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

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.time.LocalDateTime;
 import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 	@Autowired
 	private FofoOrderItemRepository fofoOrderItemRepository;
 	@Autowired
 	private PaymentOptionRepository paymentOptionRepository;
 	@Autowired
 	private StateRepository stateRepository;
 	@Autowired
 	private ItemRepository itemRepository;
 	@Autowired
 	private MVCResponseSender mvcResponseSender;
 	@Autowired
 	private ZestService zestService;
 	@Autowired
 	private FofoOrderRepository fofoOrderRepository;
 				loginDetails.getFofoId());
 		List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository
 				.selectPaymentOptionIdsByFofoId(loginDetails.getFofoId());
 		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByIds(new HashSet<>(paymentOptionIds));
 		LOGGER.info("mopPriceMap {}", mopPriceMap);
+		model.addAttribute("stateNames",
-		model.addAttribute("stateNames", stateRepository.selectAll().stream().map(x->x.getName()).collect(Collectors.toList()));
+				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
 		model.addAttribute("retailerStateName", address.getState());
 		model.addAttribute("cartItems", cartItems);
 		model.addAttribute("mopPriceMap", mopPriceMap);
 		model.addAttribute("paymentOptions", paymentOptions);
 		model.addAttribute("accessoriesDeals", accessoriesDeals);
 		return "order-index";
+	}
 	@RequestMapping(value = "/checkplans", method = RequestMethod.GET)
-	public String getInsurancePrices(HttpServletRequest request,
+	public String getInsurancePrices(HttpServletRequest request, @RequestParam float price, Model model)
-			@RequestParam float price, Model model) throws ProfitMandiBusinessException {
+			throws ProfitMandiBusinessException {
 		LOGGER.info("Request received at url : {}", request.getRequestURI());
 		try {
 			String response = mvcResponseSender.createResponseString(this.getPlans(price));
 			model.addAttribute("response", response);
 		} catch (Exception e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 			throw new ProfitMandiBusinessException("Plans", "Plans API", "Error formatting insurance plans");
+		}
 		return "response";
+	}
 	@RequestMapping(value = "/get-order", method = RequestMethod.GET)
 	public String getOrder(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId,
 		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
 		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
 		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 		List<Integer> fofoPartnerPaymentOptions = fofoPartnerPaymentOptionRepository
 				.selectPaymentOptionIdsByFofoId(fofoOrder.getFofoId());
 		Map<Integer, Item> itemsMap = fofoOrderItems.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> {
 			try {
 				return itemRepository.selectById(x.getItemId());
 			} catch (ProfitMandiBusinessException e) {
 				// TODO Auto-generated catch block
 		LOGGER.info("paymentOptionIdPaymentOptionTransactionMap" + paymentOptionIdPaymentOptionTransactionMap.keySet());
 		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
 				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
 		this.addInsuranceProvider(insurancePolicies);
 		model.addAttribute("fofoOrder", fofoOrder);
-		for(FofoOrderItem fofoOrderItem : fofoOrderItems) {
+		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
 			fofoOrderItem.setDoa(true);
+		}
 		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdLineItemMap = fofoOrderItems.stream()
 				.collect(Collectors.toMap(FofoOrderItem::getId, FofoOrderItem::getFofoLineItems));
 		Map<Integer, List<CustomerReturnItem>> foiIdCustomerReturnInventoryItemsMap = fofoOrderItems.stream()
 				.collect(Collectors.toMap(foi -> foi.getId(),
 		model.addAttribute("paymentOptionIdPaymentOptionMap", paymentOptionIdPaymentOptionMap);
 		model.addAttribute("paymentOptionIdPaymentOptionTransactionMap", paymentOptionIdPaymentOptionTransactionMap);
 		model.addAttribute("insurancePolicies", insurancePolicies);
 		model.addAttribute("fofoPartnerPaymentOptions", fofoPartnerPaymentOptions);
 		model.addAttribute("totalNumberOfPaymentOptionId", fofoPartnerPaymentOptions.size());
+		model.addAttribute("stateNames",
-		model.addAttribute("stateNames",  stateRepository.selectAll().stream().map(x->x.getName()).collect(Collectors.toList()));
+				stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList()));
 		return "search-order-details";
+	}
 	private Map<Integer, PaymentOption> paymentOptionIdPaymentOptionMap(
 			List<PaymentOptionTransaction> paymentOptionTransactions) {
 					paymentOptionTransaction);
+		}
 		return paymentOptionIdPaymentOptionTransactionMap;
+	}
 	@RequestMapping(value = "/create-order", method = RequestMethod.POST)
 	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest,
 			Model model) throws ProfitMandiBusinessException {
 		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
 		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 	public ResponseEntity<?> badReturn(HttpServletRequest request, @RequestBody FoiBadReturnRequest foiBadReturnRequest,
 			Model model) throws ProfitMandiBusinessException {
 		LOGGER.info("request at uri {} body {}", request.getRequestURI(), foiBadReturnRequest);
 		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 		CustomerCreditNote custmoerCreditNote;
-		if(roleManager.isAdmin(fofoDetails.getRoleIds())) {
+		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
 			FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
 			FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());
 			custmoerCreditNote = orderService.badReturn(fo.getFofoId(), foiBadReturnRequest);
 		} else {
 			custmoerCreditNote = orderService.badReturn(fofoDetails.getFofoId(), foiBadReturnRequest);
 			pdfModel = orderService.getInvoicePdfModel(orderId);
 		} else {
 			pdfModel = orderService.getInvoicePdfModel(fofoDetails.getFofoId(), orderId);
+		}
 		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-		PdfUtils.generateAndWrite(pdfModel, byteArrayOutputStream);
+		PdfUtils.generateAndWrite(Arrays.asList(pdfModel), byteArrayOutputStream);
 		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
 		final HttpHeaders headers = new HttpHeaders();
 		headers.setContentType(MediaType.APPLICATION_PDF);
 		headers.set("Content-disposition", "inline; filename=invoice-" + pdfModel.getInvoiceNumber() + ".pdf");
 		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
 		final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
 		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
 		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
+	}
+	@RequestMapping(value = "/generateInvoices")
+	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response,
+			@RequestParam LocalDateTime startDate, @RequestParam LocalDateTime endDate, @RequestParam int partnerId)
+			throws ProfitMandiBusinessException {
+		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
+		List<PdfModel> pdfModels = new ArrayList<>();
+		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {
+			List<Integer> orderIds = fofoOrderRepository.selectByFofoId(partnerId, startDate, endDate, 0, 0).stream()
+					.map(x -> x.getId()).collect(Collectors.toList());
+			for (int orderId : orderIds) {
+				pdfModels.add(orderService.getInvoicePdfModel(orderId));
+			}
+			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+			PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
+			LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
+			final HttpHeaders headers = new HttpHeaders();
+			headers.setContentType(MediaType.APPLICATION_PDF);
+			headers.set("Content-disposition", "inline; filename=invoice-" + partnerId + ".pdf");
+			headers.setContentLength(byteArrayOutputStream.toByteArray().length);
+			final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
+			final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
+			return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
+		} else {
+			throw new ProfitMandiBusinessException("Auth", fofoDetails.getEmailId(), "Unauthorised access");
+		}
+	}
 	@RequestMapping(value = "/saleHistory")
 	public String saleHistory(HttpServletRequest request,
 			@RequestParam(name = "searchValue", defaultValue = "") String searchValue,
 			@RequestParam(name = "searchType", defaultValue = "") SearchType searchType,
 			@RequestParam(required = false) LocalDateTime startTime,
 			throw new ProfitMandiBusinessException("Amount", amount, "Sum of amount is not equal to total amount");
+		}
 		return "response";
+	}
 	private Map<String, List<MobileInsurancePlan>> getPlans(float sellingPrice) throws ProfitMandiBusinessException {
 		Map<String, List<MobileInsurancePlan>> productDurationPlans = zestService.getAllPlansByProductAndDuration();
 		Map<String, List<MobileInsurancePlan>> returnPlans = new HashMap<>();
 		productDurationPlans.entrySet().stream().forEach(m -> {

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/OrderController.java – Rev 24440 → 24844