Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.DoubleSummaryStatistics;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.thrift.TException;

import org.json.JSONArray;

import org.json.JSONObject;

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

import org.springframework.core.io.ByteArrayResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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

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

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

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

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

import com.mongodb.TaggableReadPreference;

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.transaction.Order;

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;

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

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

import com.spice.profitmandi.service.inventory.StockAllocationService;

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

import com.spice.profitmandi.thrift.clients.PaymentClient;

import com.spice.profitmandi.thrift.clients.TransactionClient;

import com.spice.profitmandi.thrift.clients.UserClient;

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

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

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

import in.shop2020.logistics.PickUpType;

import in.shop2020.model.v1.order.LineItem;

import in.shop2020.model.v1.order.OrderSource;

import in.shop2020.model.v1.order.OrderStatus;

import in.shop2020.model.v1.order.OrderType;

import in.shop2020.model.v1.order.Transaction;

import in.shop2020.model.v1.order.TransactionService;

import in.shop2020.model.v1.order.TransactionStatus;

import in.shop2020.model.v1.user.ItemPriceQuantity;

import in.shop2020.model.v1.user.ShoppingCartException;

import in.shop2020.model.v1.user.UserContextService.Client;

import in.shop2020.model.v1.user.UserContextService.forgotPassword_args;

import in.shop2020.payments.Attribute;

import in.shop2020.payments.PaymentException;

import in.shop2020.payments.PaymentStatus;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class IndentController {

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

	private static final int WALLET_GATEWAY_ID = 8;

	private static final Set<Integer> defaultTags = new HashSet<Integer>(Arrays.asList(4));

	private final List<OrderStatus> validOrderStatusList = Arrays.asList(OrderStatus.ACCEPTED,

			OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.BILLED, OrderStatus.SHIPPED_FROM_WH,

			OrderStatus.DELIVERY_SUCCESS, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.SHIPPED_TO_LOGST,

			OrderStatus.REACHED_DESTINATION_CITY);

	private final List<OrderStatus> partnerPendingOrderList = Arrays.asList(OrderStatus.ACCEPTED,

			OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.BILLED, OrderStatus.SHIPPED_FROM_WH,

			OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.SHIPPED_TO_LOGST,

			OrderStatus.REACHED_DESTINATION_CITY);

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private UserWalletRepository userWalletRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	FofoStoreRepository fofoStoreRepository;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private StockAllocationService stockAllocationService;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	private PurchaseRepository purchaseRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	RoleManager roleManager;

	@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)

	public String saveOpenIndent(HttpServletRequest request, Model model,

			@RequestBody List<StockAllocationModel> stockAllocationModelList, @RequestParam int fofoId,

			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		boolean response = false;

		if (fofoId > 0) {

			FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

			stockAllocationModelList.forEach(x -> {

				x.setFofoId(fofoId);

				x.setCounterSize(fs.getCounterSize());

			});

		} else {

			stockAllocationModelList.forEach(x -> {

				x.setFofoId(fofoId);

				x.setCounterSize(counterSize);

			});

		}

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

			response = stockAllocationService.addToAllocation(stockAllocationModelList);

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

		}

		return "response";

	}

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

	public ResponseEntity<ByteArrayResource> downloadIndent(HttpServletRequest request, Model model,

			@RequestParam(required = false, defaultValue = "0") int fofoId,

			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {

		Set<Integer> roleIds = cookiesProcessor.getCookiesObject(request).getRoleIds();

		LOGGER.info("Counter size is {}", counterSize);

		LOGGER.info("Fofo Id is {}", fofoId);

		if (roleManager.isAdmin(roleIds)) {

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

					.collect(Collectors.toList());

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

			List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,

					true);

			Map<Integer, Integer> modelStockAllocationMap = stockAllocationList.stream()

					.collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getQuantity()));

			Map<String, Integer> catalogUserQtyMap = new HashMap<>();

			currentInventorySnapshotRepository.selectAll(Optional.of(true)).stream().forEach(x -> {

				int retailerId = x.getFofoId();

				int catalogId;

				try {

					catalogId = itemRepository.selectById(x.getItemId()).getCatalogItemId();

					String key = catalogId + "-" + retailerId;

					if (!catalogUserQtyMap.containsKey(key)) {

						catalogUserQtyMap.put(key, 0);

					}

					catalogUserQtyMap.put(key, catalogUserQtyMap.get(key) + x.getAvailability());

				} catch (ProfitMandiBusinessException e) {

					// TODO Auto-generated catch block

					throw new RuntimeException(e);

				}

			});

			List<Order> inTransitOrders = orderRepository.selectOrders(fofoIds, partnerPendingOrderList);

			Map<String, Integer> catalogUserInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> {

				try {

					return itemRepository.selectById(x.getLineItem().getItemId()).getCatalogItemId() + "-"

							+ x.getRetailerId();

				} catch (ProfitMandiBusinessException e) {

					// TODO Auto-generated catch block

					return "";

				}

			}, Collectors.summingInt(x -> x.getLineItem().getQuantity())));

			Map<String, CatalogListingModel> catalogListingMap = new HashMap<>();

			List<TagListing> tagListings = tagListingRepository.selectAll(true);

			Iterator<TagListing> iterator = tagListings.iterator();

			while (iterator.hasNext()) {

				TagListing tagListing = iterator.next();

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

				int catalogId = item.getCatalogItemId();

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

					continue;

				}

				int catalogStockAllocationQuantity = modelStockAllocationMap.containsKey(catalogId)

						? modelStockAllocationMap.get(catalogId)

						: 0;

				for (int retailerId : fofoIds) {

					String key = catalogId + "-" + retailerId;

					if (catalogListingMap.containsKey(key)) {

						continue;

					}

					int catalogInTransit = catalogUserInTransit.containsKey(key) ? catalogUserInTransit.get(key) : 0;

					int catalogInStock = catalogUserQtyMap.containsKey(key) ? catalogUserQtyMap.get(key) : 0;

					if (catalogInTransit + catalogInStock == 0 && catalogStockAllocationQuantity == 0) {

						continue;

					}

					CatalogListingModel catalogListingModel = new CatalogListingModel();

					catalogListingModel.setFofoId(retailerId);

					catalogListingModel.setModelName(item.getModelName());

					catalogListingModel.setModelNumber(item.getModelNumber());

					catalogListingModel.setCatalogId(catalogId);

					catalogListingModel.setDp(tagListing.getSellingPrice());

					catalogListingModel.setMop(tagListing.getMop());

					catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

					catalogListingModel.setAllocatedQuantity(catalogStockAllocationQuantity);

					catalogListingModel.setInTransitQuantity(catalogInTransit);

					catalogListingModel

							.setToBeOrdered(catalogStockAllocationQuantity - catalogInTransit - catalogInStock);

					catalogListingModel.setStockInHand(catalogInStock);

					catalogListingModel.setBrand(item.getBrand());

					catalogListingModel.setModelName(item.getModelName());

					catalogListingModel.setModelNumber(item.getModelNumber());

					catalogListingModel.setCategoryId(item.getCategoryId());

					catalogListingMap.put(key, catalogListingModel);

				}

			}

			List<List<Object>> listOfRows = new ArrayList<>();

			for (CatalogListingModel clm : catalogListingMap.values()) {

				CustomRetailer cr = customRetailersMap.get(clm.getFofoId());

				listOfRows.add(Arrays.asList(cr.getPartnerId(), cr.getBusinessName(), clm.getCatalogId(),

						clm.getBrand(), clm.getModelName(), clm.getModelNumber(), clm.getDp(), clm.getMop(),

						clm.getAllocatedQuantity(), clm.getInTransitQuantity(), clm.getStockInHand(),

						clm.getToBeOrdered()));

			}

			ByteArrayOutputStream baos = FileUtil

					.getCSVByteStream(

							Arrays.asList("StoreId", "StoreName", "Catalog Id", "Brand", "Model Name", "Model Number",

									"DP", "MOP", "Allocated Quantity", "In Transit", "Stock In hand", "Shortage"),

							listOfRows);

			HttpHeaders headers = new HttpHeaders();

			headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

			headers.set("Content-disposition", "inline; filename=retailer-allocation.csv");

			return new ResponseEntity<ByteArrayResource>(new ByteArrayResource(baos.toByteArray()), headers,

					HttpStatus.OK);

		}

		return null;

	}

	@RequestMapping(value = "/itemsByCatalogId")

	public String getItemsByCatalogId(HttpServletRequest request, Model model,

			@RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)

			throws ProfitMandiBusinessException 

	{

		if (catalogId == 0) {

			catalogId = itemRepository.selectById(itemId).getCatalogItemId();

		}

		List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);

		LOGGER.info("Items {}", items);

		Map<Integer, String> itemsColorMap = items.stream().filter(x->x.getColorNatural().startsWith("f_")).collect(Collectors.toMap(Item::getId, Item::getColor));

		Map<Integer, TagListing> tagsMap = tagListingRepository

				.selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

				.stream().collect(Collectors.toMap(TagListing::getItemId, x->x));

		LOGGER.info("Items color map {}", itemsColorMap);

		JSONArray response = new JSONArray();

		itemsColorMap.keySet().stream().forEach(x -> {

			response.put(

				new JSONObject()

					.put("color", itemsColorMap.get(x))

					.put("id", x)

					.put("active", tagsMap.get(x)==null ? false : tagsMap.get(x).isActive()));

		});

		model.addAttribute("response", response.toString());

		return "response";

	}

	@RequestMapping(value = "/indent/loadIndent")

	public String loadOpenIndent(HttpServletRequest request, Model model,

			@RequestParam(required = false, defaultValue = "0") int fofoId,

			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws ProfitMandiBusinessException {

		Set<Integer> roleIds = cookiesProcessor.getCookiesObject(request).getRoleIds();

		LOGGER.info("Counter size is {}", counterSize);

		LOGGER.info("Fofo Id is {}", fofoId);

		Map<Integer, ItemIdAvailability> itemCisMap = null;

		if (!roleManager.isAdmin(roleIds)) {

			fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();

			List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository

					.selectItemsStock(fofoId);

			itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)

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

		} else {

			if (fofoId == 0) {

				List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository

						.selectItemsStock();

				itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)

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

			} else {

				List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository

						.selectItemsStock(fofoId);

				itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)

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

			}

		}

		List<BrandPerformance> brandPerformanceList = new ArrayList<>();

		List<BrandPerformance> accsBrandPerformanceList = new ArrayList<>();

		List<StockAllocationModel> stockAllocationList;

		if (fofoId > 0) {

			stockAllocationList = stockAllocationService.getStockAllocation(fofoId, true);

		} else {

			stockAllocationList = stockAllocationService.getStockAllocation(counterSize, true);

		}

		LOGGER.info("Stock Allocation list  is {}", stockAllocationList);

		Map<Integer, StockAllocationModel> itemStockAllocationMap = stockAllocationList.stream()

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

		Map<Integer, Integer> itemsInTransit = null;

		LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);

		List<TagListing> tagListings = tagListingRepository.selectAll(true);

		if (!roleManager.isAdmin(roleIds)) {

			tagListings = new ArrayList<>(tagListings);

			List<Order> inTransitOrders = orderRepository.selectOrders(fofoId, validOrderStatusList);

			inTransitOrders = this.filterValidOrders(inTransitOrders);

			itemsInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),

					Collectors.summingInt(x -> x.getLineItem().getQuantity())));

		} else {

			itemsInTransit = new HashMap<>();

		}

		Iterator<TagListing> iterator = tagListings.iterator();

		int totalPcs = 0;

		int toBeOrdered = 0;

		float totalAmount = 0;

		Map<Integer, CatalogListingModel> catalogListingMap = new HashMap<>();

		while (iterator.hasNext()) {

			TagListing tagListing = iterator.next();

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

			// itemRepository.select

			// catalogTagListingMap

			if (roleManager.isAdmin(roleIds)) {

				if (item.getBrand() == null || item.getCategoryId() != 10006) {

					iterator.remove();

					continue;

				}

			} else {

				if (!(itemCisMap.containsKey(tagListing.getItemId())

						|| itemStockAllocationMap.containsKey(tagListing.getItemId()))) {

					iterator.remove();

					continue;

				}

			}

			int catalogId = item.getCatalogItemId();

			CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);

			if (!catalogListingMap.containsKey(catalogId)) {

				catalogListingModel = new CatalogListingModel();

				catalogListingModel.setCatalogId(catalogId);

				catalogListingModel.setDp(tagListing.getSellingPrice());

				catalogListingModel.setMop(tagListing.getMop());

				catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

				StockAllocationModel stockAllocationModel = itemStockAllocationMap.get(item.getCatalogItemId());

				int stockAllocationQuantity = stockAllocationModel == null ? 0 : stockAllocationModel.getQuantity();

				catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);

				catalogListingModel.setToBeOrdered(stockAllocationQuantity);

				catalogListingModel.setBrand(item.getBrand());

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

					catalogListingModel.setCategoryId(item.getCategoryId());

				}

				catalogListingMap.put(catalogId, catalogListingModel);

			}

			ItemIdAvailability itemIdAvailability = itemCisMap.get(tagListing.getItemId());

			int itemAvailability = itemIdAvailability == null ? 0 : itemIdAvailability.getAvailability();

			catalogListingModel.setStockInHand(catalogListingModel.getStockInHand() + itemAvailability);

			Integer inTransitQuantity = itemsInTransit.get(item.getId());

			int inTransitQty = (inTransitQuantity == null ? 0 : inTransitQuantity);

			catalogListingModel.setInTransitQuantity(catalogListingModel.getInTransitQuantity() + inTransitQty);

			if (catalogListingModel.getAllocatedQuantity() > 0) {

				toBeOrdered = Math.max(catalogListingModel.getToBeOrdered() - inTransitQty - itemAvailability, 0);

				catalogListingModel.setToBeOrdered(toBeOrdered);

			}

		}

		List<CatalogListingModel> catalogModelList = new ArrayList<>(catalogListingMap.values());

		Map<Boolean, List<CatalogListingModel>> performanceMap = catalogModelList.stream()

				.collect(Collectors.groupingBy(x -> x.getCategoryId() == 10006));

		List<CatalogListingModel> mobileListing = performanceMap.get(true) == null ? new ArrayList<>()

				: performanceMap.get(true);

		List<CatalogListingModel> accsListing = performanceMap.get(false) == null ? new ArrayList<>()

				: performanceMap.get(false);

		Map<String, DoubleSummaryStatistics> accsStats = accsListing.stream().collect(Collectors.groupingBy(

				x -> x.getBrand(), Collectors.summarizingDouble(x -> x.getAllocatedQuantity() * x.getMop())));

		Map<String, DoubleSummaryStatistics> mobStats = mobileListing.stream().collect(Collectors.groupingBy(

				x -> x.getBrand(), Collectors.summarizingDouble(x -> x.getAllocatedQuantity() * x.getMop())));

		for (Map.Entry<String, DoubleSummaryStatistics> entry : mobStats.entrySet()) {

			DoubleSummaryStatistics dss = entry.getValue();

			BrandPerformance bp = new BrandPerformance();

			bp.setTarget((float) dss.getSum());

			bp.setBrandName(entry.getKey());

			brandPerformanceList.add(bp);

		}

		for (Map.Entry<String, DoubleSummaryStatistics> entry : accsStats.entrySet()) {

			DoubleSummaryStatistics dss = entry.getValue();

			BrandPerformance bp = new BrandPerformance();

			bp.setTarget((float) dss.getSum());

			bp.setBrandName(entry.getKey());

			accsBrandPerformanceList.add(bp);

		}

		brandPerformanceList = brandPerformanceList.stream().filter(x -> x.getTarget() > 0)

				.sorted(Comparator.comparing(x -> x.getTarget())).collect(Collectors.toList());

		accsBrandPerformanceList = accsBrandPerformanceList.stream().filter(x -> x.getTarget() > 0)

				.sorted(Comparator.comparing(x -> x.getTarget())).collect(Collectors.toList());

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

				.collect(Collectors.toList());

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

		if (fofoId > 0) {

			CustomRetailer customRetailer = customRetailersMap.get(fofoId);

			model.addAttribute("retailerName",

					customRetailer.getBusinessName() + "-" + customRetailer.getAddress().getCity());

			FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

			model.addAttribute("retailerId", customRetailer.getPartnerId());

			model.addAttribute("counterSize", fs.getCounterSize().toString());

		} else {

			model.addAttribute("counterSize", counterSize.toString());

		}

		String customRetailers = JSONObject.valueToString(customRetailersMap.values());

		LOGGER.info("Custom retailers {}", customRetailers);

		// Lits<CatalogTagListing> catalog

		Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getToBeOrdered,

				Comparator.reverseOrder());

		model.addAttribute("catalogTagListings",

				catalogModelList.stream().sorted(firstCmp).collect(Collectors.toList()));

		model.addAttribute("customRetailers", customRetailers);

		model.addAttribute("brandPerformanceList", brandPerformanceList);

		model.addAttribute("accsBrandPerformanceList", accsBrandPerformanceList);

		model.addAttribute("counterSizes", CounterSize.values());

		model.addAttribute("isAdmin", roleManager.isAdmin(roleIds));

		model.addAttribute("totalAmount", totalAmount);

		model.addAttribute("totalPcs", totalPcs);

		model.addAttribute("walletAmount", userWalletRepository.selectByRetailerId(fofoId).getAmount());

		// model.addAttribute("itemCisMap", itemCisMap);

		return "open-indent";

	}

	private List<Order> filterValidOrders(List<Order> lastOrdersList) {

		Iterator<Order> orderIterator = lastOrdersList.iterator();

		while (orderIterator.hasNext()) {

			Order o = orderIterator.next();

			if (o.getInvoiceNumber() != null) {

				try {

					purchaseRepository.selectByPurchaseReferenceAndFofoId(o.getInvoiceNumber(), o.getRetailerId());

					orderIterator.remove();

					continue;

				} catch (Exception e) {

				}

			}

		}

		return lastOrdersList;

	}

	@RequestMapping(value = "/indent/confirm-pause", method = RequestMethod.POST)

	public String raisePO(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

			throws Exception {

		JSONArray jsonArray = new JSONArray(jsonArrayString);

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

			JSONObject obj = jsonArray.getJSONObject(i);

			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));

			tl.setActive(obj.getBoolean("active"));

			tagListingRepository.persist(tl);

		}

		model.addAttribute("response", true);

		return "response";

	}

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

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

		boolean success = false;

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		List<ItemPriceQuantity> itemQuantities = this.getItemQuantities(fofoId);

		CustomRetailer customRetailer = retailerService.getFofoRetailers(Arrays.asList(fofoId)).get(fofoId);

		Client userClient = new UserClient().getClient();

		double totalAmount = itemQuantities.stream().mapToDouble(x -> x.getQty() * x.getPrice()).sum();

		if (totalAmount > 0) {

			userClient.addItemPricingToCart(customRetailer.getCartId(), itemQuantities);

			User user = userRepository.selectById(loginDetails.getFofoId());

			userClient = new UserClient().getClient();

			LOGGER.info("Setting wallet amount in cart");

			long transactionId = userClient.createOrders(user.getActiveCartId(), "", 0, "", 0, loginDetails.getFofoId(),

					7890, OrderSource.WEBSITE.getValue(), true);

			LOGGER.info("Creating wallet payment for transactionId - {}", transactionId);

			createPayment(user, totalAmount, transactionId);

			TransactionService.Client transactionClient = new TransactionClient().getClient();

			transactionClient.changeTransactionStatus(transactionId, TransactionStatus.AUTHORIZED,

					"Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);

			transactionClient.changeTransactionStatus(Long.valueOf(transactionId), TransactionStatus.IN_PROCESS,

					"Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);

			LOGGER.info("Successfully created transaction: " + transactionId + " for amount: " + totalAmount);

			transactionClient = new TransactionClient().getClient();

			transactionClient.markOrderForRegisteredGstInvoice(Collections.singletonList(Long.valueOf(transactionId)));

			try {

				transactionClient.enqueueTransactionInfoEmail(transactionId);

			} catch (Exception e1) {

				e1.printStackTrace();

				LOGGER.error("Unable to update status of transaction. Thrift Exception:", e1);

			}

			resetCart(transactionClient.getTransaction(transactionId));

		}

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

		return "response";

	}

	private void createPayment(User user, double totalAmount, long transactionId)

			throws NumberFormatException, PaymentException, TException {

		List<Attribute> paymentAttributes = new ArrayList<Attribute>();

		in.shop2020.payments.PaymentService.Client paymentClient = new PaymentClient().getClient();

		paymentAttributes.add(new Attribute("payMethod", "7890"));

		long paymentId = paymentClient.createPayment(user.getId(), totalAmount, WALLET_GATEWAY_ID, transactionId,

				false);

		paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,

				PaymentStatus.SUCCESS, null, paymentAttributes);

	}

	private List<ItemPriceQuantity> getItemQuantities(int fofoId) throws ProfitMandiBusinessException {

		List<ItemPriceQuantity> itemQuantities = new ArrayList<>();

		/*

		 * Map<Integer, ItemIdAvailability> itemCisMap = null; List<ItemIdAvailability>

		 * currentInventorySnapshots = currentInventorySnapshotRepository

		 * .selectItemsStock(fofoId); itemCisMap =

		 * currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)

		 * .collect(Collectors.toMap(x -> x.getItemId(), x -> x));

		 * List<StockAllocationModel> stockAllocationList =

		 * stockAllocationService.getStockAllocation(fofoId, true);

		 * 

		 * Map<Integer, StockAllocationModel> itemStockAllocationMap =

		 * stockAllocationList.stream() .collect(Collectors.toMap(x -> x.catalogId(), x

		 * -> x)); Map<Integer, Integer> itemsInTransit = null;

		 * LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);

		 * List<TagListing> tagListings = tagListingRepository.selectAll(false);

		 * List<Order> inTransitOrders = orderRepository.selectOrders(fofoId,

		 * validOrderStatusList); inTransitOrders =

		 * this.filterValidOrders(inTransitOrders); itemsInTransit =

		 * inTransitOrders.stream().collect(Collectors.groupingBy(x ->

		 * x.getLineItem().getItemId(), Collectors.summingInt(x ->

		 * x.getLineItem().getQuantity())));

		 * 

		 * Iterator<TagListing> iterator = tagListings.iterator();

		 * 

		 * int toBeOrdered = 0; while (iterator.hasNext()) { TagListing tagListing =

		 * iterator.next(); LOGGER.info(" tagListing.setAllocatedQuantity {}",

		 * tagListing.getAllocatedQuantity()); if

		 * (!itemCisMap.containsKey(tagListing.getItemId()) &&

		 * !itemStockAllocationMap.containsKey(tagListing.getItemId())) {

		 * iterator.remove(); continue; } ItemIdAvailability itemIdAvailability =

		 * itemCisMap.get(tagListing.getItemId());

		 * tagListing.setStockInHand(itemIdAvailability == null ? 0 :

		 * itemIdAvailability.getAvailability()); StockAllocationModel

		 * stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());

		 * 

		 * if (itemsInTransit.containsKey(tagListing.getItemId())) {

		 * tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));

		 * } else { tagListing.setInTransitQuantity(0); } if (stockAllocationModel !=

		 * null) { tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());

		 * toBeOrdered = Math.max(tagListing.getAllocatedQuantity() -

		 * tagListing.getInTransitQuantity() - tagListing.getStockInHand(), 0); if

		 * (toBeOrdered > 0) { ItemPriceQuantity ipq = new ItemPriceQuantity();

		 * ipq.setItemId(tagListing.getItemId()); ipq.setQty((long) toBeOrdered);

		 * ipq.setPrice(tagListing.getSellingPrice()); itemQuantities.add(ipq); } } }

		 */

		return itemQuantities;

	}

	private long resetCart(Transaction transaction) {

		long sum = 0;

		Map<Long, Double> items = new HashMap<Long, Double>();

		for (in.shop2020.model.v1.order.Order order : transaction.getOrders()) {

			sum += order.getGvAmount();

			for (LineItem lineitem : order.getLineitems()) {

				Long itemId = lineitem.getItem_id();

				Double quantity = items.get(itemId);

				if (quantity == null) {

					quantity = lineitem.getQuantity();

				} else {

					quantity = quantity + lineitem.getQuantity();

				}

				items.put(itemId, quantity);

			}

		}

		LOGGER.debug("Items to reset in cart are: " + items);

		try {

			Client userClient = new UserClient().getClient();

			userClient.resetCart(transaction.getShoppingCartid(), items);

		} catch (TException e) {

			LOGGER.error("Error while updating information in payment database.", e);

		} catch (ShoppingCartException e) {

			LOGGER.error("Error while reseting the cart in cart database.", e);

		} catch (Exception e) {

			LOGGER.error("Unexpected exception", e);

		}

		return sum;

	}

}