Subversion Repositories SmartDukaan

Rev

Rev 30715 | Rev 31438 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 30715 Rev 31437
Line 47... Line 47...
47 
 
 47 
 
48 
@Controller
 48 
@Controller
49 
@Transactional(rollbackFor = Throwable.class)
 49 
@Transactional(rollbackFor = Throwable.class)
50 
public class PurchaseController {
 50 
public class PurchaseController {
51 
 
 51 
 
52 
	private static final Logger LOGGER = LogManager.getLogger(PurchaseController.class);
 52 
    private static final Logger LOGGER = LogManager.getLogger(PurchaseController.class);
53 
 
 53 
    @Autowired
54 
	@Autowired
 54 
    RestClient restClient;
55 
	private PurchaseService purchaseService;
 55 
    @Autowired
56 
 
 56 
    private PurchaseService purchaseService;
57 
	@Autowired
 57 
    @Autowired
58 
	private PurchaseRepository purchaseRepository;
 58 
    private PurchaseRepository purchaseRepository;
59 
 
 59 
    @Autowired
60 
	@Autowired
 60 
    private InventoryItemRepository inventoryItemRepository;
61 
	private InventoryItemRepository inventoryItemRepository;
 61 
    @Autowired
62 
 
 62 
    private OrderRepository orderRepository;
63 
	@Autowired
 63 
    @Autowired
64 
	private OrderRepository orderRepository;
 64 
    private RoleManager roleManager;
65 
 
 65 
 
66 
	@Autowired
 66 
    @Autowired
67 
	RestClient restClient;
 67 
    private ResponseSender responseSender;
68 
	@Autowired
 68 
 
69 
	private RoleManager roleManager;
 69 
    @Autowired
70 
 
 70 
    private CookiesProcessor cookiesProcessor;
71 
	@Autowired
 71 
 
72 
	private ResponseSender responseSender;
 72 
    @Autowired
73 
 
 73 
    private InvoiceService invoiceService;
74 
	@Autowired
 74 
 
75 
	private CookiesProcessor cookiesProcessor;
 75 
    @RequestMapping(value = "/purchase", method = RequestMethod.GET)
76 
 
 76 
    public String purchase(HttpServletRequest request) throws Exception {
77 
	@Autowired
 77 
        return "purchase";
78 
	private InvoiceService invoiceService;
 78 
    }
79 
 
 79 
 
80 
	@RequestMapping(value = "/purchase", method = RequestMethod.GET)
 80 
    @RequestMapping(value = "/pendingGrn", method = RequestMethod.GET)
81 
	public String purchase(HttpServletRequest request) throws Exception {
 81 
    public String pendingGrn(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
82 
		return "purchase";
 82 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
83 
	}
 83 
        LOGGER.info("Request Received at url {}", request.getRequestURI());
84 
 
 84 
        List<Order> pendingGrns = orderRepository.selectShipmentToDeliveredByRetailerId(fofoDetails.getFofoId());
85 
	@RequestMapping(value = "/pendingGrn", method = RequestMethod.GET)
 85 
        model.addAttribute("pendingGrns", pendingGrns);
86 
	public String pendingGrn(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
 86 
        return "pending-grn";
87 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 87 
    }
88 
		LOGGER.info("Request Received at url {}", request.getRequestURI());
 88 
 
89 
		List<Order> pendingGrns = orderRepository.selectShipmentToDeliveredByRetailerId(fofoDetails.getFofoId());
 89 
    @RequestMapping(value = "/purchase/validate-imeis", method = RequestMethod.POST)
90 
		model.addAttribute("pendingGrns", pendingGrns);
 90 
    public ResponseEntity<?> validatePurchaseImeis(HttpServletRequest request, @RequestBody ImeiInoviceModel imeiInoviceModel, Model model) throws ProfitMandiBusinessException {
91 
		return "pending-grn";
 91 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
92 
	}
 92 
        return responseSender.ok(this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel));
93 
 
 93 
    }
94 
	@RequestMapping(value = "/purchase/validate-imeis", method = RequestMethod.POST)
 94 
 
95 
	public ResponseEntity<?> validatePurchaseImeis(HttpServletRequest request, @RequestBody ImeiInoviceModel imeiInoviceModel, Model model) throws ProfitMandiBusinessException {
 95 
    private Map<String, Boolean> getImeiValidationMap(int fofoId, ImeiInoviceModel imeiInoviceModel) throws ProfitMandiBusinessException {
96 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 96 
        LOGGER.info("serialNumbers - {}", imeiInoviceModel.getSerialNumbers());
97 
		return responseSender.ok(this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel));
 97 
        Set<String> serialNumbers = new HashSet<>(orderRepository.selectSerialNumbers(imeiInoviceModel.getInvoiceNumber(), fofoId, imeiInoviceModel.getSerialNumbers()));
98 
	}
 98 
        Map<String, Boolean> imeiValidationMap = new HashMap<>();
99 
 
 99 
        imeiInoviceModel.getSerialNumbers().stream().forEach(x -> {
100 
	private Map<String, Boolean> getImeiValidationMap(int fofoId, ImeiInoviceModel imeiInoviceModel) throws ProfitMandiBusinessException {
 100 
            imeiValidationMap.put(x, true);
101 
		LOGGER.info("serialNumbers - {}", imeiInoviceModel.getSerialNumbers());
 101 
        });
102 
		Set<String> serialNumbers = new HashSet<>(orderRepository.selectSerialNumbers(imeiInoviceModel.getInvoiceNumber(), fofoId, imeiInoviceModel.getSerialNumbers()));
 102 
        if (serialNumbers.size() > 0) {
103 
		Map<String, Boolean> imeiValidationMap = new HashMap<>();
 103 
            List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId, new HashSet<>(serialNumbers), false);
104 
		imeiInoviceModel.getSerialNumbers().stream().forEach(x -> {
 104 
            Set<String> grnedSerialNumberSet = inventoryItems.stream().filter(x -> x.getPurchase().getPurchaseReference().equals(imeiInoviceModel.getInvoiceNumber()))
105 
			imeiValidationMap.put(x, true);
 105 
                    .map(x -> x.getSerialNumber()).collect(Collectors.toSet());
106 
		});
 106 
            imeiInoviceModel.getSerialNumbers().stream().forEach(imei -> {
107 
		if (serialNumbers.size() > 0) {
 107 
                if (grnedSerialNumberSet.contains(imei)) {
108 
			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId, new HashSet<>(serialNumbers), false);
 108 
                    imeiValidationMap.put(imei, false);
109 
			Set<String> grnedSerialNumberSet = inventoryItems.stream().filter(x -> x.getPurchase().getPurchaseReference().equals(imeiInoviceModel.getInvoiceNumber()))
 109 
                }
110 
					.map(x -> x.getSerialNumber()).collect(Collectors.toSet());
 110 
            });
111 
			imeiInoviceModel.getSerialNumbers().stream().forEach(imei -> {
 111 
 
112 
				if (grnedSerialNumberSet.contains(imei)) {
 112 
        }
113 
					imeiValidationMap.put(imei, false);
 113 
        return imeiValidationMap;
114 
				}
 114 
    }
115 
			});
 115 
 
116 
 
 116 
    @RequestMapping(value = "/purchase/grn-imeis", method = RequestMethod.POST)
117 
		}
 117 
    public ResponseEntity<?> grnImeis(HttpServletRequest request, @RequestBody ImeiInoviceModel imeiInoviceModel, Model model) throws ProfitMandiBusinessException {
118 
		return imeiValidationMap;
 118 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
119 
	}
 119 
        Map<String, Boolean> imeiValidationMap = this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel);
120 
 
 120 
        if (imeiValidationMap.values().stream().filter(x -> !x).findFirst().isPresent()) {
121 
	@RequestMapping(value = "/purchase/grn-imeis", method = RequestMethod.POST)
 121 
            throw new ProfitMandiBusinessException("Found invalid imeis cant proceed", "invalid imeis", "invalid imeis");
122 
	public ResponseEntity<?> grnImeis(HttpServletRequest request, @RequestBody ImeiInoviceModel imeiInoviceModel, Model model) throws ProfitMandiBusinessException {
 122 
        }
123 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 123 
 
124 
		Map<String, Boolean> imeiValidationMap = this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel);
 124 
        Map<Integer, List<String>> itemSerialNumberMap = orderRepository.selectItemSerialNumberMap(imeiInoviceModel.getInvoiceNumber(), fofoDetails.getFofoId(), imeiInoviceModel.getSerialNumbers());
125 
		if (imeiValidationMap.values().stream().filter(x -> !x).findFirst().isPresent()) {
 125 
        for (Map.Entry<Integer, List<String>> itemSerialNumberEntry : itemSerialNumberMap.entrySet()) {
126 
			throw new ProfitMandiBusinessException("Found invalid imeis cant proceed", "invalid imeis", "invalid imeis");
 126 
            ScanSerializedRequest scanSerializedRequest = new ScanSerializedRequest();
127 
		}
 127 
            scanSerializedRequest.setSerialNumbers(itemSerialNumberEntry.getValue());
128 
 
 128 
            scanSerializedRequest.setInvoiceNumber(imeiInoviceModel.getInvoiceNumber());
129 
		Map<Integer, List<String>> itemSerialNumberMap = orderRepository.selectItemSerialNumberMap(imeiInoviceModel.getInvoiceNumber(), fofoDetails.getFofoId(), imeiInoviceModel.getSerialNumbers());
 129 
            scanSerializedRequest.setItemId(itemSerialNumberEntry.getKey());
130 
		for (Map.Entry<Integer, List<String>> itemSerialNumberEntry : itemSerialNumberMap.entrySet()) {
 130 
            purchaseService.scanSerializedItems(scanSerializedRequest, fofoDetails.getFofoId());
131 
			ScanSerializedRequest scanSerializedRequest = new ScanSerializedRequest();
 131 
        }
132 
			scanSerializedRequest.setSerialNumbers(itemSerialNumberEntry.getValue());
 132 
        return responseSender.ok(true);
133 
			scanSerializedRequest.setInvoiceNumber(imeiInoviceModel.getInvoiceNumber());
 133 
    }
134 
			scanSerializedRequest.setItemId(itemSerialNumberEntry.getKey());
 134 
 
135 
			purchaseService.scanSerializedItems(scanSerializedRequest, fofoDetails.getFofoId());
 135 
    @RequestMapping(value = "/purchase/get-imeis", method = RequestMethod.GET)
136 
		}
 136 
    public ResponseEntity<?> getImeis(HttpServletRequest request, @RequestParam String invoiceNumber, @RequestParam int itemId) throws ProfitMandiBusinessException {
137 
		return responseSender.ok(true);
 137 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
138 
	}
 138 
        List<String> serialNumbers = orderRepository.selectSerialNumbersByInvoiceItem(invoiceNumber, itemId, fofoDetails.getFofoId());
139 
 
 139 
        ImeiInoviceModel imeiInoviceModel = new ImeiInoviceModel();
140 
	@RequestMapping(value = "/purchase/get-imeis", method = RequestMethod.GET)
 140 
        imeiInoviceModel.setInvoiceNumber(invoiceNumber);
141 
	public ResponseEntity<?> getImeis(HttpServletRequest request, @RequestParam String invoiceNumber, @RequestParam int itemId) throws ProfitMandiBusinessException {
 141 
        imeiInoviceModel.setSerialNumbers(serialNumbers);
142 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 142 
        List<String> validSerialNumbers = this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel).entrySet().stream().filter(x -> x.getValue()).map(x -> x.getKey()).collect(Collectors.toList());
143 
		List<String> serialNumbers = orderRepository.selectSerialNumbersByInvoiceItem(invoiceNumber, itemId, fofoDetails.getFofoId());
 143 
        return responseSender.ok(validSerialNumbers);
144 
		ImeiInoviceModel imeiInoviceModel = new ImeiInoviceModel();
 144 
    }
145 
		imeiInoviceModel.setInvoiceNumber(invoiceNumber);
 145 
 
146 
		imeiInoviceModel.setSerialNumbers(serialNumbers);
 146 
 
147 
		List<String> validSerialNumbers = this.getImeiValidationMap(fofoDetails.getFofoId(), imeiInoviceModel).entrySet().stream().filter(x -> x.getValue()).map(x -> x.getKey()).collect(Collectors.toList());
 147 
    @RequestMapping(value = "/pendingGrnDetails", method = RequestMethod.GET)
148 
		return responseSender.ok(validSerialNumbers);
 148 
    public String pendingGrnDetails(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) throws ProfitMandiBusinessException {
149 
	}
 149 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
150 
 
 150 
        LOGGER.info("Request Received at url [{}] with orderId [{}]", request.getRequestURI(), orderId);
151 
 
 151 
        model.addAttribute("pendingGrnDetails", purchaseService.getShippingDetailByOrderId(orderId, fofoDetails.getFofoId()));
152 
	@RequestMapping(value = "/pendingGrnDetails", method = RequestMethod.GET)
 152 
        return "pending-grn-details";
153 
	public String pendingGrnDetails(HttpServletRequest request, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId, Model model) throws ProfitMandiBusinessException {
 153 
    }
154 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 154 
 
155 
		LOGGER.info("Request Received at url [{}] with orderId [{}]", request.getRequestURI(), orderId);
 155 
    @RequestMapping(value = "/purchaseByInvoiceNumber", method = RequestMethod.GET)
156 
		model.addAttribute("pendingGrnDetails", purchaseService.getShippingDetailByOrderId(orderId, fofoDetails.getFofoId()));
 156 
    public String purchaseByAirwayBillOrInvoiceNumber(HttpServletRequest request,
157 
		return "pending-grn-details";
 157 
                                                      @RequestParam(name = ProfitMandiConstants.AIRWAY_BILL_OR_INVOICE_NUMBER)
158 
	}
 158 
                                                      String airwayBillOrInvoiceNumber, Model model) throws ProfitMandiBusinessException {
159 
 
 159 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
160 
	@RequestMapping(value = "/purchaseByInvoiceNumber", method = RequestMethod.GET)
 160 
        LOGGER.info("Request Received at url {} with airwayBillOrInvoiceNumber {}", request.getRequestURI(), airwayBillOrInvoiceNumber);
161 
	public String purchaseByAirwayBillOrInvoiceNumber(HttpServletRequest request,
 161 
        Map<String, Object> map = purchaseService.purchaseByInvoiceNumber(airwayBillOrInvoiceNumber, fofoDetails.getFofoId());
162 
													  @RequestParam(name = ProfitMandiConstants.AIRWAY_BILL_OR_INVOICE_NUMBER)
 162 
        model.addAllAttributes(map);
163 
													  String airwayBillOrInvoiceNumber, Model model) throws ProfitMandiBusinessException {
 163 
        return "purchase";
164 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 164 
    }
165 
		LOGGER.info("Request Received at url {} with airwayBillOrInvoiceNumber {}", request.getRequestURI(), airwayBillOrInvoiceNumber);
 165 
 
166 
		Map<String, Object> map = purchaseService.purchaseByInvoiceNumber(airwayBillOrInvoiceNumber, fofoDetails.getFofoId());
 166 
    @RequestMapping(value = "/purchase-invoice/{invoiceNumber}", method = RequestMethod.GET)
167 
		model.addAllAttributes(map);
 167 
    public ResponseEntity<?> downloadInvoice(HttpServletRequest request, @PathVariable String invoiceNumber, Model model) throws Exception {
168 
		return "purchase";
 168 
        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
169 
	}
 169 
        List<String> invoiceNumbers = Arrays.asList(invoiceNumber.replaceAll(" ", "").split(","));
170 
 
 170 
        Map<String, List<Order>> invoiceOrdersMap = orderRepository.selectByInvoiceNumbers(invoiceNumbers).stream().collect(Collectors.groupingBy(x -> x.getInvoiceNumber()));
171 
	@RequestMapping(value = "/purchase-invoice/{invoiceNumber}", method = RequestMethod.GET)
 171 
        if (invoiceOrdersMap.size() > 0) {
172 
	public ResponseEntity<?> downloadInvoice(HttpServletRequest request, @PathVariable String invoiceNumber, Model model) throws Exception {
 172 
            if (roleManager.isAdmin(fofoDetails.getRoleIds()) || invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0).getRetailerId() == fofoDetails.getFofoId()) {
173 
		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 173 
 
174 
		List<String> invoiceNumbers = Arrays.asList(invoiceNumber.replaceAll(" ", "").split(","));
 174 
                final HttpHeaders headers = new HttpHeaders();
175 
		Map<String, List<Order>> invoiceOrdersMap = orderRepository.selectByInvoiceNumbers(invoiceNumbers).stream().collect(Collectors.groupingBy(x -> x.getInvoiceNumber()));
 175 
 
176 
		if (invoiceOrdersMap.size() > 0) {
 176 
 
177 
			if (roleManager.isAdmin(fofoDetails.getRoleIds()) || invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0).getRetailerId() == fofoDetails.getFofoId()) {
 177 
                Map<String, String> headersMap = new HashMap<>();
178 
 
 178 
                headersMap.put("Authorization", "Basic " + Base64.getEncoder().encodeToString("smartdukaan:$smart@123#".getBytes()));
179 
				final HttpHeaders headers = new HttpHeaders();
 179 
                if (invoiceNumbers.size() == 1) {
180 
				headers.setContentType(MediaType.APPLICATION_PDF);
 180 
                    String invoicePath = this.getInvoicePath(invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0));
181 
				headers.set("Content-Type", "application/pdf");
 181 
                    HttpResponse response = restClient.getResponse("http://45.79.106.95/" + invoicePath, null, headersMap);
182 
				headers.set("Content-disposition", "inline; filename=" + invoiceNumber + ".pdf");
 182 
                    headers.setContentType(MediaType.APPLICATION_PDF);
183 
 
 183 
                    headers.set("Content-Type", "application/pdf");
184 
				if (false) {
 184 
                    headers.set("Content-disposition", "inline; filename=" + invoiceNumber + ".pdf");
185 
					/*InvoicePdfModel invoicePdfModel = invoiceService.getInvoicePdfModel(orders);
 185 
                    InputStreamResource is = new InputStreamResource(response.getEntity().getContent());
186 
 
 186 
                    return new ResponseEntity<>(is, headers, HttpStatus.OK);
187 
					ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
 187 
 
188 
					List<InvoicePdfModel> pdfModels = new ArrayList<>();
 188 
                } else {
189 
					pdfModels.add(invoicePdfModel);
 189 
 
190 
					PdfUtils.generateAndWrite(pdfModels, byteArrayOutputStream);
 190 
                    ByteArrayOutputStream fos = new ByteArrayOutputStream();
191 
					final InputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
 191 
                    ZipOutputStream zipOut = new ZipOutputStream(fos);
192 
					final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
 192 
 
193 
					LOGGER.info("Before stream - {}", pdfModels);
 193 
                    for (String invoice : invoiceNumbers) {
194 
					return new ResponseEntity<>(inputStreamResource, headers, HttpStatus.OK);*/
 194 
                        List<Order> orders = invoiceOrdersMap.get(invoice);
195 
				} else {
 195 
                        String invoicePath = this.getInvoicePath(orders.get(0));
196 
					Map<String, String> headersMap = new HashMap<>();
 196 
                        HttpResponse response = restClient.getResponse("http://45.79.106.95/" + invoicePath, null, headersMap);
197 
					headersMap.put("Authorization", "Basic " + Base64.getEncoder().encodeToString("smartdukaan:$smart@123#".getBytes()));
 197 
                        this.addFileToZip(zipOut, response.getEntity().getContent(), invoice + ".pdf");
198 
					if (invoiceNumbers.size() == 1) {
 198 
                    }
199 
						String invoicePath = this.getInvoicePath(invoiceOrdersMap.get(invoiceNumbers.get(0)).get(0));
 199 
                    zipOut.close();
200 
						HttpResponse response = restClient.getResponse("http://45.79.106.95/" + invoicePath, null, headersMap);
 200 
                    byte[] byteArray = fos.toByteArray();
201 
						InputStreamResource is = new InputStreamResource(response.getEntity().getContent());
 201 
                    headers.set("Content-Type", ContentType.APPLICATION_OCTET_STREAM.getMimeType());
202 
						return new ResponseEntity<>(is, headers, HttpStatus.OK);
 202 
                    headers.set("Content-disposition", "attachment; filename=invoices.zip");
203 
 
 203 
                    headers.setContentLength(byteArray.length);
204 
					} else {
 204 
                    final InputStream inputStream = new ByteArrayInputStream(fos.toByteArray());
205 
 
 205 
                    return new ResponseEntity<>(new InputStreamResource(inputStream), headers, HttpStatus.OK);
206 
						ByteArrayOutputStream fos = new ByteArrayOutputStream();
 206 
                }
207 
						ZipOutputStream zipOut = new ZipOutputStream(fos);
 207 
 
208 
 
 208 
            }
209 
						for (String invoice : invoiceNumbers) {
 209 
        } else {
210 
							List<Order> orders = invoiceOrdersMap.get(invoice);
 210 
            throw new ProfitMandiBusinessException("Invalid Invoice", invoiceNumber, "Please check with your manager");
211 
							String invoicePath = this.getInvoicePath(orders.get(0));
 211 
        }
212 
							HttpResponse response = restClient.getResponse("http://45.79.106.95/" + invoicePath, null, headersMap);
 212 
        return null;
213 
							this.addFileToZip(zipOut, response.getEntity().getContent(), invoice + ".pdf");
 213 
    }
214 
						}
 214 
 
215 
						zipOut.close();
 215 
    private void addFileToZip(ZipOutputStream outZip, InputStream inputStream, String fileName) throws Exception {
216 
						byte[] byteArray = fos.toByteArray();
 216 
        byte data[] = new byte[BUFFER_SIZE];
217 
						headers.set("Content-Type", ContentType.APPLICATION_OCTET_STREAM.getMimeType());
 217 
        ZipEntry entry = new ZipEntry(fileName);
218 
						headers.set("Content-disposition", "attachment; filename=invoices.zip");
 218 
        outZip.putNextEntry(entry);
219 
						headers.setContentLength(byteArray.length);
 219 
        IOUtils.copy(inputStream, outZip);
220 
						final InputStream inputStream = new ByteArrayInputStream(fos.toByteArray());
 220 
        outZip.closeEntry();
221 
						return new ResponseEntity<>(new InputStreamResource(inputStream), headers, HttpStatus.OK);
 221 
    }
222 
					}
 222 
 
223 
				}
 223 
    private String getInvoicePath(Order order) {
224 
 
 224 
        LocalDateTime billTime = order.getBillingTimestamp();
225 
			}
 225 
        String dirPath = billTime.getYear() + "-" + (billTime.getMonthValue() - 1) + File.separator + order.getRetailerId();
226 
		} else {
 226 
        String filename = dirPath + File.separator + order.getInvoiceNumber() + ".pdf";
227 
			throw new ProfitMandiBusinessException("Invalid Invoice", invoiceNumber, "Please check with your manager");
 227 
        return filename;
228 
		}
 228 
    }
229 
		return null;
 - 
 
230 
	}
 - 
 
231 
 
 - 
 
232 
	private void addFileToZip(ZipOutputStream outZip, InputStream inputStream, String fileName) throws Exception {
 - 
 
233 
		byte data[] = new byte[BUFFER_SIZE];
 - 
 
234 
		ZipEntry entry = new ZipEntry(fileName);
 - 
 
235 
		outZip.putNextEntry(entry);
 - 
 
236 
		IOUtils.copy(inputStream, outZip);
 - 
 
237 
		outZip.closeEntry();
 - 
 
238 
	}
 - 
 
239 
 
 - 
 
240 
	private String getInvoicePath(Order order) {
 - 
 
241 
		LocalDateTime billTime = order.getBillingTimestamp();
 - 
 
242 
		String dirPath = billTime.getYear() + "-" + (billTime.getMonthValue() - 1) + File.separator + order.getRetailerId();
 - 
 
243 
		String filename = dirPath + File.separator + order.getInvoiceNumber() + ".pdf";
 - 
 
244 
		return filename;
 - 
 
245 
	}
 - 
 
246 
}
 229 
}
247 

            230