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

 	@Autowired
 	private OrderRepository orderRepository;
 	@Autowired
 	private FofoUser fofoUser;
 	@Autowired
 	private ActivatedImeiRepository activatedImeiRepository;
 	@Autowired
 	private Mongo mongoClient;
 	@Autowired
 	private SchemeInOutRepository schemeInOutRepository;
 	@Autowired
 	private LineItemRepository lineItemRepository;
 	@Autowired
 	private FofoLineItemRepository fofoLineItemRepository;
 	@Autowired
 	private PositionRepository positionRepository;
 		LocalDateTime curDate = LocalDate.now().atStartOfDay();
 		int dayOfMonth = curDate.getDayOfMonth();
 		for (int i = 1; i <= 6; i++) {
 			LocalDateTime startOfMonth = curDate.withDayOfMonth(1).minusMonths(i);
 			int lengthOfMonth = YearMonth.from(startOfMonth).lengthOfMonth();
-			LOGGER.info("Start of previous Month {}, start of next month Month {}", startOfMonth,startOfMonth.plusMonths(1));
+			LOGGER.info("Start of previous Month {}, start of next month Month {}", startOfMonth,
+					startOfMonth.plusMonths(1));
 			double monthSales = fofoOrderItemRepository.selectSumMopGroupByRetailer(startOfMonth,
 					startOfMonth.plusMonths(1), loginDetails.getFofoId(), false).get(fofoId);
 			double mtdSales = fofoOrderItemRepository
 					.selectSumMopGroupByRetailer(startOfMonth,
 			ms.setMtdSales(fofoUser.format((long) mtdSales));
 			ms.setMonthlySales(fofoUser.format(((long) monthSales)));
 			ms.setPartnerType(partnerType);
 			ms.setMonth(startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));
 			monthSaleMap.put(i, ms);
-       }
+		}
 		model.addAttribute("monthSales", monthSaleMap);
 		return "monthSales";
+	}
 		String email = loginDetails.getEmailId();
 		int fofoId = loginDetails.getFofoId();
 		LocalDateTime startDate = LocalDate.now().withDayOfYear(1).atStartOfDay();
 		LocalDateTime endtDate = LocalDateTime.now();
-		OnlineDeliveredOrderSum onlineDeliveredOrderSum = pendingOrderItemRepository.selectSumSellingPriceOnlineOrder(fofoId, startDate, endtDate);
+		OnlineDeliveredOrderSum onlineDeliveredOrderSum = pendingOrderItemRepository
+				.selectSumSellingPriceOnlineOrder(fofoId, startDate, endtDate);
-    	LOGGER.info("onlineDeliveredOrderSum" + onlineDeliveredOrderSum.getSellingPrice());
+		LOGGER.info("onlineDeliveredOrderSum" + onlineDeliveredOrderSum.getSellingPrice());
 		long countOrder = pendingOrderRepository.pendingOrderCount(fofoId, OrderStatus.PROCESSING);
 		LOGGER.info("countOrder" + countOrder);
 		ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
 		orderStatus.add(in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING);
 		orderStatus.add(in.shop2020.model.v1.order.OrderStatus.BILLED);
 		orderStatus.add(in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH);
-		List<Order> order =orderRepository.selectOrders(fofoId,orderStatus);
+		List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);
+		List<Integer> submittedOrderIds = order.stream()
-	    List<Integer>	submittedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING)
+				.map(x -> x.getId()).collect(Collectors.toList());
+		List<Integer> billedOrderIds = order.stream()
-	    List<Integer>	billedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.BILLED).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.BILLED).map(x -> x.getId())
+				.collect(Collectors.toList());
+		List<Integer> shippedOrderIds = order.stream()
-	    List<Integer>	shippedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH)
+				.map(x -> x.getId()).collect(Collectors.toList());
-	    LOGGER.info("billedOrderIds {}", billedOrderIds);
+		LOGGER.info("billedOrderIds {}", billedOrderIds);
-	    LOGGER.info("shippedOrderIds {}", shippedOrderIds);
+		LOGGER.info("shippedOrderIds {}", shippedOrderIds);
-	    List<Order> grnPendingOrder =orderRepository.selectPendingGrnOrders(fofoId);
+		List<Order> grnPendingOrder = orderRepository.selectPendingGrnOrders(fofoId);
-	    List<Integer>	grnOrderIds = grnPendingOrder.stream().map(x -> x.getId()).collect(Collectors.toList());
+		List<Integer> grnOrderIds = grnPendingOrder.stream().map(x -> x.getId()).collect(Collectors.toList());
-	    model.addAttribute("grnOrderIds", grnOrderIds);
+		model.addAttribute("grnOrderIds", grnOrderIds);
-	    if(!grnOrderIds.isEmpty()) {
+		if (!grnOrderIds.isEmpty()) {
-	    List<LineItem>  grnPendingLineItem = lineItemRepository.selectLineItem(grnOrderIds);
+			List<LineItem> grnPendingLineItem = lineItemRepository.selectLineItem(grnOrderIds);
-	    Map<Integer, LineItem> grnPendingLineMap = grnPendingLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> grnPendingLineMap = grnPendingLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    long grnPendingCount = grnPendingLineMap.entrySet().stream().filter(x -> x.getKey() > 0 ).count();
+			long grnPendingCount = grnPendingLineMap.entrySet().stream().filter(x -> x.getKey() > 0).count();
+			long grnPendingValue = grnPendingLineMap.entrySet().stream()
-		   long grnPendingValue = grnPendingLineMap.entrySet().stream().mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
+					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
-		   model.addAttribute("grnPendingCount", grnPendingCount);
+			model.addAttribute("grnPendingCount", grnPendingCount);
-		   model.addAttribute("grnPendingValue", grnPendingValue);
+			model.addAttribute("grnPendingValue", grnPendingValue);
+		}
-	    }
-	    if(!submittedOrderIds.isEmpty()) {
+		if (!submittedOrderIds.isEmpty()) {
-	    List<LineItem>  submittedLineItem = lineItemRepository.selectLineItem(submittedOrderIds);
+			List<LineItem> submittedLineItem = lineItemRepository.selectLineItem(submittedOrderIds);
-	    Map<Integer, LineItem> submittedLineItemMap = submittedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> submittedLineItemMap = submittedLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("submittedLineItemMap {}", submittedLineItemMap);
+			LOGGER.info("submittedLineItemMap {}", submittedLineItemMap);
-	   long submittedCount = submittedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0 ).count();
+			long submittedCount = submittedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0).count();
+			long submittedValue = submittedLineItemMap.entrySet().stream()
-	   long submittedValue = submittedLineItemMap.entrySet().stream().mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
+					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
-	   model.addAttribute("submittedCount", submittedCount);
+			model.addAttribute("submittedCount", submittedCount);
-	   model.addAttribute("submittedValue", submittedValue);
+			model.addAttribute("submittedValue", submittedValue);
-	   LOGGER.info("submittedCount {}", submittedCount);
+			LOGGER.info("submittedCount {}", submittedCount);
-	    }
+		}
-	    if(!billedOrderIds.isEmpty()) {
+		if (!billedOrderIds.isEmpty()) {
-	    List<LineItem>  billedLineItem = lineItemRepository.selectLineItem(billedOrderIds);
+			List<LineItem> billedLineItem = lineItemRepository.selectLineItem(billedOrderIds);
-	    Map<Integer, LineItem> billedLineItemMap = billedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> billedLineItemMap = billedLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("billedLineItemMap {}", billedLineItemMap);
+			LOGGER.info("billedLineItemMap {}", billedLineItemMap);
-	    long billedCount = billedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0 ).count();
+			long billedCount = billedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0).count();
-		   model.addAttribute("billedCount", billedCount);
+			model.addAttribute("billedCount", billedCount);
-		   LOGGER.info("billedCount {}", billedCount);
+			LOGGER.info("billedCount {}", billedCount);
+			long billedValue = billedLineItemMap.entrySet().stream()
-		   long billedValue = billedLineItemMap.entrySet().stream().mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
+					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
-		   model.addAttribute("billedValue", billedValue);
+			model.addAttribute("billedValue", billedValue);
-	    }
+		}
-	    if(!shippedOrderIds.isEmpty()) {
+		if (!shippedOrderIds.isEmpty()) {
-	    List<LineItem>  shippedLineItem = lineItemRepository.selectLineItem(shippedOrderIds);
+			List<LineItem> shippedLineItem = lineItemRepository.selectLineItem(shippedOrderIds);
-	    Map<Integer, LineItem> shippedLineItemMap = shippedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> shippedLineItemMap = shippedLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("shippedLineItemMap {}", shippedLineItemMap);
+			LOGGER.info("shippedLineItemMap {}", shippedLineItemMap);
-	    long shippedCount = shippedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0 ).count();
+			long shippedCount = shippedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0).count();
-		   model.addAttribute("shippedCount", shippedCount);
+			model.addAttribute("shippedCount", shippedCount);
-		   LOGGER.info("shippedCount {}", shippedCount);
+			LOGGER.info("shippedCount {}", shippedCount);
+			long shippedValue = shippedLineItemMap.entrySet().stream()
-		   long shippedValue = shippedLineItemMap.entrySet().stream().mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
+					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();
-		   model.addAttribute("shippedValue", shippedValue);
+			model.addAttribute("shippedValue", shippedValue);
-	    }
+		}
 		model.addAttribute("countOrder", countOrder);
 		model.addAttribute("onlineDeliveredOrderSum", onlineDeliveredOrderSum.getSellingPrice());
 		boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());
 		model.addAttribute("isAdmin", isAdmin);
 		 */
 		return "dashboard1";
+	}
 	@RequestMapping(value = "/getGrnPendingOrderStatus", method = RequestMethod.GET)
 	public String getGrnPendingOrderStatus(HttpServletRequest request, Model model) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		int fofoId = loginDetails.getFofoId();
-        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
+		ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
-		List<Order> order =orderRepository.selectPendingGrnOrders(fofoId);
+		List<Order> order = orderRepository.selectPendingGrnOrders(fofoId);
-	    List<Integer>	orderIds = order.stream().map(x -> x.getId()).collect(Collectors.toList());
+		List<Integer> orderIds = order.stream().map(x -> x.getId()).collect(Collectors.toList());
-	    model.addAttribute("grnOrderIds", orderIds);
+		model.addAttribute("grnOrderIds", orderIds);
-	    if(!orderIds.isEmpty()) {
+		if (!orderIds.isEmpty()) {
-	    List<LineItem>  grnPendingLineItem = lineItemRepository.selectLineItem(orderIds);
+			List<LineItem> grnPendingLineItem = lineItemRepository.selectLineItem(orderIds);
-	    Map<Integer, LineItem> grnPendingLineMap = grnPendingLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> grnPendingLineMap = grnPendingLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("grnPendingLineMap {}", grnPendingLineMap);
+			LOGGER.info("grnPendingLineMap {}", grnPendingLineMap);
-	    model.addAttribute("grnPendingLineMap", grnPendingLineMap);
+			model.addAttribute("grnPendingLineMap", grnPendingLineMap);
-	    Map<Integer, Order> orderMap = order.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+			Map<Integer, Order> orderMap = order.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
-	    model.addAttribute("orderMap", orderMap);
+			model.addAttribute("orderMap", orderMap);
-	    }
+		}
 		return "purchase-grn-order-status";
+	}
 	@RequestMapping(value = "/getPendingOrderStatus", method = RequestMethod.GET)
 	public String getPendingOrderStatus(HttpServletRequest request, Model model) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		int fofoId = loginDetails.getFofoId();
-        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
+		ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
 		orderStatus.add(in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING);
-		List<Order> order =orderRepository.selectOrders(fofoId,orderStatus);
+		List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);
+		List<Integer> submittedOrderIds = order.stream()
-	    List<Integer>	submittedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING)
+				.map(x -> x.getId()).collect(Collectors.toList());
-	    model.addAttribute("submittedOrderIds", submittedOrderIds);
+		model.addAttribute("submittedOrderIds", submittedOrderIds);
-	    if(!submittedOrderIds.isEmpty()) {
+		if (!submittedOrderIds.isEmpty()) {
-	    List<LineItem>  submittedLineItem = lineItemRepository.selectLineItem(submittedOrderIds);
+			List<LineItem> submittedLineItem = lineItemRepository.selectLineItem(submittedOrderIds);
-	    Map<Integer, LineItem> submittedLineItemMap = submittedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> submittedLineItemMap = submittedLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("submittedLineItemMap {}", submittedLineItemMap);
+			LOGGER.info("submittedLineItemMap {}", submittedLineItemMap);
-	    model.addAttribute("submittedLineItemMap", submittedLineItemMap);
+			model.addAttribute("submittedLineItemMap", submittedLineItemMap);
-		    }
+		}
 		return "purchase-pending-order-status";
+	}
 	@RequestMapping(value = "/getBilledOrderStatus", method = RequestMethod.GET)
 	public String getBilledOrderStatus(HttpServletRequest request, Model model) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		int fofoId = loginDetails.getFofoId();
-        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
+		ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
 		orderStatus.add(in.shop2020.model.v1.order.OrderStatus.BILLED);
-		List<Order> order =orderRepository.selectOrders(fofoId,orderStatus);
+		List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);
+		List<Integer> billedOrderIds = order.stream()
-	    	    List<Integer>	billedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.BILLED).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.BILLED).map(x -> x.getId())
+				.collect(Collectors.toList());
-	     LOGGER.info("billedOrderIds {}", billedOrderIds);
+		LOGGER.info("billedOrderIds {}", billedOrderIds);
-	 	    model.addAttribute("billedOrderIds", billedOrderIds);
+		model.addAttribute("billedOrderIds", billedOrderIds);
-	    if(!billedOrderIds.isEmpty()) {
+		if (!billedOrderIds.isEmpty()) {
-	    List<LineItem>  billedLineItem = lineItemRepository.selectLineItem(billedOrderIds);
+			List<LineItem> billedLineItem = lineItemRepository.selectLineItem(billedOrderIds);
-	    Map<Integer, LineItem> billedLineItemMap = billedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> billedLineItemMap = billedLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("billedLineItemMap {}", billedLineItemMap);
+			LOGGER.info("billedLineItemMap {}", billedLineItemMap);
-	    model.addAttribute("billedLineItemMap", billedLineItemMap);
+			model.addAttribute("billedLineItemMap", billedLineItemMap);
-	    }
+		}
 		return "purchase-billed-order-status";
+	}
 	@RequestMapping(value = "/getShippedOrderStatus", method = RequestMethod.GET)
 	public String getShippedOrderStatus(HttpServletRequest request, Model model) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		int fofoId = loginDetails.getFofoId();
-        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
+		ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();
 		orderStatus.add(in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH);
-		List<Order> order =orderRepository.selectOrders(fofoId,orderStatus);
+		List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);
+		List<Integer> shippedOrderIds = order.stream()
-	   	    List<Integer>	shippedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH)
+				.map(x -> x.getId()).collect(Collectors.toList());
-	    	  	    model.addAttribute("shippedOrderIds", shippedOrderIds);
+		model.addAttribute("shippedOrderIds", shippedOrderIds);
-	    LOGGER.info("shippedOrderIds {}", shippedOrderIds);
+		LOGGER.info("shippedOrderIds {}", shippedOrderIds);
-	    if(!shippedOrderIds.isEmpty()) {
+		if (!shippedOrderIds.isEmpty()) {
-	    List<LineItem>  shippedLineItem = lineItemRepository.selectLineItem(shippedOrderIds);
+			List<LineItem> shippedLineItem = lineItemRepository.selectLineItem(shippedOrderIds);
-	    Map<Integer, LineItem> shippedLineItemMap = shippedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
+			Map<Integer, LineItem> shippedLineItemMap = shippedLineItem.stream()
+					.collect(Collectors.toMap(x -> x.getOrderId(), x -> x));
-	    LOGGER.info("shippedLineItemMap {}", shippedLineItemMap);
+			LOGGER.info("shippedLineItemMap {}", shippedLineItemMap);
-	    model.addAttribute("shippedLineItemMap", shippedLineItemMap);
+			model.addAttribute("shippedLineItemMap", shippedLineItemMap);
-	    }
+		}
 		return "purchase-shipped-order-status";
+	}
 	@RequestMapping(value = "/getMonthsInvestment", method = RequestMethod.GET)
 	public String getMonthsInvestment(HttpServletRequest request,
 		int fofoId = loginDetails.getFofoId();
 		LocalDateTime curDate = LocalDate.now().atStartOfDay();
 		LocalDateTime startOfMonth = curDate.withDayOfMonth(1).minusMonths(6);
 		LocalDateTime startfMonthTotal = curDate.withDayOfMonth(1).minusMonths(12);
-		LocalDateTime endMonthTotal = curDate.withDayOfMonth(1).minusMonths(6);
+		LocalDateTime endMonthTotal = curDate.withDayOfMonth(1).minusMonths(5);
+		LOGGER.info("startfMonthTotal" + startfMonthTotal);
+		LOGGER.info("endMonthTotal" + endMonthTotal);
 		List<YearMonth> yms = new ArrayList<YearMonth>();
-		for (int i = 1; i <= 6; i++) {
+		for (int i = 0; i <= 5; i++) {
 			yms.add(YearMonth.from(curDate.withDayOfMonth(1).minusMonths(i)));
+		}
 		Collections.reverse(yms);
 		model.addAttribute("yms", yms);
 		LOGGER.info("ym" + yms);
 		model.addAttribute("brands", brands);
 		for (String brand : brands) {
 			Map<YearMonth, Double> yearMonthValue = brandMonthValue.get(brand);
-			for (int i = 6; i >= 1; i--) {
+			for (int i = 5; i >= 0; i--) {
 				LocalDateTime startMonth = curDate.withDayOfMonth(1).minusMonths(i);
 				if (yearMonthValue != null) {
 					if (yearMonthValue.get(YearMonth.from(startMonth)) == null) {

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/DashboardController.java – Rev 29746 → 29875