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

	@Autowired

    @Autowired

	private CustomerRepository customerRepository;

    NotificationService notificationService;

    @Autowired

	private boolean accessoriesDeals = true;

    private CustomerRepository customerRepository;

    private boolean accessoriesDeals = true;

	@Autowired

    @Autowired

	private RoleManager roleManager;

    private RoleManager roleManager;

    @Autowired

	@Autowired

    private Gson gson;

	private Gson gson;

    @Autowired

    private CustomerReturnItemRepository customerReturnItemRepository;

	@Autowired

    @Autowired

	private CustomerReturnItemRepository customerReturnItemRepository;

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

	@Autowired

    private PaymentOptionRepository paymentOptionRepository;

	private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private StateRepository stateRepository;

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

    @Autowired

    private ItemRepository itemRepository;

	@Autowired

    @Autowired

	private PaymentOptionRepository paymentOptionRepository;

    private MVCResponseSender mvcResponseSender;

    @Autowired

	@Autowired

    private InsuranceService insuranceService;

	private StateRepository stateRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

	@Autowired

    @Autowired

	private ItemRepository itemRepository;

    private CustomerAddressRepository customerAddressRepository;

    @Autowired

	@Autowired

    private InsurancePolicyRepository insurancePolicyRepository;

	private MVCResponseSender mvcResponseSender;

    @Autowired

    private InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

    @Autowired

	private InsuranceService insuranceService;

    private CookiesProcessor cookiesProcessor;

    @Autowired

	@Autowired

    private PricingService pricingService;

	private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private OrderService orderService;

	@Autowired

    @Autowired

	private CustomerAddressRepository customerAddressRepository;

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    @Autowired

	@Autowired

    private AddressRepository addressRepository;

	private InsurancePolicyRepository insurancePolicyRepository;

    @Autowired

    private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

	@Autowired

    @Autowired

	private InsuranceProviderRepository insuranceProviderRepository;

    private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

    @Autowired

	@Autowired

    private ResponseSender<?> responseSender;

	private CookiesProcessor cookiesProcessor;

    @Autowired

    private PendingOrderRepository pendingOrderRepository;

	@Autowired

    @Autowired

	private PricingService pricingService;

    private OrderRepository orderRepository;

    @Autowired

	@Autowired

    private PendingOrderItemRepository pendingOrderItemRepository;

	private OrderService orderService;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

	@Autowired

    @Autowired

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    private RetailerService retailerService;

    @Autowired

	@Autowired

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	private AddressRepository addressRepository;

    @Autowired

    private TagListingRepository tagListingRepository;

	@Autowired

    @Autowired

	private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

    private PendingOrderService pendingOrderService;

    @Autowired

	@Autowired

    private EmailService emailService;

	private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

    @Autowired

    private SolrService commonSolrService;

	@Autowired

    @Autowired

	private ResponseSender<?> responseSender;

    private MouRepository mouRepository;

	@Autowired

    @RequestMapping(value = "/order")

	private PendingOrderRepository pendingOrderRepository;

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

            throws ProfitMandiBusinessException {

	@Autowired

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

	private OrderRepository orderRepository;

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

	@Autowired

        Address address = addressRepository.selectById(addressId);

	private PendingOrderItemRepository pendingOrderItemRepository;

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

	@Autowired

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

	private FofoStoreRepository fofoStoreRepository;

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

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

	@Autowired

        for (CartFofo cartFofo : cartItems) {

	private RetailerService retailerService;

            itemIds.add(cartFofo.getItemId());

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

	@Autowired

                poIds.add(cartFofo.getPoId());

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

                poItemIds.add(cartFofo.getPoItemId());

            }

	@Autowired

        }

	private TagListingRepository tagListingRepository;

        PendingOrder po = null;

	@Autowired

        Customer customer = null;

	private PendingOrderService pendingOrderService;

        PendingOrderItem poi = null;

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

	@Autowired

                loginDetails.getFofoId());

	private EmailService emailService;

        List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository

                .selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());

	@Autowired

	private SolrService commonSolrService;

        if (!poIds.isEmpty()) {

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

	@Autowired

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

	private MouRepository mouRepository;

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

                paymentOptionIds.add(23);

	@RequestMapping(value = "/order")

            }

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

        }

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        if (!poItemIds.isEmpty()) {

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

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

        }

		Address address = addressRepository.selectById(addressId);

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

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

        // HashSet<>(paymentOptionIds));

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

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

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

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

		for (CartFofo cartFofo : cartItems) {

        LOGGER.info("pendingOrder" + po);

			itemIds.add(cartFofo.getItemId());

        LOGGER.info("pendingOrderItem" + poi);

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

				poIds.add(cartFofo.getPoId());

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

				poItemIds.add(cartFofo.getPoItemId());

        model.addAttribute("stateNames",

			}

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

		}

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

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

		PendingOrder po = null;

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

		Customer customer = null;

		PendingOrderItem poi = null;

        model.addAttribute("cartItems", cartItems);

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

        model.addAttribute("pendingOrder", po);

				loginDetails.getFofoId());

        model.addAttribute("pendingOrderItem", poi);

		List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository

				.selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());

        model.addAttribute("mopPriceMap", mopPriceMap);

        model.addAttribute("paymentOptions", paymentOptions);

		if (!poIds.isEmpty()) {

        model.addAttribute("accessoriesDeals", accessoriesDeals);

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

        return "order-index";

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

    }

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

				paymentOptionIds.add(23);

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

		if (!poItemIds.isEmpty()) {

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

        try {

		}

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

            model.addAttribute("response1", response);

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

        } catch (Exception e) {

		// HashSet<>(paymentOptionIds));

            // TODO Auto-generated catch block

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

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

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

        }

		LOGGER.info("pendingOrder" + po);

		LOGGER.info("pendingOrderItem" + poi);

        return "response";

    }

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

		model.addAttribute("stateNames",

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

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

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

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

                           Model model) throws ProfitMandiBusinessException {

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

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

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

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

		model.addAttribute("cartItems", cartItems);

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

		model.addAttribute("pendingOrder", po);

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

		model.addAttribute("pendingOrderItem", poi);

        customerAddress.setPhoneNumber(customer.getMobileNumber());

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

		model.addAttribute("mopPriceMap", mopPriceMap);

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

		model.addAttribute("paymentOptions", paymentOptions);

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

		model.addAttribute("accessoriesDeals", accessoriesDeals);

                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

		return "order-index";

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

	}

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        this.addInsuranceProvider(insurancePolicies);

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

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

        model.addAttribute("fofoOrder", fofoOrder);

			@RequestParam int itemId) throws ProfitMandiBusinessException {

        model.addAttribute("fofoLineItems", fofoLineItems);

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

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

        model.addAttribute("customerBillingAddressObj", customerAddress);

		try {

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

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

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

			model.addAttribute("response1", response);

        model.addAttribute("insurancePolicies", insurancePolicies);

		} catch (Exception e) {

        return "order-details";

			// TODO Auto-generated catch block

    }

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

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

    private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(

		}

            List<InsuranceProvider> insuranceProviders) {

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

		return "response";

        for (InsuranceProvider insuranceProvider : insuranceProviders) {

	}

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

        }

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

        return insuranceProviderIdInsuranceProviderMap;

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

    }

			Model model) throws ProfitMandiBusinessException {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

    private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) {

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

        if (insurancePolicies.isEmpty()) {

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

            return;

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

        }

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

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

		customerAddress.setPhoneNumber(customer.getMobileNumber());

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

            insuranceProviderIds.add(insurancePolicy.getProviderId());

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

        }

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

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

				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

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

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

        Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

                .toInsuranceProviderIdInsuranceProvider(insuranceProviders);

		this.addInsuranceProvider(insurancePolicies);

        for (InsurancePolicy insurancePolicy : insurancePolicies) {

            insurancePolicy

		model.addAttribute("fofoOrder", fofoOrder);

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

		model.addAttribute("fofoLineItems", fofoLineItems);

        }

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

    }

		model.addAttribute("customerBillingAddressObj", customerAddress);

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

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

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

    public String getSaleDetails(HttpServletRequest request,

		model.addAttribute("insurancePolicies", insurancePolicies);

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

		return "order-details";

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

	}

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

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

	private Map<Integer, InsuranceProvider> toInsuranceProviderIdInsuranceProvider(

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

			List<InsuranceProvider> insuranceProviders) {

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

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

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

		for (InsuranceProvider insuranceProvider : insuranceProviders) {

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

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

		}

        // Added Migration info as we lost it.

		return insuranceProviderIdInsuranceProviderMap;

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

	}

            PaymentOptionTransaction pot = new PaymentOptionTransaction();

            pot.setAmount(fofoOrder.getTotalAmount());

	private void addInsuranceProvider(List<InsurancePolicy> insurancePolicies) {

            pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());

		if (insurancePolicies.isEmpty()) {

            // Mark it paid through cash

			return;

            pot.setPaymentOptionId(1);

		}

            pot.setReferenceType(PaymentOptionReferenceType.ORDER);

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

            paymentOptionTransactionRepository.persist(pot);

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

            paymentOptionTransactions.add(pot);

			insuranceProviderIds.add(insurancePolicy.getProviderId());

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

		}

        }

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

        Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

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

                .paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

		Map<Integer, InsuranceProvider> insuranceProviderIdInsuranceProviderMap = this

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

				.toInsuranceProviderIdInsuranceProvider(insuranceProviders);

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

        this.addInsuranceProvider(insurancePolicies);

			insurancePolicy

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

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

            try {

		}

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

	}

            } catch (ProfitMandiBusinessException e) {

                // TODO Auto-generated catch block

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

                return null;

	public String getSaleDetails(HttpServletRequest request,

            }

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

        }));

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

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

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

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

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

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

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

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

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

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

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

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

		// Added Migration info as we lost it.

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

        for (FofoOrderItem foi : fofoOrderItems) {

			PaymentOptionTransaction pot = new PaymentOptionTransaction();

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

			pot.setAmount(fofoOrder.getTotalAmount());

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

			pot.setCreateTimestamp(fofoOrder.getCreateTimestamp());

            }

			// Mark it paid through cash

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

			pot.setPaymentOptionId(1);

                    .selectAllByOrderItemId(foi.getId());

			pot.setReferenceType(PaymentOptionReferenceType.ORDER);

            this.markDoa(fofoOrder, foi, isAdmin);

			paymentOptionTransactionRepository.persist(pot);

            for (CustomerReturnItem customerReturnItem : customerReturnItems) {

			paymentOptionTransactions.add(pot);

                inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

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

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

		}

            }

		Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap = this

        }

				.paymentOptionIdPaymentOptionMap(paymentOptionTransactions);

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

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

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        model.addAttribute("fofoOrder", fofoOrder);

		this.addInsuranceProvider(insurancePolicies);

        model.addAttribute("itemsMap", itemsMap);

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

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

			try {

        model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

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

                StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

			} catch (ProfitMandiBusinessException e) {

        model.addAttribute("fofoOrderItemIdLineItemMap", fofoOrderItemIdLineItemMap);

				// TODO Auto-generated catch block

				return null;

        model.addAttribute("fofoOrderItems", fofoOrderItems);

			}

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

		}));

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

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

        model.addAttribute("customerBillingAddressObj", customerAddress);

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

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

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

        model.addAttribute("insurancePolicies", insurancePolicies);

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

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

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

        return "sale-details";

    }

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

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

		for (FofoOrderItem foi : fofoOrderItems) {

        if (isAdmin) {

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

            foi.setDoa(true);

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

            return;

			}

        }

			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

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

					.selectAllByOrderItemId(foi.getId());

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

			this.markDoa(fofoOrder, foi, isAdmin);

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

			for (CustomerReturnItem customerReturnItem : customerReturnItems) {

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

				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

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

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

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

			}

            foi.setDoa(true);

		}

        } else

            foi.setDoa(

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

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

		model.addAttribute("fofoOrder", fofoOrder);

    }

		model.addAttribute("itemsMap", itemsMap);

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

    private boolean markDefective(FofoOrder fofoOrder) {

		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

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

				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

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

		model.addAttribute("fofoOrderItemIdLineItemMap", fofoOrderItemIdLineItemMap);

    }

		model.addAttribute("fofoOrderItems", fofoOrderItems);

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

    @RequestMapping(value = "/getSearchOrder")

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

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

		model.addAttribute("customerBillingAddressObj", customerAddress);

        return "search-order";

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

    }

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

		model.addAttribute("insurancePolicies", insurancePolicies);

    @RequestMapping(value = "/getInvoiceSearchOrder")

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

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

		return "sale-details";

        return "invoices-cancel";

	}

    }

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

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

		if (isAdmin) {

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

			foi.setDoa(true);

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

			return;

            throws Exception {

		}

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

        orderService.updateCustomerDetails(customCustomer, invoiceNumber);

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

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

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

    }

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

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

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

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

    public String getSearchOrderDetails(HttpServletRequest request,

			foi.setDoa(true);

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

		} else

            throws Exception {

			foi.setDoa(

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

        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

	}

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

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

	private boolean markDefective(FofoOrder fofoOrder) {

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

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

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

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

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

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

	}

            try {

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

	@RequestMapping(value = "/getSearchOrder")

            } catch (ProfitMandiBusinessException e) {

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

                // TODO Auto-generated catch block

		return "search-order";

                return null;

	}

            }

        }));

	@RequestMapping(value = "/getInvoiceSearchOrder")

        LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);

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

        List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

		return "invoices-cancel";

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

	}

        LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);

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

        Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

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

                .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

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

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

			throws Exception {

        List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

                .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

		orderService.updateCustomerDetails(customCustomer, invoiceNumber);

        this.addInsuranceProvider(insurancePolicies);

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

        model.addAttribute("fofoOrder", fofoOrder);

	}

        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

            fofoOrderItem.setDoa(true);

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

        }

	public String getSearchOrderDetails(HttpServletRequest request,

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

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

			throws Exception {

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

		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

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

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

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

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

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

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

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

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

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

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

        for (FofoOrderItem foi : fofoOrderItems) {

			try {

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

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

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

			} catch (ProfitMandiBusinessException e) {

            }

				// TODO Auto-generated catch block

            List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

				return null;

                    .selectAllByOrderItemId(foi.getId());

			}

            for (CustomerReturnItem customerReturnItem : customerReturnItems) {

		}));

                inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

		LOGGER.info("fofoPartnerPaymentOptions" + fofoPartnerPaymentOptions);

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

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

            }

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

        }

		LOGGER.info("paymentOptionTransactions" + paymentOptionTransactions);

        model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

                StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

		Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

        model.addAttribute("fofoOrderItems", fofoOrderItems);

				.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

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

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

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

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

        model.addAttribute("itemsMap", itemsMap);

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

        model.addAttribute("markDefective", true);

		this.addInsuranceProvider(insurancePolicies);

        model.addAttribute("customer", customer);

		model.addAttribute("fofoOrder", fofoOrder);

        model.addAttribute("customerAddress", customerAddress);

		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

        model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

			fofoOrderItem.setDoa(true);

        model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

		}

        model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);

        model.addAttribute("insurancePolicies", insurancePolicies);

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

        model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);

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

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

        model.addAttribute("stateNames",

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

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

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

        return "search-order-details";

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

    }

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

    private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(

            List<PaymentOptionTransaction> paymentOptionTransactions) {

		for (FofoOrderItem foi : fofoOrderItems) {

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

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

        for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

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

            paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());

			}

        }

			List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository

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

					.selectAllByOrderItemId(foi.getId());

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

			for (CustomerReturnItem customerReturnItem : customerReturnItems) {

        for (PaymentOption paymentOption : paymentOptions) {

				inventoryItemBilledQtyMap.put(customerReturnItem.getInventoryItemId(),

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

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

        }

			}

        return paymentOptionIdPaymentOptionMap;

		}

    }

		model.addAttribute("foiIdCustomerReturnInventoryItemsMap",

				StringUtils.toString(foiIdCustomerReturnInventoryItemsMap));

    private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(

		model.addAttribute("fofoOrderItems", fofoOrderItems);

            List<Integer> fofoPartnerPaymentOptions) {

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

        List<PaymentOption> paymentOptions = paymentOptionRepository

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

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

		model.addAttribute("itemsMap", itemsMap);

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

		model.addAttribute("markDefective", true);

        for (PaymentOption paymentOption : paymentOptions) {

		model.addAttribute("customer", customer);

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

		model.addAttribute("customerAddress", customerAddress);

        }

		model.addAttribute("paymentOptionTransactions", paymentOptionTransactions);

        return paymentOptionIdPaymentOptionMap;

		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);

    }

		model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);

		model.addAttribute("insurancePolicies", insurancePolicies);

    private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(

		model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);

            List<PaymentOptionTransaction> paymentOptionTransactions) {

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

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

		model.addAttribute("stateNames",

        for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

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

            paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),

		return "search-order-details";

                    paymentOptionTransaction);

	}

        }

        return paymentOptionIdPaymentOptionTransactionMap;

	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(

    }

			List<PaymentOptionTransaction> paymentOptionTransactions) {

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

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

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

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

			paymentOptionIds.add(paymentOptionTransaction.getPaymentOptionId());

                              Model model) throws ProfitMandiBusinessException {

		}

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

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

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

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

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

		for (PaymentOption paymentOption : paymentOptions) {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

		}

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

		return paymentOptionIdPaymentOptionMap;

	}

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

        try {

	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMapUsingPaymentOptions(

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

			List<Integer> fofoPartnerPaymentOptions) {

        } catch (Exception e) {

		List<PaymentOption> paymentOptions = paymentOptionRepository

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

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

            e.printStackTrace();

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

        }

		for (PaymentOption paymentOption : paymentOptions) {

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

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

    }

		}

		return paymentOptionIdPaymentOptionMap;

    private void sendWhatsappInvoice(FofoOrder fofoOrder) throws Exception {

	}

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

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

	private Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap(

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

			List<PaymentOptionTransaction> paymentOptionTransactions) {

                "Thank you for purchasing from SmartDukaan from our Store %s, %s.\n" +

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

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

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

                "\n" +

			paymentOptionIdPaymentOptionTransactionMap.put(paymentOptionTransaction.getPaymentOptionId(),

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

					paymentOptionTransaction);

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

		}

                "\n" +

		return paymentOptionIdPaymentOptionTransactionMap;

                "Best Regards\n" +

	}

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

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

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

    }

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

			Model model) throws ProfitMandiBusinessException {

    private String getFileName(String invoiceNumber) {

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

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

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

    }

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

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

    private String getPublicInvoiceUrl(String invoiceNumber) {

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

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

        return publicUrl;

    }

		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 {

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

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

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

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

			Model model) throws ProfitMandiBusinessException {

        CustomerCreditNote custmoerCreditNote;

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

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

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

		CustomerCreditNote custmoerCreditNote;

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

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

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

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

        } else {

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

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

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

        }

		} else {

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

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

    }

		}

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

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

	}

    public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response, @PathVariable String partnerCode, @PathVariable int number) throws ProfitMandiBusinessException {

        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(partnerCode + "/" + number);

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

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

	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response, @PathVariable String partnerCode, @PathVariable int number) throws ProfitMandiBusinessException {

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(partnerCode + "/" + number);

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

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

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

        final HttpHeaders headers = new HttpHeaders();

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

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

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

        int contentLength = byteArrayOutputStream.toByteArray().length;

		final HttpHeaders headers = new HttpHeaders();

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

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

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

        return ResponseEntity.ok()

		int contentLength = byteArrayOutputStream.toByteArray().length;

                .headers(headers)

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

                .contentLength(contentLength)

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

		return ResponseEntity.ok()

                .body(inputStreamResource);

				.headers(headers)

    }

				.contentLength(contentLength)

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

    @

				.body(inputStreamResource);

	}

            PostMapping(value = "/wa-listen")

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

	@RequestMapping(value = "/generateInvoice")

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

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

    @RequestMapping(value = "/generateInvoice")

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

		InvoicePdfModel pdfModel = null;

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

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

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

			pdfModel = orderService.getInvoicePdfModel(orderId);

                ProfitMandiConstants.ORDER_ID, orderId);

		} else {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

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

        InvoicePdfModel pdfModel = null;

		}

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

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

            pdfModel = orderService.getInvoicePdfModel(orderId);

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

        } else {

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

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

		final HttpHeaders headers = new HttpHeaders();

        }

		headers.setContentType(MediaType.APPLICATION_PDF);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

        PdfUtils.generateAndWrite(Arrays.asList(pdfModel), 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, headers, HttpStatus.OK);

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

	}

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

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

	@RequestMapping(value = "/generateInvoices")

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

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

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

    }

			throws ProfitMandiBusinessException {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

    @RequestMapping(value = "/generateInvoices")

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

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

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

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

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

            throws ProfitMandiBusinessException {

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

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

			for (int orderId : orderIds) {

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

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

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

			}

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

			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

			PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

            for (int orderId : orderIds) {

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

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

			final HttpHeaders headers = new HttpHeaders();

            }

			headers.setContentType(MediaType.APPLICATION_PDF);

            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

            PdfUtils.generateAndWrite(pdfModels, 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-" + partnerId + ".pdf");

		} else {

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

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

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

		}

            final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

	}

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

        } else {

	@RequestMapping(value = "/saleHistory")

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

	public String saleHistory(HttpServletRequest request,

        }

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

    }

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

			@RequestParam(required = false) LocalDateTime startTime,

    @RequestMapping(value = "/saleHistory")

			@RequestParam(required = false) LocalDateTime endTime,

    public String saleHistory(HttpServletRequest request,

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

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

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

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

			throws ProfitMandiBusinessException {

                              @RequestParam(required = false) LocalDateTime startTime,

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

                              @RequestParam(required = false) LocalDateTime endTime,

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

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

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

				startTime, endTime, offset, limit);

            throws ProfitMandiBusinessException {

		model.addAllAttributes(map);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		return "sale-history";

	}

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

                startTime, endTime, offset, limit);

	@RequestMapping(value = "/downloadInvoices")

        model.addAllAttributes(map);

	public ResponseEntity<?> downloadInvoices(HttpServletRequest request,

        return "sale-history";

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

    }

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

			@RequestParam(required = false) LocalDateTime startTime,

    @RequestMapping(value = "/downloadInvoices")

			@RequestParam(required = false) LocalDateTime endTime,

    public ResponseEntity<?> downloadInvoices(HttpServletRequest request,

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

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

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

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

			throws ProfitMandiBusinessException {

                                              @RequestParam(required = false) LocalDateTime startTime,

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

                                              @RequestParam(required = false) LocalDateTime endTime,

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

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

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

				startTime, endTime, offset, 100);

            throws ProfitMandiBusinessException {

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

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

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

                startTime, endTime, offset, 100);

		}

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

		final HttpHeaders headers = new HttpHeaders();

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

		headers.setContentType(MediaType.APPLICATION_PDF);

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

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

        }

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

        final HttpHeaders headers = new HttpHeaders();

		for (FofoOrder fofoOrder : fofoOrders) {

        headers.setContentType(MediaType.APPLICATION_PDF);

			try {

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

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

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

			} catch (Exception e) {

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

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

        for (FofoOrder fofoOrder : fofoOrders) {

						fofoOrder.getInvoiceNumber());

            try {

			}

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

		}

            } catch (Exception e) {

		PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

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

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

                        fofoOrder.getInvoiceNumber());

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

            }

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

        }

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

        PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);

	}

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

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

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

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

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

			throws ProfitMandiBusinessException {

    }

		CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

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

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

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

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

            throws ProfitMandiBusinessException {

		final HttpHeaders headers = new HttpHeaders();

        CreditNotePdfModel creditNotePdfModel = orderService.getCreditNotePdfModel(creditNoteId);

		headers.setContentType(MediaType.APPLICATION_PDF);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		headers.set("Content-disposition",

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

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

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

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

        final HttpHeaders headers = new HttpHeaders();

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

        headers.setContentType(MediaType.APPLICATION_PDF);

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

        headers.set("Content-disposition",

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

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

	}

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

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

	@RequestMapping(value = "/getPaginatedSaleHistory")

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

	public String getSaleHistoryPaginated(HttpServletRequest request,

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

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

    }

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

			@RequestParam(required = false) LocalDateTime startTime,

    @RequestMapping(value = "/getPaginatedSaleHistory")

			@RequestParam(required = false) LocalDateTime endTime,

    public String getSaleHistoryPaginated(HttpServletRequest request,

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

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

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

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

			throws ProfitMandiBusinessException {

                                          @RequestParam(required = false) LocalDateTime startTime,

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

                                          @RequestParam(required = false) LocalDateTime endTime,

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

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

				searchValue, startTime, endTime, offset, limit);

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

		model.addAllAttributes(map);

            throws ProfitMandiBusinessException {

		return "sale-history-paginated";

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

	}

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

                searchValue, startTime, endTime, offset, limit);

	@PutMapping(value = "/updatePaymentTransaction")

        model.addAllAttributes(map);

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

        return "sale-history-paginated";

			@RequestParam int fofoId, @RequestParam int referenceId,

    }

			@RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,

			@RequestParam float totalAmount, Model model) throws Exception {

    @PutMapping(value = "/updatePaymentTransaction")

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

		List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel

                                           @RequestParam int fofoId, @RequestParam int referenceId,

				.getPaymentOptionTransactionModel();

                                           @RequestBody PartnerOptionsAndItemAmountModel partnerOptionsAndItemAmountModel,

		LOGGER.info(paymentOptionTransactionModels);

                                           @RequestParam float totalAmount, Model model) throws Exception {

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

		LOGGER.info("sdssd" + fofoOrder);

        List<PaymentOptionTransactionModel> paymentOptionTransactionModels = partnerOptionsAndItemAmountModel

		fofoOrder.setTotalAmount(totalAmount);

                .getPaymentOptionTransactionModel();

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

        LOGGER.info(paymentOptionTransactionModels);

		for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {

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

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

        LOGGER.info("sdssd" + fofoOrder);

        fofoOrder.setTotalAmount(totalAmount);

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

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

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

        for (FofoItemIdAmountModel fim : fofoItemIdAmountModel) {

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

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

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

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

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

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

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

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

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

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

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

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

						fofoOrderItem.setSellingPrice(fim.getAmount());

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

					} else {

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

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

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

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

					}

                        fofoOrderItem.setSellingPrice(fim.getAmount());

                    } else {

					LOGGER.info("fofoOrderItem2" + fofoOrderItem);

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

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

				} else {

                    }

					// TODO below mop condition need to added added

					fofoOrderItem.setSellingPrice(fim.getAmount());

                    LOGGER.info("fofoOrderItem2" + fofoOrderItem);

				}

                } else {

			} else {

                    // TODO below mop condition need to added added

				fofoOrderItem.setSellingPrice(fim.getAmount());

                    fofoOrderItem.setSellingPrice(fim.getAmount());

				LOGGER.info("fofoOrderItem1" + fofoOrderItem);

                }

			}

            } else {

			LOGGER.info("fofoOrderItem" + fofoOrderItem);

                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.getUnitPrice() + "amount" + amount); if (amount ==

        /*

		 * fofoOrder.getUnitPrice()) {

         * for (PaymentOptionTransactionModel paymentOptionTransactionModel :

		 */

         * paymentOptionTransactionModels) { amount = amount +

		if (paymentOptionTransactionModels.size() > 0) {

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

			List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

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

					.selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);

         * fofoOrder.getUnitPrice()) {

			Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

         */

					.paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

        if (paymentOptionTransactionModels.size() > 0) {

			LOGGER.info(

            List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

					"paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

                    .selectByReferenceIdAndType(referenceId, PaymentOptionReferenceType.ORDER);

			for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {

            Map<Integer, PaymentOptionTransaction> paymentOptionIdPaymentOptionTransactionMap = this

				if (paymentOptionIdPaymentOptionTransactionMap

                    .paymentOptionIdPaymentOptionTransactionMap(paymentOptionTransactions);

						.containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {

            LOGGER.info(

                    "paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());

					PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap

            for (PaymentOptionTransactionModel paymentOptionTransactionModel : paymentOptionTransactionModels) {

							.get(paymentOptionTransactionModel.getPaymentOptionId());

                if (paymentOptionIdPaymentOptionTransactionMap

                        .containsKey(paymentOptionTransactionModel.getPaymentOptionId())) {

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

						paymentOptionTransactionRepository.delete(paymentOptionTransaction);

                    PaymentOptionTransaction paymentOptionTransaction = paymentOptionIdPaymentOptionTransactionMap

						LOGGER.info("deleted successfully");

                            .get(paymentOptionTransactionModel.getPaymentOptionId());

					} else {

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

						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

                        paymentOptionTransactionRepository.delete(paymentOptionTransaction);

						paymentOptionTransactionRepository.persist(paymentOptionTransaction);

                        LOGGER.info("deleted successfully");

						LOGGER.info("updated successfully");

                    } else {

					}

                        paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

				} else {

                        paymentOptionTransactionRepository.persist(paymentOptionTransaction);

					if (paymentOptionTransactionModel.getAmount() > 0) {

                        LOGGER.info("updated successfully");

						PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

						paymentOptionTransaction.setReferenceId(referenceId);

                    }

						paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);

                } else {

						paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());

                    if (paymentOptionTransactionModel.getAmount() > 0) {

						paymentOptionTransaction.setAmount(paymentOptionTransactionModel.getAmount());

                        PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();

						paymentOptionTransaction.setFofoId(fofoId);

                        paymentOptionTransaction.setReferenceId(referenceId);

						paymentOptionTransaction.setCreateTimestamp(fofoOrder.getCreateTimestamp());

                        paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);

						paymentOptionTransactionRepository.persist(paymentOptionTransaction);

                        paymentOptionTransaction.setPaymentOptionId(paymentOptionTransactionModel.getPaymentOptionId());

						LOGGER.info("inserted successfully");

                        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

		 * 

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

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

        }

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

        /*

		 */

         * else

         *

		return "response";

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

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

	}

         */

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

        return "response";

			throws ProfitMandiBusinessException {

		try {

    }

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

					sellingPrice);

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

			return productDurationPlans;

            throws ProfitMandiBusinessException {

		} catch (Exception e) {

        try {

			LOGGER.info(e, e);

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

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

                    sellingPrice);

					"Could not fetch insurance Plans");

            return productDurationPlans;

		}

        } catch (Exception e) {

            LOGGER.info(e, e);

	}

            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 {

    @GetMapping("/insuranceDetails")

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    public String getInsuranceDetails(HttpServletRequest request,

		long size = 0;

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

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

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

				offset, limit);

            throws ProfitMandiBusinessException {

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

        long size = 0;

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

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

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

                offset, limit);

		if (size < limit) {

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

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

        Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

		} else {

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

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

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

		}

        if (size < limit) {

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

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

		model.addAttribute("size", size);

        } else {

		model.addAttribute("insurancePolicies", insurancePolicies);

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

		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);

        }

		return "insurance-details";

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

	}

        model.addAttribute("size", size);

        model.addAttribute("insurancePolicies", insurancePolicies);

	@GetMapping("/insuranceDetailsPaginated")

        model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);

	public String getInsuranceDetailsPaginated(HttpServletRequest request,

        return "insurance-details";

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

    }

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

			throws ProfitMandiBusinessException {

    @GetMapping("/insuranceDetailsPaginated")

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    public String getInsuranceDetailsPaginated(HttpServletRequest request,

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

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

				offset, limit);

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

		Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

            throws ProfitMandiBusinessException {

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

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

		model.addAttribute("insurancePolicies", insurancePolicies);

                offset, limit);

		model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);

        Map<Integer, String> providerPolicyNameAndIdMap = insuranceProviderRepository

		return "insurance-details-paginated";

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

	}

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

        model.addAttribute("insurancePolicies", insurancePolicies);

	@GetMapping("/getMouForm")

        model.addAttribute("providerPolicyNameAndIdMap", providerPolicyNameAndIdMap);

	public String getMouForm(HttpServletRequest request, Model model) throws Exception {

        return "insurance-details-paginated";

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    }

		Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());

    @GetMapping("/getMouForm")

		if (mou != null) {

    public String getMouForm(HttpServletRequest request, Model model) throws Exception {

			if (mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

			} else {

        Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());

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

        if (mou != null) {

			}

            if (mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {

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

		} else {

            } else {

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

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

            }

		}

		return "response";

        } else {

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

	}

        }

	@GetMapping("/pendingOrders")

        return "response";

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    }

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

		Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());

    @GetMapping("/pendingOrders")

		if (mou == null) {

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

			mou = new Mou();

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

			mou.setFofoId(loginDetails.getFofoId());

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

			mou.setCreateTimestamp(LocalDateTime.now());

        Mou mou = mouRepository.selectByFofoId(loginDetails.getFofoId());

			mou.setUpdateTimestamp(LocalDateTime.now());

        if (mou == null) {

			mouRepository.persist(mou);

            mou = new Mou();

		} else if (!mou.getUpdateTimestamp().getMonth().equals(LocalDateTime.now().getMonth())) {

            mou.setFofoId(loginDetails.getFofoId());

			mou.setUpdateTimestamp(LocalDateTime.now());

            mou.setCreateTimestamp(LocalDateTime.now());

		}

            mou.setUpdateTimestamp(LocalDateTime.now());

            mouRepository.persist(mou);