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



	@Autowired
	private SuggestedPoDetailRepository suggestedPoDetailRepository;
 
	@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)
	public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,
			@RequestParam int itemQty, @RequestParam int fofoId) throws Exception {
		if (fofoId == 0) {
 
			LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
			fofoId = loginDetails.getFofoId();
 

		model.addAttribute("response", mvcResponseSender.createResponseString(false));
		return "response";
	}
 
	private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,
			int catalogId, int itemQty) {
		if (monthlyPlanned == null) {
			monthlyPlanned = new MonthlyPlanned();
			monthlyPlanned.setFofoId(fofoId);
			monthlyPlanned.setYearMonth(currentMonthDate);
			monthlyPlannedRepository.persist(monthlyPlanned);

 
	}
 
	@RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)
	public String confirmOpenIndent(HttpServletRequest request,
			@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {
 
		if (fofoId == 0) {
			LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
			fofoId = loginDetails.getFofoId();
		}

				Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),
				plannedModel.stream()
						.map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))
						.collect(Collectors.toList()));
		LOGGER.info("baos" + baos);
		Utils.sendMailWithAttachments(googleMailSender, new String[] { customRetailer.getEmail() },
				ccemails.toArray(new String[ccemails.size()]), bccemails.toArray(new String[bccemails.size()]),
				"Planned Indent", "PFA",
				new Attachment[] { new Attachment("PlannedIndent.csv", new ByteArrayResource(baos.toByteArray())), });
 
	}
 
	@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 {
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
		Set<Integer> roleIds = loginDetails.getRoleIds();
		LOGGER.info("Counter size is {}", counterSize);
		LOGGER.info("Fofo Id is {}", fofoId);
 
		if (roleManager.isAdmin(roleIds) || loginDetails.getFofoId() == fofoId) {
			List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())
					.collect(Collectors.toList());
			Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
 
			Map<Integer, CustomRetailer> crm = fofoIds.stream().map(x -> customRetailerMap.get(x))
					.filter(x -> x != null).collect(Collectors.toList()).stream()
					.collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
			List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,
					true);
			Map<Integer, Integer> modelStockAllocationMap = stockAllocationList.stream()
					.collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getQuantity()));
 

					catalogListingMap.put(key, catalogListingModel);
				}
			}
			List<List<?>> listOfRows = new ArrayList<>();
			for (CatalogListingModel clm : catalogListingMap.values()) {
				CustomRetailer cr = crm.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()));
			}

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

 
	}
 
	@RequestMapping(value = "/hotdealsitemsByCatalogId")
	public String getHotdealsitemsByCatalogId(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);

 
	}
 
	@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 Exception {
 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
		Set<Integer> roleIds = loginDetails.getRoleIds();
		LOGGER.info("Counter size is {}", counterSize);
		LOGGER.info("Fofo Id is {}", fofoId);

		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {
			planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);
			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);
			LOGGER.info("monthlyPlanned2" + monthlyPlanned);
			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
					LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
					.collect(Collectors.toList());
 
			model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());
		} else {
			planningMonthDate = LocalDate.now().withDayOfMonth(1);

			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);
			model.addAttribute("planningMonth", planningMonthDate.getMonth());
			model.addAttribute("mtd", true);
			model.addAttribute("freezed", true);
			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
					curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())
					.collect(Collectors.toList());
			LOGGER.info("monthlyPlanned1" + monthlyPlanned);
		}
 
		Map<Integer, Integer> plannedDetailMap = null;

	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.getFofoRetailer(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);

				PaymentStatus.SUCCESS, null, paymentAttributes);
	}
 
	@RequestMapping(value = "/indent/loadIndentPreviousMonth")
	public String previousMonthLoadOpenIndent(HttpServletRequest request, Model model,
			@RequestParam(required = false, defaultValue = "0") int fofoId,
			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
		LocalDate planMonthStart = null;
		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {
			planMonthStart = LocalDate.now().plusMonths(1).withDayOfMonth(1);
		} else {
			planMonthStart = LocalDate.now().withDayOfMonth(1);

 
	}
 
	@RequestMapping(value = "/getFocusedModel", method = RequestMethod.GET)
	public String getFocusedModel(HttpServletRequest request,
			@RequestParam(name = "offset", defaultValue = "0") int offset,
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
			throws ProfitMandiBusinessException {
 
		long size = 0;
		List<FocusedModel> focusedModels = focusedModelRepository.selectAll(offset, limit);
 

		return regionMap;
	}
 
	@RequestMapping(value = "/getPaginatedFocusedModel", method = RequestMethod.GET)
	public String getPaginatedFocusedModel(HttpServletRequest request,
			@RequestParam(name = "offset", defaultValue = "0") int offset,
			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
			throws ProfitMandiBusinessException {
		LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);
		List<FocusedModel> focusedModels = focusedModelRepository.selectAll(offset, limit);
 
		if (!focusedModels.isEmpty()) {

		return "focused-model-paginated";
	}
 
	@RequestMapping(value = "/focusedModel", method = RequestMethod.POST)
	public String focusedModel(HttpServletRequest request, @RequestParam int catalogId,
			@RequestParam(name = "recommended", defaultValue = "0") int recommended,
			@RequestParam(name = "minimumQty", defaultValue = "0") int minimumQty,
			@RequestParam(name = "obvrecommend", defaultValue = "0") int obvrecommend,
			@RequestParam(name = "obvminimum", defaultValue = "0") int obvminimum, @RequestParam int regionId,
			Model model) throws ProfitMandiBusinessException {
 
		FocusedModel fm = new FocusedModel();
		fm.setCatalogId(catalogId);
		fm.setMinimumQty(minimumQty);
		fm.setRecommendedQty(recommended);

 
		Map<Integer, List<Integer>> pp = csService.getAuthUserIdPartnerIdMapping();
 
		List<Integer> fofoIds = pp.get(authUser.getId());
 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
		Map<Integer, CustomRetailer> crm = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
				.collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
		Map<Integer, FofoStore> fofoStoreMap = fofoStoreRepository.selectByRetailerIds(fofoIds).stream()
				.collect(Collectors.toMap(x -> x.getId(), x -> x));
 
		model.addAttribute("customRetailersMap", crm);
		model.addAttribute("fofoStoreMap", fofoStoreMap);
		return "partners_allocation";
 
	}
 

		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
 
		Map<Integer, List<Integer>> pp = csService.getAuthUserIdPartnerIdMapping();
 
		List<Integer> fofoIds = pp.get(authUser.getId());
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
		Map<Integer, CustomRetailer> crm = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
				.collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
 
 
 
		model.addAttribute("customRetailersMap", crm);
 
		return "partner-po";
 
	}
 
	@RequestMapping(value = "/removeItem", method = RequestMethod.DELETE)
	public String removeFocusedModelItem(HttpServletRequest request,
			@RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {
 
		focusedModelRepository.deleteById(id);
		model.addAttribute("response", mvcResponseSender.createResponseString(true));
		return "response";
	}
 
	@RequestMapping(value = "/getPartnerloadContent")
	public String getPartnerloadContent(HttpServletRequest request, Model model,
			@RequestParam(required = false, defaultValue = "0") int fofoId,
			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
 
		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
		Set<Integer> roleIds = loginDetails.getRoleIds();
		LOGGER.info("Counter size is {}", counterSize);
		LOGGER.info("Fofo Id is {}", fofoId);

		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {
			currentMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);
			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);
			LOGGER.info("monthlyPlanned2" + monthlyPlanned);
			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
					LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
					.collect(Collectors.toList());
 
			model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());
		} else {
			currentMonthDate = LocalDate.now().withDayOfMonth(1);

			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);
			model.addAttribute("planningMonth", currentMonthDate.getMonth());
			model.addAttribute("mtd", true);
			model.addAttribute("freezed", true);
			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
					curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())
					.collect(Collectors.toList());
			LOGGER.info("monthlyPlanned1" + monthlyPlanned);
		}
 
		Map<Integer, Integer> plannedDetailMap = null;

 
		if (emails.contains(authUser.getEmailId())) {
			fofoIds = storeGuyMap.get("tarun.verma@smartdukaan.com");
			LOGGER.info("fofoIds" + fofoIds);
		}
 
 
 
 
 
 
 
 
 
		Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = new HashMap<>();
 
		Map<Integer, Map<String, Double>> fofoIdBrandAmountMap = new HashMap<>();
 
		Map<Integer, InStockAccessoriesTvFofoIdModel> inStockAccessTv = new HashMap<>();
		Map<Integer, InStockAccessoriesTvFofoIdModel> pendingIndentAccessTv = new HashMap<>();
		Map<Integer, InStockAccessoriesTvFofoIdModel> grnPendingAccessTvOrders = new HashMap<>();
 
		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();
		Map<Integer, CustomRetailer> customRetailers = new HashMap<>();
		Map<Integer, PartnerType> fofoIdPartnerTypeMap = new HashMap<>();
 
		if (fofoIds.size() > 0 && fofoIds != null) {
			List<Integer> fofoIdList = new ArrayList<>(fofoIds);

			Map<Integer, Map<String, Float>> partnerBrandLimitMap = brandLimitRepository.selectAllPartnerBrandLimit()
					.stream().collect(Collectors.groupingBy(x -> x.getFofoId(),
							Collectors.toMap(x -> x.getBrand(), x -> x.getBrandLimit())));
 
			model.addAttribute("partnerBrandLimitMap", partnerBrandLimitMap);
			customRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
 
					.collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
			Map<Integer, Map<String, Double>> inStockBrandModel = new HashMap<>();
			Map<Integer, Map<String, Double>> pendingIndent = new HashMap<>();
			Map<Integer, Map<String, Double>> grnPendingOrders = new HashMap<>();
 
			// mobile

		return "partner-brandwise-detail";
	}
 
	@RequestMapping(value = "/changeActivationType", method = RequestMethod.POST)
	public String changeActivationType(HttpServletRequest request, @RequestParam String code,
			@RequestParam ActivationType activationType, Model model) throws Exception {
 
		FofoStore fofoStore = fofoStoreRepository.selectByStoreCode(code);
 
		fofoStore.setActivationType(activationType);
 

		return "response";
	}
 
	@RequestMapping(value = "/getPartnerShortageStock", method = RequestMethod.GET)
	public String getPartnerShortageStock(HttpServletRequest request,
			@RequestParam(required = false, defaultValue = "") String brand, @RequestParam int fofoId, Model model)
			throws Exception {
 
		Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap = saholicInventoryService
				.getSaholicStock();
 

		return "partner-stock";
 
	}
 
	private List<PartnerStockDescriptionModel> getBrandItemwiseDescription(String brand,
			Map<Integer, Integer> catalogIdAndQtyMap) throws ProfitMandiBusinessException {
		List<PartnerStockDescriptionModel> inStocks = new ArrayList<>();
 
		for (Entry<Integer, Integer> inStock : catalogIdAndQtyMap.entrySet()) {
			List<Item> items = itemRepository.selectAllByCatalogItemId(inStock.getKey());
 

 
		return inStocks;
	}
 
	private FocusedModelShortageModel getFocusedModelShortage(int qty, int catalogId,
			Map<Integer, Integer> processingOrderMap, Map<Integer, Integer> grnPendingOrdersMap,
			Map<Integer, Integer> catalogIdAndQtyMap, int fofoId,
			Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap,
			Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap, List<Item> items,
			CustomRetailer customRetailer) throws ProfitMandiBusinessException {
 
		int minQty = qty;
		int inStockQty = 0;
		int processingQty = 0;
		int grnPendingQty = 0;

		return "send-po-notification";
	}
 
	@RequestMapping(value = "/indent/send-po-notification", method = RequestMethod.POST)
	public String sendPONotification(HttpServletRequest request, @RequestBody POItemWarehouseModel poItemWarehouseModel,
			Model model) throws Exception {
 
		Map<Integer, Item> selectedCatalogItemMap = itemRepository
				.selectAllByCatalogIds(new HashSet<>(poItemWarehouseModel.getCatalogIds())).stream()
				.collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x, (existing, replacement) -> existing));
 
		Set<String> brands = selectedCatalogItemMap.values().stream().map(x -> x.getBrand().toLowerCase())
				.collect(Collectors.toSet());
 
		int warehouseId = poItemWarehouseModel.getWarehouseId();
		for (String brand : brands) {
			List<String> modelNames = selectedCatalogItemMap.entrySet().stream()
					.filter(x -> x.getValue().getBrand().toLowerCase().equals(brand))
					.map(x -> x.getValue().getItemDescriptionNoColor()).collect(Collectors.toList());
			SendNotificationModel sendNotificationModel = new SendNotificationModel();
			sendNotificationModel.setCampaignName("SendPo");
			sendNotificationModel.setTitle(String.format(PO_TITLE_STRING));
			sendNotificationModel.setMessage(String.join(", ", modelNames));
			sendNotificationModel.setType("url");
			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
			sendNotificationModel.setMessageType(MessageType.notification);
 
			List<BrandRegionMapping> brandRegionMappings = brandRegionMappingRepository.selectAll().stream()
					.filter(x -> brand.equals(x.getBrand().toLowerCase()) && x.getFromWarehouseId() == warehouseId
							&& !x.isAccessory())
					.collect(Collectors.toList());
			List<Integer> toWarehouseIds = brandRegionMappings.stream().map(x -> x.getToWarehouseId())
					.collect(Collectors.toList());
 
			List<Integer> fofoIds = fofoStoreRepository.selectByWarehouseIds(toWarehouseIds).stream()

Subversion Repositories SmartDukaan

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

Rev 30118		Rev 30426
Line 220...		Line 220...
220	`@Autowired`	220	`@Autowired`
221	`private SuggestedPoDetailRepository suggestedPoDetailRepository;`	221	`private SuggestedPoDetailRepository suggestedPoDetailRepository;`
222		222
223	`@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)`	223	`@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)`
224	`public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,`	224	`public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,`
225	`@RequestParam int itemQty, @RequestParam int fofoId) throws Exception {`	225	`@RequestParam int itemQty, @RequestParam int fofoId) throws Exception {`
226	`if (fofoId == 0) {`	226	`if (fofoId == 0) {`
227		227
228	`LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);`	228	`LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);`
229	`fofoId = loginDetails.getFofoId();`	229	`fofoId = loginDetails.getFofoId();`
230		230
Line 242...		Line 242...
242	`model.addAttribute("response", mvcResponseSender.createResponseString(false));`	242	`model.addAttribute("response", mvcResponseSender.createResponseString(false));`
243	`return "response";`	243	`return "response";`
244	`}`	244	`}`
245		245
246	`private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,`	246	`private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,`
247	`int catalogId, int itemQty) {`	247	`int catalogId, int itemQty) {`
248	`if (monthlyPlanned == null) {`	248	`if (monthlyPlanned == null) {`
249	`monthlyPlanned = new MonthlyPlanned();`	249	`monthlyPlanned = new MonthlyPlanned();`
250	`monthlyPlanned.setFofoId(fofoId);`	250	`monthlyPlanned.setFofoId(fofoId);`
251	`monthlyPlanned.setYearMonth(currentMonthDate);`	251	`monthlyPlanned.setYearMonth(currentMonthDate);`
252	`monthlyPlannedRepository.persist(monthlyPlanned);`	252	`monthlyPlannedRepository.persist(monthlyPlanned);`
Line 280...		Line 280...
280		280
281	`}`	281	`}`
282		282
283	`@RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)`	283	`@RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)`
284	`public String confirmOpenIndent(HttpServletRequest request,`	284	`public String confirmOpenIndent(HttpServletRequest request,`
285	`@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {`	285	`@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {`
286		286
287	`if (fofoId == 0) {`	287	`if (fofoId == 0) {`
288	`LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);`	288	`LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);`
289	`fofoId = loginDetails.getFofoId();`	289	`fofoId = loginDetails.getFofoId();`
290	`}`	290	`}`
Line 336...		Line 336...
336	`Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),`	336	`Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),`
337	`plannedModel.stream()`	337	`plannedModel.stream()`
338	`.map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))`	338	`.map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))`