WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/IndentController.java

 package com.spice.profitmandi.web.controller;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
 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.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.spice.profitmandi.common.enumuration.CounterSize;
-import com.spice.profitmandi.common.enumuration.IndentStatus;
 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.CurrentInventorySnapshot;
-import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
 import com.spice.profitmandi.dao.entity.fofo.FofoStore;
-import com.spice.profitmandi.dao.entity.fofo.IndentItem;
 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.dtr.IndentItemRepository;
-import com.spice.profitmandi.dao.repository.dtr.IndentRepository;
 import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
-import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
 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;
 	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
 	private ItemRepository itemRepository;
 	@Autowired
-	private IndentRepository indentRepository;
-	@Autowired
 	private StockAllocationService stockAllocationService;
 	@Autowired
-	private IndentItemRepository indentItemRepository;
-	@Autowired
 	private RetailerService retailerService;
 	@Autowired
 	private TagListingRepository tagListingRepository;
 	@Autowired
-	private FofoOrderRepository fofoOrderRepository;
-	@Autowired
 	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
 	@Autowired
 	private PurchaseRepository purchaseRepository;
 			model.addAttribute("response", mvcResponseSender.createResponseString(response));
+		}
 		return "response";
+	}
-	@RequestMapping(value = "/migrate", method = RequestMethod.PUT)
+	@RequestMapping(value = "/indent/download", method = RequestMethod.GET)
-	public String migrate(HttpServletRequest request, Model model) throws Exception {
+	public ResponseEntity<ByteArrayResource> downloadIndent(HttpServletRequest request, Model model,
-		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+			@RequestParam(required = false, defaultValue = "0") int fofoId,
-		int fofoId = loginDetails.getFofoId();
+			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
-		List<TagListing> tagListings = tagListingRepository.selectAll(false);
+		Set<Integer> roleIds = cookiesProcessor.getCookiesObject(request).getRoleIds();
-		for (TagListing tagListing : tagListings) {
+		LOGGER.info("Counter size is {}", counterSize);
-			int itemId = tagListing.getItemId();
+		LOGGER.info("Fofo Id is {}", fofoId);
-		}
-		return "";
-	}
-	@RequestMapping(value = "/indent/inProcess")
+		if (roleManager.isAdmin(roleIds)) {
-	public String loadInProcessIndents(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
+			List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,
-		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
-		int fofoId = loginDetails.getFofoId();
+					true);
-		List<Integer> pendingIndentIds = indentRepository.selectIndentByStatus(fofoId, IndentStatus.PENDING).stream()
+			Map<Integer, StockAllocationModel> modelStockAllocationMap = stockAllocationList.stream()
-				.map(x -> x.getId()).collect(Collectors.toList());
+					.collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
-		List<Integer> allocatedIndentIds = indentRepository.selectIndentByStatus(fofoId, IndentStatus.ALLOCATED)
+			List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())
-				.stream().map(x -> x.getId()).collect(Collectors.toList());
+					.collect(Collectors.toList());
-		pendingIndentIds.addAll(allocatedIndentIds);
+			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
-		if (pendingIndentIds.size() > 0) {
-			Map<Integer, IndentItem> pendingIndentItemIdMap = indentItemRepository.selectIndentItems(pendingIndentIds)
+			Map<String, CatalogListingModel> catalogListingMap = new HashMap<>();
-					.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x));
+			List<TagListing> tagListings = tagListingRepository.selectAll(true);
-			List<TagListing> tagListings = tagListingRepository
+			Iterator<TagListing> iterator = tagListings.iterator();
-					.selectByItemIdsAndTagIds(pendingIndentItemIdMap.keySet(), new HashSet<>(Arrays.asList(4)));
+			Map<Integer, List<CurrentInventorySnapshot>> itemListSnapshot = new HashMap<>();
-			List<FofoOrderItem> fofoOrderItems = fofoOrderRepository.selectByFofoItemIds(fofoId, pendingIndentIds,
+			currentInventorySnapshotRepository.selectAll(Optional.of(true)).stream().forEach(x -> {
-					LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(30), LocalDateTime.now());
-			Map<Integer, Integer> itemQuantity = fofoOrderItems.stream().collect(
+				if (!itemListSnapshot.containsKey(x.getItemId())) {
-					Collectors.groupingBy(FofoOrderItem::getItemId, Collectors.summingInt(FofoOrderItem::getQuantity)));
+					itemListSnapshot.put(x.getItemId(), new ArrayList<>());
+				}
-			List<CurrentInventorySnapshot> cis = currentInventorySnapshotRepository.selectByFofoId(fofoId);
-			Map<Integer, CurrentInventorySnapshot> itemIdSnapshotMap = cis.stream()
-					.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
+				itemListSnapshot.get(x.getItemId()).add(x);
+			});
+			List<Order> inTransitOrders = orderRepository.selectOrders(fofoIds, partnerPendingOrderList);
-			for (TagListing tagListing : tagListings) {
+			Map<String, Integer> itemsInTransit = inTransitOrders.stream()
-				Integer itemId = tagListing.getItemId();
+					.collect(Collectors.groupingBy(
-				tagListing.setItemDescription(itemRepository.selectById(itemId).getItemDescription());
+							x -> new String(x.getLineItem().getItemId() + "-" + x.getRetailerId()),
+							Collectors.summingInt(x -> x.getLineItem().getQuantity())));
-				if (itemQuantity.containsKey(itemId)) {
+			while (iterator.hasNext()) {
-					tagListing.setLast30DaysSale(itemQuantity.get(itemId));
+				TagListing tagListing = iterator.next();
+				Item item = itemRepository.selectById(tagListing.getItemId());
+				if (item.getCategoryId() != 10006) {
+					continue;
+				}
+				int catalogId = item.getCatalogItemId();
+				if ((modelStockAllocationMap.containsKey(catalogId)
+						&& modelStockAllocationMap.get(catalogId).getQuantity() > 0)
-				if (itemIdSnapshotMap.containsKey(itemId)) {
+						|| itemListSnapshot.containsKey(item.getId())) {
+					List<CurrentInventorySnapshot> cisList = itemListSnapshot.get(item.getId());
+					if (cisList != null) {
+						for (CurrentInventorySnapshot cis : cisList) {
+							if (!catalogListingMap.containsKey(catalogId + "-" + cis.getFofoId())) {
+								CatalogListingModel catalogListingModel = new CatalogListingModel();
+								catalogListingModel.setFofoId(cis.getFofoId());
+								catalogListingModel.setModelName(item.getModelName());
+								catalogListingModel.setModelNumber(item.getModelNumber());
+								catalogListingModel.setCatalogId(catalogId);
+								catalogListingModel.setDp(tagListing.getSellingPrice());
+								catalogListingModel.setMop(tagListing.getMop());
+								catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());
+								StockAllocationModel stockAllocationModel = modelStockAllocationMap.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 + "-" + cis.getFofoId(), catalogListingModel);
+							}
+							CatalogListingModel catalogListingModel = catalogListingMap
+									.get(catalogId + "-" + cis.getFofoId());
+							int itemAvailability = cis.getAvailability();
-					tagListing.setStockInHand(itemIdSnapshotMap.get(itemId).getAvailability());
+							catalogListingModel.setStockInHand(catalogListingModel.getStockInHand() + itemAvailability);
+							Integer inTransitQuantity = itemsInTransit.get(item.getId() + "-" + cis.getFofoId());
+							int inTransitQty = (inTransitQuantity == null ? 0 : inTransitQuantity);
+							catalogListingModel
+									.setInTransitQuantity(catalogListingModel.getInTransitQuantity() + inTransitQty);
+							if (catalogListingModel.getAllocatedQuantity() > 0) {
+								int toBeOrdered = Math
+										.max(catalogListingModel.getToBeOrdered() - inTransitQty - itemAvailability, 0);
+								catalogListingModel.setToBeOrdered(toBeOrdered);
+							}
+						}
+					}
+				}
+			}
+			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.getBrand(), clm.getCatalogId(),
+								clm.getItemDescription(), clm.getDp(), clm.getMop(), clm.getAllocatedQuantity(),
+								clm.getInTransitQuantity(), clm.getStockInHand(), clm.getToBeOrdered()));
+			}
+			ByteArrayOutputStream baos = FileUtil.getCSVByteStream(Arrays.asList("StoreId", "StoreName", "Catalog Id", "Brand", "Model", "DP", "MOP",
-			model.addAttribute("pendingIndentItemIdMap", pendingIndentItemIdMap);
+					"Allocated Quantity", "In Transit", "Stock In hand", "Shortage"), listOfRows);
-			model.addAttribute("tagListings", tagListings);
+			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 "pending-indent";
+		return null;
+	}
 	@RequestMapping(value = "/indent/loadIndent")
 	public String loadOpenIndent(HttpServletRequest request, Model model,
 			@RequestParam(required = false, defaultValue = "0") int fofoId,
 			stockAllocationList = stockAllocationService.getStockAllocation(counterSize, true);
+		}
 		LOGGER.info("Stock Allocation list  is {}", stockAllocationList);
 		Map<Integer, StockAllocationModel> itemStockAllocationMap = stockAllocationList.stream()
-				.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
+				.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);
+		}
 		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();
-			LOGGER.info(" tagListing.setAllocatedQuantity {}", tagListing.getAllocatedQuantity());
 			Item item = itemRepository.selectById(tagListing.getItemId());
+			// itemRepository.select
+			// catalogTagListingMap
 			if (roleManager.isAdmin(roleIds)) {
-				if (item.getBrand() == null || item.getCategoryId() == 0) {
+				if (item.getBrand() == null || item.getCategoryId() != 10006) {
 					iterator.remove();
 					continue;
+				}
 			} else {
-				if (!itemCisMap.containsKey(tagListing.getItemId())
+				if (!(itemCisMap.containsKey(tagListing.getItemId())
-						&& !itemStockAllocationMap.containsKey(tagListing.getItemId())) {
+					|| itemStockAllocationMap.containsKey(tagListing.getItemId()))
+				) {
 					iterator.remove();
 					continue;
+				}
+			}
-			ItemIdAvailability itemIdAvailability = itemCisMap.get(tagListing.getItemId());
+			int catalogId = item.getCatalogItemId();
-			tagListing.setStockInHand(itemIdAvailability == null ? 0 : itemIdAvailability.getAvailability());
-			StockAllocationModel stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());
-			if (itemsInTransit.containsKey(tagListing.getItemId())) {
+			CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);
-				tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));
+			if (!catalogListingMap.containsKey(catalogId)) {
-			} else {
-				tagListing.setInTransitQuantity(0);
+				catalogListingModel = new CatalogListingModel();
-			}
-			if (stockAllocationModel != null) {
+				catalogListingModel.setCatalogId(catalogId);
-				tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());
+				catalogListingModel.setDp(tagListing.getSellingPrice());
-				toBeOrdered = Math.max(tagListing.getAllocatedQuantity() - tagListing.getInTransitQuantity()
+				catalogListingModel.setMop(tagListing.getMop());
-						- tagListing.getStockInHand(), 0);
+				catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());
-				totalPcs += toBeOrdered;
+				StockAllocationModel stockAllocationModel = itemStockAllocationMap.get(item.getCatalogItemId());
-				totalAmount += toBeOrdered * tagListing.getSellingPrice();
+				int stockAllocationQuantity = stockAllocationModel == null ? 0 : stockAllocationModel.getQuantity();
-				tagListing.setToBeOrdered(toBeOrdered);
+				catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);
-			} else {
-				tagListing.setAllocatedQuantity(0);
+				catalogListingModel.setToBeOrdered(stockAllocationQuantity);
-			}
-			tagListing.setBrand(item.getBrand());
+				catalogListingModel.setBrand(item.getBrand());
-			tagListing.setItemDescription(item.getItemDescription());
-			if (item.getCategoryId() == 10006) {
+				if (item.getCategoryId() == 10006) {
-				tagListing.setCategoryId(item.getCategoryId());
+					catalogListingModel.setCategoryId(item.getCategoryId());
+				}
+				catalogListingMap.put(catalogId, catalogListingModel);
+			}
-			// LOGGER.info(" tagListing.setAllocatedQuantity {}",
-			// tagListing.getAllocatedQuantity());
-		}
+			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<Integer, List<TagListing>> performanceMap = tagListings.stream()
+		Map<Boolean, List<CatalogListingModel>> performanceMap = catalogModelList.stream()
-				.collect(Collectors.groupingBy(x -> x.getCategoryId()));
+				.collect(Collectors.groupingBy(x -> x.getCategoryId() == 10006));
-		List<TagListing> accsListing = performanceMap.get(0);
+		List<CatalogListingModel> mobileListing = performanceMap.get(true) == null ? new ArrayList<>()
+				: performanceMap.get(true);
-		List<TagListing> mobileListing = performanceMap.get(10006);
+		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())));
 		} else {
 			model.addAttribute("counterSize", counterSize.toString());
+		}
 		String customRetailers = JSONObject.valueToString(customRetailersMap.values());
 		LOGGER.info("Custom retailers {}", customRetailers);
-		Comparator<TagListing> firstCmp = Comparator
+		// Lits<CatalogTagListing> catalog
-				.comparing(x -> ((x.getAllocatedQuantity() - x.getStockInHand() - x.getInTransitQuantity() == 0)
+		Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getToBeOrdered,
-						? Integer.MIN_VALUE
+				Comparator.reverseOrder());
-						: (x.getAllocatedQuantity() - x.getStockInHand())), Comparator.reverseOrder());
+		model.addAttribute("catalogTagListings",
-		model.addAttribute("tagListings", tagListings.stream().sorted(firstCmp).collect(Collectors.toList()));
+				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));
+			}
+		}
 		return lastOrdersList;
+	}
-	@RequestMapping(value = "/indent/confirm-pause/{tagId}", method=RequestMethod.POST)
+	@RequestMapping(value = "/indent/confirm-pause/{tagId}", method = RequestMethod.POST)
 	public String raisePO(HttpServletRequest request, Model model, @PathVariable int tagId) throws Exception {
 		tagListingRepository.updateActiveById(tagId, false);
 		model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		return "response";
+	}
-		@RequestMapping(value = "/indent/create-po", method=RequestMethod.POST)
+	@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();
+		double totalAmount = itemQuantities.stream().mapToDouble(x -> x.getQty() * x.getPrice()).sum();
-		if(totalAmount > 0) {
+		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,
+			long transactionId = userClient.createOrders(user.getActiveCartId(), "", 0, "", 0, loginDetails.getFofoId(),
-					OrderSource.WEBSITE.getValue(), true);
+, OrderSource.WEBSITE.getValue(), true);
 			LOGGER.info("Creating wallet payment for transactionId - {}", transactionId);
 			createPayment(user, totalAmount, transactionId);
-			TransactionService.Client  transactionClient = new TransactionClient().getClient();
+			TransactionService.Client transactionClient = new TransactionClient().getClient();
 			transactionClient.changeTransactionStatus(transactionId, TransactionStatus.AUTHORIZED,
-					"Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B,
+					"Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);
-					OrderSource.WEBSITE);
 			transactionClient.changeTransactionStatus(Long.valueOf(transactionId), TransactionStatus.IN_PROCESS,
-					"Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B,
+					"Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);
-					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);
 			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 {
+	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);
+		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,
+		paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,
-				paymentAttributes);
+				PaymentStatus.SUCCESS, null, paymentAttributes);
+	}
 	private List<ItemPriceQuantity> getItemQuantities(int fofoId) throws ProfitMandiBusinessException {
 		List<ItemPriceQuantity> itemQuantities = new ArrayList<>();
+		/*
-		Map<Integer, ItemIdAvailability> itemCisMap = null;
+		 * Map<Integer, ItemIdAvailability> itemCisMap = null; List<ItemIdAvailability>
-		List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository
+		 * currentInventorySnapshots = currentInventorySnapshotRepository
-				.selectItemsStock(fofoId);
+		 * .selectItemsStock(fofoId); itemCisMap =
-		itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
+		 * currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
-				.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
+		 * .collect(Collectors.toMap(x -> x.getItemId(), x -> x));
+		 * List<StockAllocationModel> stockAllocationList =
-		List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(fofoId, true);
+		 * stockAllocationService.getStockAllocation(fofoId, true);
+		 *
-		Map<Integer, StockAllocationModel> itemStockAllocationMap = stockAllocationList.stream()
+		 * Map<Integer, StockAllocationModel> itemStockAllocationMap =
-				.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
+		 * stockAllocationList.stream() .collect(Collectors.toMap(x -> x.catalogId(), x
-		Map<Integer, Integer> itemsInTransit = null;
+		 * -> x)); Map<Integer, Integer> itemsInTransit = null;
-		LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);
+		 * LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);
-		List<TagListing> tagListings = tagListingRepository.selectAll(false);
+		 * List<TagListing> tagListings = tagListingRepository.selectAll(false);
-		List<Order> inTransitOrders = orderRepository.selectOrders(fofoId, validOrderStatusList);
+		 * List<Order> inTransitOrders = orderRepository.selectOrders(fofoId,
+		 * validOrderStatusList); inTransitOrders =
-		inTransitOrders = this.filterValidOrders(inTransitOrders);
+		 * this.filterValidOrders(inTransitOrders); itemsInTransit =
-		itemsInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
+		 * inTransitOrders.stream().collect(Collectors.groupingBy(x ->
+		 * x.getLineItem().getItemId(), Collectors.summingInt(x ->
-				Collectors.summingInt(x -> x.getLineItem().getQuantity())));
+		 * x.getLineItem().getQuantity())));
+		 *
-		Iterator<TagListing> iterator = tagListings.iterator();
+		 * Iterator<TagListing> iterator = tagListings.iterator();
+		 *
-		int toBeOrdered = 0;
-		while (iterator.hasNext()) {
+		 * int toBeOrdered = 0; while (iterator.hasNext()) { TagListing tagListing =
-			TagListing tagListing = iterator.next();
+		 * iterator.next(); LOGGER.info(" tagListing.setAllocatedQuantity {}",
-			LOGGER.info(" tagListing.setAllocatedQuantity {}", tagListing.getAllocatedQuantity());
+		 * tagListing.getAllocatedQuantity()); if
-			if (!itemCisMap.containsKey(tagListing.getItemId())
+		 * (!itemCisMap.containsKey(tagListing.getItemId()) &&
-					&& !itemStockAllocationMap.containsKey(tagListing.getItemId())) {
+		 * !itemStockAllocationMap.containsKey(tagListing.getItemId())) {
-				iterator.remove();
+		 * iterator.remove(); continue; } ItemIdAvailability itemIdAvailability =
-				continue;
-			}
-			ItemIdAvailability itemIdAvailability = itemCisMap.get(tagListing.getItemId());
+		 * itemCisMap.get(tagListing.getItemId());
-			tagListing.setStockInHand(itemIdAvailability == null ? 0 : itemIdAvailability.getAvailability());
+		 * tagListing.setStockInHand(itemIdAvailability == null ? 0 :
+		 * itemIdAvailability.getAvailability()); StockAllocationModel
-			StockAllocationModel stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());
+		 * stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());
+		 *
-			if (itemsInTransit.containsKey(tagListing.getItemId())) {
+		 * if (itemsInTransit.containsKey(tagListing.getItemId())) {
-				tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));
+		 * tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));
-			} else {
-				tagListing.setInTransitQuantity(0);
+		 * } else { tagListing.setInTransitQuantity(0); } if (stockAllocationModel !=
-			}
-			if (stockAllocationModel != null) {
-				tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());
+		 * null) { tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());
-				toBeOrdered = Math.max(tagListing.getAllocatedQuantity() - tagListing.getInTransitQuantity()
+		 * toBeOrdered = Math.max(tagListing.getAllocatedQuantity() -
-						- tagListing.getStockInHand(), 0);
+		 * tagListing.getInTransitQuantity() - tagListing.getStockInHand(), 0); if
-				if (toBeOrdered > 0) {
-					ItemPriceQuantity ipq = new ItemPriceQuantity();
+		 * (toBeOrdered > 0) { ItemPriceQuantity ipq = new ItemPriceQuantity();
-					ipq.setItemId(tagListing.getItemId());
+		 * ipq.setItemId(tagListing.getItemId()); ipq.setQty((long) toBeOrdered);
-					ipq.setQty((long)toBeOrdered);
-					ipq.setPrice(tagListing.getSellingPrice());
+		 * ipq.setPrice(tagListing.getSellingPrice()); itemQuantities.add(ipq); } } }
-					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();

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/IndentController.java – Rev 23855 → 24231