Subversion Repositories SmartDukaan

Rev

Rev 21896 | Rev 21965 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
21612 ashik.ali 1 
package com.spice.profitmandi.web.controller;
2 
 
21689 ashik.ali 3 
import java.io.ByteArrayInputStream;
4 
import java.io.ByteArrayOutputStream;
5 
import java.io.InputStream;
21680 ashik.ali 6 
import java.util.ArrayList;
7 
import java.util.HashMap;
21612 ashik.ali 8 
import java.util.HashSet;
21680 ashik.ali 9 
import java.util.List;
10 
import java.util.Map;
21612 ashik.ali 11 
import java.util.Set;
12 
 
13 
import javax.servlet.http.HttpServletRequest;
21689 ashik.ali 14 
import javax.servlet.http.HttpServletResponse;
21612 ashik.ali 15 
 
16 
import org.slf4j.Logger;
17 
import org.slf4j.LoggerFactory;
18 
import org.springframework.beans.factory.annotation.Autowired;
21689 ashik.ali 19 
import org.springframework.core.io.InputStreamResource;
20 
import org.springframework.http.HttpHeaders;
21 
import org.springframework.http.HttpStatus;
22 
import org.springframework.http.MediaType;
23 
import org.springframework.http.ResponseEntity;
21612 ashik.ali 24 
import org.springframework.stereotype.Controller;
21919 ashik.ali 25 
import org.springframework.transaction.annotation.Transactional;
21612 ashik.ali 26 
import org.springframework.web.bind.annotation.RequestBody;
27 
import org.springframework.web.bind.annotation.RequestMapping;
28 
import org.springframework.web.bind.annotation.RequestMethod;
21689 ashik.ali 29 
import org.springframework.web.bind.annotation.RequestParam;
21612 ashik.ali 30 
 
31 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
21680 ashik.ali 32 
import com.spice.profitmandi.common.model.CustomAddress;
21689 ashik.ali 33 
import com.spice.profitmandi.common.model.CustomCustomer;
34 
import com.spice.profitmandi.common.model.CustomFofoLineItem;
35 
import com.spice.profitmandi.common.model.CustomFofoOrderItem;
36 
import com.spice.profitmandi.common.model.CustomRetailer;
21896 ashik.ali 37 
import com.spice.profitmandi.common.model.GstRate;
21689 ashik.ali 38 
import com.spice.profitmandi.common.model.PdfModel;
21612 ashik.ali 39 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
21689 ashik.ali 40 
import com.spice.profitmandi.common.util.PdfUtils;
21680 ashik.ali 41 
import com.spice.profitmandi.common.util.StringUtils;
21896 ashik.ali 42 
import com.spice.profitmandi.common.util.Utils;
21728 ashik.ali 43 
import com.spice.profitmandi.dao.entity.catalog.Item;
44 
import com.spice.profitmandi.dao.entity.dtr.Retailer;
45 
import com.spice.profitmandi.dao.entity.dtr.User;
46 
import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;
47 
import com.spice.profitmandi.dao.entity.fofo.Customer;
48 
import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
21896 ashik.ali 49 
import com.spice.profitmandi.dao.entity.fofo.FofoItemId;
21728 ashik.ali 50 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
51 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItemSerialNumber;
52 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
53 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
54 
import com.spice.profitmandi.dao.entity.fofo.InvoiceNumberGenerationSequence;
55 
import com.spice.profitmandi.dao.entity.fofo.PaymentOption;
56 
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
57 
import com.spice.profitmandi.dao.entity.user.Address;
58 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
21883 kshitij.so 59 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
21728 ashik.ali 60 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
61 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
62 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
63 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
64 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
65 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
66 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
67 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
68 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemSerialNumberRepository;
69 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
70 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
71 
import com.spice.profitmandi.dao.repository.fofo.InvoiceNumberGenerationSequenceRepository;
72 
import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
73 
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
74 
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
75 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
21612 ashik.ali 76 
import com.spice.profitmandi.web.model.FofoDetails;
77 
import com.spice.profitmandi.web.request.CreateOrderRequest;
78 
import com.spice.profitmandi.web.request.CustomPaymentOption;
21680 ashik.ali 79 
import com.spice.profitmandi.web.response.ItemIdQuantityAvailability;
80 
import com.spice.profitmandi.web.response.Quantity;
21612 ashik.ali 81 
import com.spice.profitmandi.web.util.CookiesFetcher;
82 
import com.spice.profitmandi.web.util.MVCResponseSender;
83 
 
84 
@Controller
21919 ashik.ali 85 
@Transactional(rollbackFor = Throwable.class)
21612 ashik.ali 86 
public class OrderController {
87 
 
88 
	private static final Logger LOGGER = LoggerFactory.getLogger(OrderController.class);
21896 ashik.ali 89 
 
21612 ashik.ali 90 
	@Autowired
91 
	OrderRepository orderRepository;
21896 ashik.ali 92 
 
21612 ashik.ali 93 
	@Autowired
94 
	InventoryItemRepository inventoryItemRepository;
21896 ashik.ali 95 
 
21612 ashik.ali 96 
	@Autowired
21680 ashik.ali 97 
	CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
21896 ashik.ali 98 
 
21680 ashik.ali 99 
	@Autowired
100 
	InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;
21896 ashik.ali 101 
 
21680 ashik.ali 102 
	@Autowired
103 
	CustomerRepository customerRepository;
21896 ashik.ali 104 
 
21680 ashik.ali 105 
	@Autowired
106 
	AddressRepository addressRepository;
21896 ashik.ali 107 
 
21680 ashik.ali 108 
	@Autowired
109 
	FofoLineItemSerialNumberRepository fofoLineItemSerialNumberRepository;
21896 ashik.ali 110 
 
21680 ashik.ali 111 
	@Autowired
112 
	FofoLineItemRepository fofoLineItemRepository;
21896 ashik.ali 113 
 
21680 ashik.ali 114 
	@Autowired
115 
	PaymentOptionRepository paymentOptionRepository;
21896 ashik.ali 116 
 
21680 ashik.ali 117 
	@Autowired
118 
	ScanRecordRepository scanRecordRepository;
21896 ashik.ali 119 
 
21680 ashik.ali 120 
	@Autowired
121 
	FofoOrderRepository fofoOrderRepository;
21896 ashik.ali 122 
 
21680 ashik.ali 123 
	@Autowired
21689 ashik.ali 124 
	RetailerRepository retailerRepository;
21896 ashik.ali 125 
 
21689 ashik.ali 126 
	@Autowired
127 
	UserRepository userRepository;
21896 ashik.ali 128 
 
21689 ashik.ali 129 
	@Autowired
130 
	UserAccountRepository userAccountRepository;
21896 ashik.ali 131 
 
21689 ashik.ali 132 
	@Autowired
133 
	RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
21896 ashik.ali 134 
 
21689 ashik.ali 135 
	@Autowired
21711 ashik.ali 136 
	CustomerAddressRepository customerAddressRepository;
21896 ashik.ali 137 
 
21711 ashik.ali 138 
	@Autowired
21896 ashik.ali 139 
	ItemRepository itemRepository;
140 
 
141 
	@Autowired
21612 ashik.ali 142 
	MVCResponseSender mvcResponseSender;
21896 ashik.ali 143 
 
21612 ashik.ali 144 
	@Autowired
145 
	CookiesFetcher cookiesFetcher;
146 
 
21896 ashik.ali 147 
	@RequestMapping(value = "/order", method = RequestMethod.POST)
148 
	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest)  throws Throwable{
21680 ashik.ali 149 
		//FofoDetails fofoDetails = cookiesFetcher.getCookiesObject(request);
150 
		LOGGER.info("/order request {}", createOrderRequest);
151 
		FofoDetails fofoDetails = new FofoDetails();
152 
		fofoDetails.setFofoId(963490);
21919 ashik.ali 153 
		return this.createOrder(createOrderRequest, fofoDetails);
154 
	}
155 
 
156 
	private String createOrder(CreateOrderRequest createOrderRequest, FofoDetails fofoDetails) throws ProfitMandiBusinessException{
21680 ashik.ali 157 
		Set<Integer> itemIds = new HashSet<>();
21896 ashik.ali 158 
		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); //this is for error
159 
		Map<Integer, CustomFofoLineItem> customFofoLineItemMap = new HashMap<>();
160 
		Map<Integer, Float> lineItemPrice = new HashMap<>(); //this is for pricing error
161 
		float totalAmount = 0;
162 
		for(CustomFofoLineItem customFofoLineItem : createOrderRequest.getFofoLineItems()){
163 
			itemIds.add(customFofoLineItem.getItemId());
164 
			if(!customFofoLineItem.getSerialNumbers().isEmpty() && customFofoLineItem.getQuantity() != customFofoLineItem.getSerialNumbers().size()){
165 
				itemIdQuantity.put(customFofoLineItem.getItemId(), customFofoLineItem.getQuantity());
21680 ashik.ali 166 
			}
21896 ashik.ali 167 
			if(!(customFofoLineItem.getSellingPrice() > 0)){
168 
				lineItemPrice.put(customFofoLineItem.getItemId(), customFofoLineItem.getSellingPrice());
169 
			}else{
170 
				totalAmount = totalAmount + customFofoLineItem.getSellingPrice() * customFofoLineItem.getQuantity();
21680 ashik.ali 171 
			}
21896 ashik.ali 172 
			customFofoLineItemMap.put(customFofoLineItem.getItemId(), customFofoLineItem);
21680 ashik.ali 173 
		}
174 
		if(!itemIdQuantity.isEmpty()){
175 
			// if item quantity does not match with given serialnumbers size
176 
			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);
177 
			return "error";
178 
		}
179 
		try{
180 
			this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);
181 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
182 
			LOGGER.error("Error occured while validating payment options : ", profitMandiBusinessException);
183 
			return "error";
184 
		}
21896 ashik.ali 185 
		if(!lineItemPrice.isEmpty()){
186 
			// given fofo line item price must be greater than zero
187 
			LOGGER.error("requested itemId's selling price must greater than 0");
188 
			return "error";
189 
		}
190 
 
191 
		List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository.selectByFofoItemIds(fofoDetails.getFofoId(), itemIds);
192 
		if(itemIds.size() != currentInventorySnapshots.size()){
193 
			// error
194 
		}
195 
		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); //this is for error
196 
		for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
197 
			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(currentInventorySnapshot.getId().getItemId());
198 
			if(customFofoLineItem.getQuantity() > currentInventorySnapshot.getAvailability()){
199 
				ItemIdQuantityAvailability itemIdQuantityAvailability = new ItemIdQuantityAvailability();
200 
				itemIdQuantityAvailability.setItemId(customFofoLineItem.getItemId());
201 
				Quantity quantity = new Quantity();
202 
				quantity.setAvailable(currentInventorySnapshot.getAvailability());
203 
				quantity.setRequested(customFofoLineItem.getQuantity());
204 
				itemIdQuantityAvailability.setQuantity(quantity);
205 
				itemIdQuantityAvailabilities.add(itemIdQuantityAvailability);
206 
			}
207 
 
208 
		}
209 
 
210 
 
211 
 
21680 ashik.ali 212 
		if(!itemIdQuantityAvailabilities.isEmpty()){
213 
			// itemIdQuantity request is not valid
214 
			LOGGER.error("Requested quantities should not be greater than currently available quantities {}", itemIdQuantityAvailabilities);
215 
			return "error";
216 
		}
21896 ashik.ali 217 
 
218 
 
219 
 
21680 ashik.ali 220 
		Set<Integer> invalidItemIdSerialNumbers = new HashSet<>();
221 
		Map<Integer, Set<String>> itemIdSerialNumbers = new HashMap<>();
222 
		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), itemIds);
21896 ashik.ali 223 
 
21711 ashik.ali 224 
		Map<Integer, Float> itemIdPriceDropAmount = new HashMap<>();
21896 ashik.ali 225 
 
21680 ashik.ali 226 
		for(InventoryItem inventoryItem : inventoryItems){
21896 ashik.ali 227 
			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(inventoryItem.getItemId());
228 
			if(customFofoLineItem.getSerialNumbers().isEmpty()){
229 
				if(!(inventoryItem.getSerialNumber() == null && inventoryItem.getSerialNumber().equals(""))){
230 
					invalidItemIdSerialNumbers.add(inventoryItem.getItemId());
231 
				}
232 
			}
233 
			if(!customFofoLineItem.getSerialNumbers().isEmpty()){
234 
				if(!customFofoLineItem.getSerialNumbers().contains(inventoryItem.getSerialNumber())){
235 
					if(!itemIdSerialNumbers.containsKey(customFofoLineItem.getItemId())){
236 
						Set<String> serialNumbers = new HashSet<>();
237 
						serialNumbers.add(inventoryItem.getSerialNumber());
238 
						itemIdSerialNumbers.put(customFofoLineItem.getItemId(), serialNumbers);
239 
					}else{
240 
						itemIdSerialNumbers.get(customFofoLineItem.getItemId()).add(inventoryItem.getSerialNumber());
21680 ashik.ali 241 
					}
242 
				}
243 
			}
21896 ashik.ali 244 
			itemIdPriceDropAmount.put(inventoryItem.getItemId(), inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount());
21680 ashik.ali 245 
		}
21896 ashik.ali 246 
 
21680 ashik.ali 247 
		if(!invalidItemIdSerialNumbers.isEmpty()){
248 
			LOGGER.error("Invalid itemId's serialNumbers {}", invalidItemIdSerialNumbers);
249 
			// itemId's are serialized you are saying these are not serialized
250 
			return "error";
251 
		}
21896 ashik.ali 252 
 
21680 ashik.ali 253 
		if(!itemIdSerialNumbers.isEmpty()){
254 
			LOGGER.error("Invalid itemId's serialNumbers {}", itemIdSerialNumbers);
255 
			// itemId's are non serialized you are saying these are serialized
256 
			return "error";
257 
		}
21896 ashik.ali 258 
 
259 
		List<Item> items = itemRepository.selectByIds(itemIds);
260 
 
261 
		if(items.size() != itemIds.size()){
262 
			LOGGER.error("Requested ItemIds not found in catalog");
263 
			// invalid itemIds
264 
			return "error";
265 
		}
266 
 
267 
		Map<Integer, Item> itemIdDetails = this.toItemMap(items);
268 
 
21680 ashik.ali 269 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
270 
		try{
271 
			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoDetails.getFofoId());
272 
			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
273 
			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
274 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
275 
			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
276 
			invoiceNumberGenerationSequence.setFofoId(fofoDetails.getFofoId());
277 
			invoiceNumberGenerationSequence.setPrefix("INVOICE");
278 
			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
279 
		}
21896 ashik.ali 280 
 
21680 ashik.ali 281 
		CustomCustomer customCustomer = createOrderRequest.getCustomer();
21896 ashik.ali 282 
 
21680 ashik.ali 283 
		if(!StringUtils.isValidEmailAddress(customCustomer.getEmailId())){
284 
			LOGGER.error("invalid customer emailId {} ", customCustomer.getEmailId());
285 
			return "error";
286 
		}
21896 ashik.ali 287 
 
21680 ashik.ali 288 
		if(!StringUtils.isValidMobile(customCustomer.getMobileNumber())){
289 
			LOGGER.error("invalid customer mobileNumber {} ", customCustomer.getMobileNumber());
290 
			return "error";
291 
		}
21896 ashik.ali 292 
 
21680 ashik.ali 293 
		Customer customer = null;
21919 ashik.ali 294 
		boolean foundCustomer = false;
295 
		if(customCustomer.getCustomerAddressId() > 0){
296 
			try{
297 
				customer = customerRepository.selectById(customCustomer.getCustomerAddressId());
298 
			}catch(ProfitMandiBusinessException profitMandiBusinessException){
299 
				LOGGER.error("Error : ", profitMandiBusinessException);
300 
				foundCustomer = true;
301 
			}
302 
		}else{
303 
			try{
304 
				customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
305 
			}catch(ProfitMandiBusinessException profitMandiBusinessException){
306 
				LOGGER.error("Error : ", profitMandiBusinessException);
307 
				foundCustomer = true;
308 
			}
309 
		}
310 
		LOGGER.error("Error occured : {}", foundCustomer);
311 
		if(foundCustomer){
21680 ashik.ali 312 
			customer = new Customer();
21883 kshitij.so 313 
			customer.setName(customCustomer.getName());
21680 ashik.ali 314 
			customer.setEmailId(customCustomer.getEmailId());
315 
			customer.setMobileNumber(customCustomer.getMobileNumber());
316 
			customerRepository.persist(customer);
317 
		}
21896 ashik.ali 318 
		//TODO:Check if createOrderRequest contains addressId
21711 ashik.ali 319 
		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress());
320 
		customerAddress.setCustomerId(customer.getId());
321 
		customerAddressRepository.persist(customerAddress);
21896 ashik.ali 322 
 
323 
			/*InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = */
324 
 
325 
 
21680 ashik.ali 326 
		FofoOrder fofoOrder = new FofoOrder();
327 
		fofoOrder.setCustomerId(customer.getId());
328 
		fofoOrder.setFofoId(fofoDetails.getFofoId());
329 
		fofoOrder.setInvoiceNumber(invoiceNumberGenerationSequence.getPrefix() + invoiceNumberGenerationSequence.getSequence());
330 
		fofoOrder.setTotalAmount(totalAmount);
21886 kshitij.so 331 
		fofoOrder.setCustomerAddressId(customerAddress.getId());
21680 ashik.ali 332 
		fofoOrderRepository.persist(fofoOrder);
21896 ashik.ali 333 
 
21680 ashik.ali 334 
		for(CustomPaymentOption customPaymentOption : createOrderRequest.getPaymentOptions()){
335 
			PaymentOption paymentOption = new PaymentOption();
336 
			paymentOption.setOrderId(fofoOrder.getId());
337 
			paymentOption.setAmount(customPaymentOption.getAmount());
338 
			paymentOption.setType(customPaymentOption.getType());
339 
			paymentOptionRepository.persist(paymentOption);
340 
		}
341 
 
21896 ashik.ali 342 
		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoDetails.getFofoId()));
21919 ashik.ali 343 
 
344 
		Map<String, GstRate> gstRateMap = null;
345 
		if(retailerAddress.getState().equals(customerAddress.getState())){
346 
			LOGGER.info("inter gstRate = true");
347 
			gstRateMap = Utils.getInterGstRates();
348 
		}else{
349 
			gstRateMap = Utils.getGstRates(retailerAddress.getState());
350 
		}
351 
		LOGGER.info("gstRateMap {}", gstRateMap);
21680 ashik.ali 352 
		for(CustomFofoLineItem customFofoLineItem : createOrderRequest.getFofoLineItems()){
353 
			FofoLineItem fofoLineItem = new FofoLineItem();
354 
			fofoLineItem.setItemId(customFofoLineItem.getItemId());
355 
			fofoLineItem.setQuantity(customFofoLineItem.getQuantity());
21690 ashik.ali 356 
			fofoLineItem.setSellingPrice(customFofoLineItem.getSellingPrice());
21680 ashik.ali 357 
			fofoLineItem.setOrderId(fofoOrder.getId());
358 
			fofoLineItem.setDp(customFofoLineItem.getSellingPrice());
21896 ashik.ali 359 
			Item item = itemIdDetails.get(customFofoLineItem.getItemId());
360 
			GstRate gstRate = gstRateMap.get(item.getHsnCode());
361 
			fofoLineItem.setIgstRate(gstRate.getIgstRate());
362 
			fofoLineItem.setCgstRate(gstRate.getCgstRate());
363 
			fofoLineItem.setSgstRate(gstRate.getSgstRate());
21919 ashik.ali 364 
			fofoLineItem.setHsnCode(gstRate.getHsnCode());
21711 ashik.ali 365 
			fofoLineItem.setCost(itemIdPriceDropAmount.get(customFofoLineItem.getItemId()));
21896 ashik.ali 366 
			fofoLineItem.setBrand(item.getBrand());
367 
			fofoLineItem.setModelName(item.getModelName());
368 
			fofoLineItem.setModelNumber(item.getModelNumber());
369 
			fofoLineItem.setColor(item.getColor());
21680 ashik.ali 370 
			fofoLineItemRepository.persist(fofoLineItem);
371 
			LOGGER.info("\n\n");
372 
			if(!customFofoLineItem.getSerialNumbers().isEmpty()){
373 
				for(String serialNumber : customFofoLineItem.getSerialNumbers()){
374 
					FofoLineItemSerialNumber fofoLineItemSerialNumber = new FofoLineItemSerialNumber();
375 
					fofoLineItemSerialNumber.setFofoLineItemId(fofoLineItem.getId());
376 
					fofoLineItemSerialNumber.setSerialNumber(serialNumber);
377 
					fofoLineItemSerialNumberRepository.persist(fofoLineItemSerialNumber);
378 
				}
379 
			}
21896 ashik.ali 380 
 
381 
			for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
382 
				FofoItemId fofoItemId = new FofoItemId();
383 
				fofoItemId.setFofoId(fofoDetails.getFofoId());
384 
				fofoItemId.setItemId(fofoLineItem.getItemId());
385 
				if(currentInventorySnapshot.getId().equals(fofoItemId)){
386 
					currentInventorySnapshotRepository.updateAvailabilityByFofoItemId(fofoItemId, currentInventorySnapshot.getAvailability() - customFofoLineItem.getQuantity());
387 
				}
388 
			}
21680 ashik.ali 389 
			for(InventoryItem inventoryItem : inventoryItems){
390 
				if(inventoryItem.getItemId() == fofoLineItem.getItemId()){
391 
					if(inventoryItem.getSerialNumber() == null || inventoryItem.getSerialNumber().isEmpty()){
392 
						if(fofoLineItem.getQuantity() > 0)
21896 ashik.ali 393 
						if(fofoLineItem.getQuantity() <= inventoryItem.getGoodQuantity()){
394 
							inventoryItem.setGoodQuantity(inventoryItem.getGoodQuantity() - fofoLineItem.getQuantity());
395 
							inventoryItem.setLastScanType(ScanType.SALE);
396 
							inventoryItemRepository.persist(inventoryItem);
397 
							ScanRecord scanRecord = new ScanRecord();
398 
							scanRecord.setInventoryItemId(inventoryItem.getId());
399 
							scanRecord.setFofoId(fofoDetails.getFofoId());
400 
							scanRecord.setQuantity(fofoLineItem.getQuantity());
401 
							scanRecord.setType(ScanType.SALE);
402 
							scanRecordRepository.persist(scanRecord);
403 
						}else{
404 
							int availableGoodQuantity = inventoryItem.getGoodQuantity();
405 
							inventoryItem.setGoodQuantity(0);
406 
							fofoLineItem.setQuantity(fofoLineItem.getQuantity() - availableGoodQuantity);
407 
							inventoryItem.setLastScanType(ScanType.SALE);
408 
							inventoryItemRepository.persist(inventoryItem);
409 
							ScanRecord scanRecord = new ScanRecord();
410 
							scanRecord.setInventoryItemId(inventoryItem.getId());
411 
							scanRecord.setFofoId(fofoDetails.getFofoId());
412 
							scanRecord.setQuantity(availableGoodQuantity);
413 
							scanRecord.setType(ScanType.SALE);
414 
							scanRecordRepository.persist(scanRecord);
415 
						}
21680 ashik.ali 416 
					}else{
417 
						inventoryItem.setGoodQuantity(0);
418 
						inventoryItem.setLastScanType(ScanType.SALE);
419 
						inventoryItemRepository.persist(inventoryItem);
420 
						ScanRecord scanRecord = new ScanRecord();
421 
						scanRecord.setInventoryItemId(inventoryItem.getId());
422 
						scanRecord.setFofoId(fofoDetails.getFofoId());
423 
						scanRecord.setQuantity(1);
424 
						scanRecord.setType(ScanType.SALE);
425 
						scanRecordRepository.persist(scanRecord);
426 
					}
427 
				}
21919 ashik.ali 428 
			}
21680 ashik.ali 429 
		}
21612 ashik.ali 430 
		return null;
431 
	}
21896 ashik.ali 432 
 
433 
 
434 
	private Map<Integer, Item> toItemMap(List<Item> items){
435 
		Map<Integer, Item> map = new HashMap<>();
21680 ashik.ali 436 
		for(Item item : items){
21896 ashik.ali 437 
			map.put(item.getId(), item);
21680 ashik.ali 438 
		}
439 
		return map;
440 
	}
21896 ashik.ali 441 
 
21711 ashik.ali 442 
	/*private Address createAddress(CustomAddress customAddress){
21680 ashik.ali 443 
		Address address = new Address();
444 
		address.setName(customAddress.getName());
445 
		address.setLine1(customAddress.getLine1());
446 
		address.setLine2(customAddress.getLine2());
447 
		address.setLandmark(customAddress.getLandmark());
448 
		address.setCity(customAddress.getCity());
449 
		address.setPinCode(customAddress.getPinCode());
450 
		address.setState(customAddress.getState());
451 
		address.setCountry(customAddress.getCountry());
452 
		address.setPhoneNumber(customAddress.getPhoneNumber());
453 
		address.setEnabled(true);
454 
		return address;
21711 ashik.ali 455 
	}*/
21896 ashik.ali 456 
 
21711 ashik.ali 457 
	private CustomerAddress createCustomerAddress(CustomAddress customAddress){
458 
		CustomerAddress customerAddress = new CustomerAddress();
459 
		customerAddress.setName(customAddress.getName());
460 
		customerAddress.setLine1(customAddress.getLine1());
461 
		customerAddress.setLine2(customAddress.getLine2());
462 
		customerAddress.setLandmark(customAddress.getLandmark());
463 
		customerAddress.setCity(customAddress.getCity());
464 
		customerAddress.setPinCode(customAddress.getPinCode());
465 
		customerAddress.setState(customAddress.getState());
466 
		customerAddress.setCountry(customAddress.getCountry());
467 
		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());
468 
		return customerAddress;
21680 ashik.ali 469 
	}
21896 ashik.ali 470 
 
21689 ashik.ali 471 
	private CustomAddress createCustomAddress(Address address){
472 
		CustomAddress customAddress = new CustomAddress();
473 
		customAddress.setName(address.getName());
474 
		customAddress.setLine1(address.getLine1());
475 
		customAddress.setLine2(address.getLine2());
476 
		customAddress.setLandmark(address.getLandmark());
477 
		customAddress.setCity(address.getCity());
478 
		customAddress.setPinCode(address.getPinCode());
479 
		customAddress.setState(address.getState());
480 
		customAddress.setCountry(address.getCountry());
481 
		customAddress.setPhoneNumber(address.getPhoneNumber());
482 
		return customAddress;
21680 ashik.ali 483 
	}
21896 ashik.ali 484 
 
21711 ashik.ali 485 
	private CustomAddress createCustomAddress(CustomerAddress customerAddress){
486 
		CustomAddress customAddress = new CustomAddress();
487 
		customAddress.setName(customerAddress.getName());
488 
		customAddress.setLine1(customerAddress.getLine1());
489 
		customAddress.setLine2(customerAddress.getLine2());
490 
		customAddress.setLandmark(customerAddress.getLandmark());
491 
		customAddress.setCity(customerAddress.getCity());
492 
		customAddress.setPinCode(customerAddress.getPinCode());
493 
		customAddress.setState(customerAddress.getState());
494 
		customAddress.setCountry(customerAddress.getCountry());
495 
		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());
496 
		return customAddress;
497 
	}
21896 ashik.ali 498 
 
21680 ashik.ali 499 
	private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount) throws ProfitMandiBusinessException
21612 ashik.ali 500 
	{
501 
		float calculatedAmount = 0;
502 
		Set<String> paymentOptionTypes = new HashSet<>();
503 
		for(CustomPaymentOption customPaymentOption : customPaymentOptions){
21680 ashik.ali 504 
			if(paymentOptionTypes.contains(customPaymentOption.getType().name())){
21612 ashik.ali 505 
				throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_TYPE, customPaymentOption.getType().name(), "");
21680 ashik.ali 506 
			}else{
507 
				paymentOptionTypes.add(customPaymentOption.getType().name());
508 
				calculatedAmount = calculatedAmount + customPaymentOption.getAmount();
21612 ashik.ali 509 
			}
510 
		}
511 
		if(calculatedAmount != totalAmount){
512 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_CALCULATED_AMOUNT, calculatedAmount, "");
513 
		}
514 
	}
21896 ashik.ali 515 
 
516 
 
21689 ashik.ali 517 
	@RequestMapping(value = "/generateInvoice")
21896 ashik.ali 518 
	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws Throwable{
21689 ashik.ali 519 
		LOGGER.info("Request received at url {} with params {} ", request.getRequestURI(), request.getParameterMap());
520 
		//FofoDetails fofoDetails = cookiesFetcher.getCookiesObject(request);
21896 ashik.ali 521 
 
21689 ashik.ali 522 
		FofoDetails fofoDetails = new FofoDetails();
523 
		fofoDetails.setFofoId(963490);
524 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
525 
		PdfModel pdfModel = new PdfModel();
526 
		pdfModel.setAuther("profitmandi");
527 
		pdfModel.setTitle("Retailer Invoice");
528 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
529 
		CustomCustomer customCustomer = new CustomCustomer();
530 
		customCustomer.setName(customer.getName());
531 
		customCustomer.setEmailId(customer.getEmailId());
532 
		customCustomer.setMobileNumber(customer.getMobileNumber());
21711 ashik.ali 533 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
21689 ashik.ali 534 
		customCustomer.setAddress(this.createCustomAddress(customerAddress));
535 
		pdfModel.setCustomer(customCustomer);
536 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
21919 ashik.ali 537 
		//pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
21896 ashik.ali 538 
 
21689 ashik.ali 539 
		Retailer retailer = retailerRepository.selectById(fofoDetails.getFofoId());
540 
		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));
541 
		CustomRetailer customRetailer = new CustomRetailer();
542 
		customRetailer.setBusinessName(retailer.getName());
543 
		customRetailer.setMobileNumber(user.getMobileNumber());
544 
		customRetailer.setTinNumber(retailer.getNumber());
545 
		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));
546 
		customRetailer.setAddress(this.createCustomAddress(retailerAddress));
547 
		pdfModel.setRetailer(customRetailer);
548 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByOrderId(fofoOrder.getId());
21896 ashik.ali 549 
 
21689 ashik.ali 550 
		Set<CustomFofoOrderItem> customerFofoOrderItems = new HashSet<>();
551 
		for(FofoLineItem fofoLineItem : fofoLineItems){
552 
			CustomFofoOrderItem customFofoOrderItem = new CustomFofoOrderItem();
553 
			customFofoOrderItem.setAmount(fofoLineItem.getQuantity() * fofoLineItem.getSellingPrice());
554 
			customFofoOrderItem.setDescription(fofoLineItem.getBrand() + " " + fofoLineItem.getModelName() + " " + fofoLineItem.getModelNumber() + " " + fofoLineItem.getColor());
21919 ashik.ali 555 
			float totalTaxRate = fofoLineItem.getIgstRate() + fofoLineItem.getSgstRate() + fofoLineItem.getCgstRate();
556 
			float taxableAmount = customFofoOrderItem.getAmount() / (1 + (totalTaxRate / 100));
557 
			//float itemTotal = customFofoOrderItem.getAmount() + taxableAmount;
558 
			//LOGGER.info("totalTaxRate ={}, taxableAmount ={}, itemTotal ={}", totalTaxRate, taxableAmount, itemTotal);
21689 ashik.ali 559 
			customFofoOrderItem.setRate(fofoLineItem.getSellingPrice());
560 
			customFofoOrderItem.setQuantity(fofoLineItem.getQuantity());
21919 ashik.ali 561 
			float igstAmount = (taxableAmount * fofoLineItem.getIgstRate()) / 100;
562 
			float cgstAmount = (taxableAmount * fofoLineItem.getCgstRate()) / 100;
563 
			float sgstAmount = (taxableAmount * fofoLineItem.getSgstRate()) / 100;
564 
			LOGGER.info("igst [{},{}], cgst [{},{}], sgst[{},{}]", fofoLineItem.getIgstRate(), igstAmount, fofoLineItem.getCgstRate(), cgstAmount, fofoLineItem.getSgstRate(), sgstAmount);
21896 ashik.ali 565 
			customFofoOrderItem.setIgstRate(fofoLineItem.getIgstRate());
21919 ashik.ali 566 
			customFofoOrderItem.setIgstAmount(igstAmount);
567 
			customFofoOrderItem.setCgstRate(fofoLineItem.getCgstRate());
568 
			customFofoOrderItem.setCgstAmount(cgstAmount);
569 
			customFofoOrderItem.setSgstRate(fofoLineItem.getSgstRate());
570 
			customFofoOrderItem.setSgstAmount(sgstAmount);
21896 ashik.ali 571 
			customFofoOrderItem.setHsnCode(fofoLineItem.getHsnCode());
21919 ashik.ali 572 
			customFofoOrderItem.setItemTotal(customFofoOrderItem.getAmount() + igstAmount + cgstAmount + sgstAmount);
21689 ashik.ali 573 
			customFofoOrderItem.setSerialNumbers(String.join(", ",this.toSerialNumbers(fofoLineItem.getFofoLineItemSerialNumbers())));
574 
			customerFofoOrderItems.add(customFofoOrderItem);
21919 ashik.ali 575 
			pdfModel.setTotalAmount(pdfModel.getTotalAmount() + customFofoOrderItem.getItemTotal());
21689 ashik.ali 576 
		}
577 
		pdfModel.setOrderItems(customerFofoOrderItems);
578 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
579 
		PdfUtils.generateAndWrite(pdfModel, byteArrayOutputStream);
580 
		//final MediaType mediaType=MediaType.parseMediaType(profilePhotoModel.getContentType().getValue());
581 
		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
21896 ashik.ali 582 
        final HttpHeaders headers=new HttpHeaders();
583 
        headers.setContentType(MediaType.APPLICATION_PDF);
21919 ashik.ali 584 
        headers.set("Content-Disposition", "Order-"+orderId);
21896 ashik.ali 585 
        headers.setContentLength(byteArrayOutputStream.toByteArray().length);
586 
        final InputStream inputStream=new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
587 
        final InputStreamResource inputStreamResource=new InputStreamResource(inputStream);
588 
        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
21689 ashik.ali 589 
	}
21896 ashik.ali 590 
 
21689 ashik.ali 591 
	private Set<String> toSerialNumbers(Set<FofoLineItemSerialNumber> fofoLineItemSerialNumbers){
592 
		Set<String> serialNumbers = new HashSet<>(fofoLineItemSerialNumbers.size());
593 
		for(FofoLineItemSerialNumber fofoLineItemSerialNumber : fofoLineItemSerialNumbers){
594 
			serialNumbers.add(fofoLineItemSerialNumber.getSerialNumber());
595 
		}
596 
		return serialNumbers;
597 
	}
21896 ashik.ali 598 
 
599 
 
21612 ashik.ali 600 
}