Subversion Repositories SmartDukaan

Rev

Rev 22037 | Rev 22069 | 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;
21985 kshitij.so 7 
import java.util.Collection;
21680 ashik.ali 8 
import java.util.HashMap;
21612 ashik.ali 9 
import java.util.HashSet;
21985 kshitij.so 10 
import java.util.Iterator;
21680 ashik.ali 11 
import java.util.List;
12 
import java.util.Map;
21612 ashik.ali 13 
import java.util.Set;
14 
 
15 
import javax.servlet.http.HttpServletRequest;
21689 ashik.ali 16 
import javax.servlet.http.HttpServletResponse;
21612 ashik.ali 17 
 
21985 kshitij.so 18 
import org.json.JSONObject;
21612 ashik.ali 19 
import org.slf4j.Logger;
20 
import org.slf4j.LoggerFactory;
21 
import org.springframework.beans.factory.annotation.Autowired;
21689 ashik.ali 22 
import org.springframework.core.io.InputStreamResource;
23 
import org.springframework.http.HttpHeaders;
24 
import org.springframework.http.HttpStatus;
25 
import org.springframework.http.MediaType;
26 
import org.springframework.http.ResponseEntity;
21612 ashik.ali 27 
import org.springframework.stereotype.Controller;
22064 ashik.ali 28 
import org.springframework.transaction.annotation.Transactional;
21985 kshitij.so 29 
import org.springframework.ui.Model;
21612 ashik.ali 30 
import org.springframework.web.bind.annotation.RequestBody;
31 
import org.springframework.web.bind.annotation.RequestMapping;
32 
import org.springframework.web.bind.annotation.RequestMethod;
21689 ashik.ali 33 
import org.springframework.web.bind.annotation.RequestParam;
21612 ashik.ali 34 
 
35 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
21985 kshitij.so 36 
import com.spice.profitmandi.common.model.CartFofo;
21680 ashik.ali 37 
import com.spice.profitmandi.common.model.CustomAddress;
21689 ashik.ali 38 
import com.spice.profitmandi.common.model.CustomCustomer;
39 
import com.spice.profitmandi.common.model.CustomFofoLineItem;
40 
import com.spice.profitmandi.common.model.CustomFofoOrderItem;
41 
import com.spice.profitmandi.common.model.CustomRetailer;
21896 ashik.ali 42 
import com.spice.profitmandi.common.model.GstRate;
21689 ashik.ali 43 
import com.spice.profitmandi.common.model.PdfModel;
21612 ashik.ali 44 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
21689 ashik.ali 45 
import com.spice.profitmandi.common.util.PdfUtils;
21680 ashik.ali 46 
import com.spice.profitmandi.common.util.StringUtils;
21896 ashik.ali 47 
import com.spice.profitmandi.common.util.Utils;
21728 ashik.ali 48 
import com.spice.profitmandi.dao.entity.catalog.Item;
49 
import com.spice.profitmandi.dao.entity.dtr.Retailer;
50 
import com.spice.profitmandi.dao.entity.dtr.User;
51 
import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;
52 
import com.spice.profitmandi.dao.entity.fofo.Customer;
53 
import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
21896 ashik.ali 54 
import com.spice.profitmandi.dao.entity.fofo.FofoItemId;
21728 ashik.ali 55 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
56 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItemSerialNumber;
57 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
58 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
59 
import com.spice.profitmandi.dao.entity.fofo.InvoiceNumberGenerationSequence;
60 
import com.spice.profitmandi.dao.entity.fofo.PaymentOption;
61 
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
62 
import com.spice.profitmandi.dao.entity.user.Address;
63 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
21883 kshitij.so 64 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
21728 ashik.ali 65 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
66 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
67 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
68 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
69 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
70 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
71 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
72 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
73 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemSerialNumberRepository;
74 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
75 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
76 
import com.spice.profitmandi.dao.repository.fofo.InvoiceNumberGenerationSequenceRepository;
77 
import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
78 
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
79 
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
80 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
21612 ashik.ali 81 
import com.spice.profitmandi.web.model.FofoDetails;
82 
import com.spice.profitmandi.web.request.CreateOrderRequest;
83 
import com.spice.profitmandi.web.request.CustomPaymentOption;
21680 ashik.ali 84 
import com.spice.profitmandi.web.response.ItemIdQuantityAvailability;
85 
import com.spice.profitmandi.web.response.Quantity;
21612 ashik.ali 86 
import com.spice.profitmandi.web.util.CookiesFetcher;
87 
import com.spice.profitmandi.web.util.MVCResponseSender;
88 
 
21985 kshitij.so 89 
import in.shop2020.model.v1.catalog.ItemType;
90 
 
21612 ashik.ali 91 
@Controller
22037 amit.gupta 92 
@Transactional(rollbackFor=Throwable.class)
21612 ashik.ali 93 
public class OrderController {
94 
 
95 
	private static final Logger LOGGER = LoggerFactory.getLogger(OrderController.class);
21985 kshitij.so 96 
 
21612 ashik.ali 97 
	@Autowired
98 
	OrderRepository orderRepository;
21985 kshitij.so 99 
 
21612 ashik.ali 100 
	@Autowired
101 
	InventoryItemRepository inventoryItemRepository;
21985 kshitij.so 102 
 
21612 ashik.ali 103 
	@Autowired
21680 ashik.ali 104 
	CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
21985 kshitij.so 105 
 
21680 ashik.ali 106 
	@Autowired
107 
	InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;
21985 kshitij.so 108 
 
21680 ashik.ali 109 
	@Autowired
110 
	CustomerRepository customerRepository;
21985 kshitij.so 111 
 
21680 ashik.ali 112 
	@Autowired
113 
	AddressRepository addressRepository;
21985 kshitij.so 114 
 
21680 ashik.ali 115 
	@Autowired
116 
	FofoLineItemSerialNumberRepository fofoLineItemSerialNumberRepository;
21985 kshitij.so 117 
 
21680 ashik.ali 118 
	@Autowired
119 
	FofoLineItemRepository fofoLineItemRepository;
21985 kshitij.so 120 
 
21680 ashik.ali 121 
	@Autowired
122 
	PaymentOptionRepository paymentOptionRepository;
21985 kshitij.so 123 
 
21680 ashik.ali 124 
	@Autowired
125 
	ScanRecordRepository scanRecordRepository;
21985 kshitij.so 126 
 
21680 ashik.ali 127 
	@Autowired
128 
	FofoOrderRepository fofoOrderRepository;
21985 kshitij.so 129 
 
21680 ashik.ali 130 
	@Autowired
21689 ashik.ali 131 
	RetailerRepository retailerRepository;
21985 kshitij.so 132 
 
21689 ashik.ali 133 
	@Autowired
134 
	UserRepository userRepository;
21985 kshitij.so 135 
 
21689 ashik.ali 136 
	@Autowired
137 
	UserAccountRepository userAccountRepository;
21985 kshitij.so 138 
 
21689 ashik.ali 139 
	@Autowired
140 
	RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
21985 kshitij.so 141 
 
21689 ashik.ali 142 
	@Autowired
21711 ashik.ali 143 
	CustomerAddressRepository customerAddressRepository;
21985 kshitij.so 144 
 
21711 ashik.ali 145 
	@Autowired
21896 ashik.ali 146 
	ItemRepository itemRepository;
21985 kshitij.so 147 
 
21896 ashik.ali 148 
	@Autowired
21612 ashik.ali 149 
	MVCResponseSender mvcResponseSender;
21985 kshitij.so 150 
 
21612 ashik.ali 151 
	@Autowired
152 
	CookiesFetcher cookiesFetcher;
21985 kshitij.so 153 
 
154 
	@RequestMapping(value = "/order")
155 
	public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model) throws Exception{
156 
		try {
22064 ashik.ali 157 
			cookiesFetcher.getCookiesObject(request);
21985 kshitij.so 158 
		} catch (ProfitMandiBusinessException e) {
159 
			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
160 
			return "response";
161 
		}
162 
		JSONObject cartObject = new JSONObject(cartData);
163 
		Iterator<?> keys = cartObject.keys();
164 
 
165 
		Set<Integer> itemIds = new HashSet<>();
166 
		List<CartFofo> cartItems = new ArrayList<CartFofo>();
167 
 
168 
		while( keys.hasNext() ) {
169 
			String key = (String)keys.next();
170 
			if ( cartObject.get(key) instanceof JSONObject ) {
171 
				System.out.println(cartObject.get(key));
172 
			}
173 
			CartFofo cf = new CartFofo();
174 
			cf.setItemId(cartObject.getJSONObject(key).getInt("itemId"));
175 
			cf.setQuantity(cartObject.getJSONObject(key).getInt("quantity"));
176 
			if (cf.getQuantity() <= 0){
177 
				continue;
178 
			}
179 
			cartItems.add(cf);
180 
			itemIds.add(cartObject.getJSONObject(key).getInt("itemId"));
181 
		}
182 
		Map<Integer, Item>  itemMap = new HashMap<Integer, Item>();
183 
		if (itemIds.size() > 0){
184 
			List<Item> items = itemRepository.selectByIds(itemIds);
185 
			for (Item i : items){
186 
				itemMap.put(i.getId(), i);
187 
			}
188 
		}
189 
		for (CartFofo cf : cartItems){
190 
			Item i = itemMap.get(cf.getItemId());
191 
			if (i == null){
192 
				continue;
193 
			}
194 
			cf.setDisplayName(getValidName(i.getBrand())+" "+getValidName(i.getModelName())+" "+getValidName(i.getModelNumber())+" "+getValidName(i.getColor()).replaceAll("\\s+", " "));
195 
			cf.setItemType(i.getType());
196 
		}
197 
		model.addAttribute("cartObj", cartItems);
198 
		return "order-index";
199 
	}
200 
 
201 
	private String getValidName(String name){
202 
		return name!=null?name:"";
203 
	}
21612 ashik.ali 204 
 
21985 kshitij.so 205 
	@RequestMapping(value = "/get-order", method = RequestMethod.GET)
206 
	public String getOrder(HttpServletRequest request, @RequestParam(name = "orderId") int orderId, Model model) throws ProfitMandiBusinessException, Exception{
207 
		FofoDetails fofoDetails;
208 
		try {
209 
			fofoDetails = cookiesFetcher.getCookiesObject(request);
210 
		} catch (ProfitMandiBusinessException e) {
211 
			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
212 
			return "response";
213 
		}
214 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
215 
		LOGGER.info(fofoOrder.toString());
216 
		LOGGER.info(fofoOrder.getCustomer().toString());
217 
		LOGGER.info(fofoOrder.getCustomer().getCustomerAddress().toString());
218 
		LOGGER.info(fofoOrder.getFofoLineItem().toString());
219 
		LOGGER.info(fofoOrder.getFofoLineItem().get(0).getFofoLineItemSerialNumbers().toString());
220 
		LOGGER.info(fofoOrder.getPaymentOption().toString());
221 
		return null;
222 
	}
223 
 
224 
	@RequestMapping(value = "/create-order", method = RequestMethod.POST)
225 
	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest, Model model)  throws Throwable{
22064 ashik.ali 226 
		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);
21985 kshitij.so 227 
		FofoDetails fofoDetails;
228 
		try {
229 
			fofoDetails = cookiesFetcher.getCookiesObject(request);
230 
		} catch (ProfitMandiBusinessException e) {
231 
			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
232 
			return "response";
233 
		}
21680 ashik.ali 234 
		Set<Integer> itemIds = new HashSet<>();
21896 ashik.ali 235 
		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); //this is for error
236 
		Map<Integer, CustomFofoLineItem> customFofoLineItemMap = new HashMap<>();
237 
		Map<Integer, Float> lineItemPrice = new HashMap<>(); //this is for pricing error
238 
		float totalAmount = 0;
239 
		for(CustomFofoLineItem customFofoLineItem : createOrderRequest.getFofoLineItems()){
240 
			itemIds.add(customFofoLineItem.getItemId());
241 
			if(!customFofoLineItem.getSerialNumbers().isEmpty() && customFofoLineItem.getQuantity() != customFofoLineItem.getSerialNumbers().size()){
242 
				itemIdQuantity.put(customFofoLineItem.getItemId(), customFofoLineItem.getQuantity());
21680 ashik.ali 243 
			}
21896 ashik.ali 244 
			if(!(customFofoLineItem.getSellingPrice() > 0)){
245 
				lineItemPrice.put(customFofoLineItem.getItemId(), customFofoLineItem.getSellingPrice());
246 
			}else{
247 
				totalAmount = totalAmount + customFofoLineItem.getSellingPrice() * customFofoLineItem.getQuantity();
21680 ashik.ali 248 
			}
21896 ashik.ali 249 
			customFofoLineItemMap.put(customFofoLineItem.getItemId(), customFofoLineItem);
21680 ashik.ali 250 
		}
251 
		if(!itemIdQuantity.isEmpty()){
252 
			// if item quantity does not match with given serialnumbers size
253 
			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);
254 
			return "error";
255 
		}
256 
		try{
257 
			this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);
258 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
259 
			LOGGER.error("Error occured while validating payment options : ", profitMandiBusinessException);
260 
			return "error";
261 
		}
21896 ashik.ali 262 
		if(!lineItemPrice.isEmpty()){
263 
			// given fofo line item price must be greater than zero
264 
			LOGGER.error("requested itemId's selling price must greater than 0");
265 
			return "error";
266 
		}
21985 kshitij.so 267 
 
21896 ashik.ali 268 
		List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository.selectByFofoItemIds(fofoDetails.getFofoId(), itemIds);
269 
		if(itemIds.size() != currentInventorySnapshots.size()){
270 
			// error
271 
		}
272 
		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); //this is for error
21985 kshitij.so 273 
		LOGGER.info("currentInventorySnapshots "+currentInventorySnapshots);
21896 ashik.ali 274 
		for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
275 
			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(currentInventorySnapshot.getId().getItemId());
21985 kshitij.so 276 
			LOGGER.info("customFofoLineItem "+customFofoLineItem);
21896 ashik.ali 277 
			if(customFofoLineItem.getQuantity() > currentInventorySnapshot.getAvailability()){
278 
				ItemIdQuantityAvailability itemIdQuantityAvailability = new ItemIdQuantityAvailability();
279 
				itemIdQuantityAvailability.setItemId(customFofoLineItem.getItemId());
280 
				Quantity quantity = new Quantity();
281 
				quantity.setAvailable(currentInventorySnapshot.getAvailability());
282 
				quantity.setRequested(customFofoLineItem.getQuantity());
283 
				itemIdQuantityAvailability.setQuantity(quantity);
284 
				itemIdQuantityAvailabilities.add(itemIdQuantityAvailability);
285 
			}
21985 kshitij.so 286 
 
21896 ashik.ali 287 
		}
21985 kshitij.so 288 
 
289 
 
290 
 
21680 ashik.ali 291 
		if(!itemIdQuantityAvailabilities.isEmpty()){
292 
			// itemIdQuantity request is not valid
293 
			LOGGER.error("Requested quantities should not be greater than currently available quantities {}", itemIdQuantityAvailabilities);
294 
			return "error";
295 
		}
21985 kshitij.so 296 
 
297 
 
298 
 
299 
		//		Set<Integer> invalidItemIdSerialNumbers = new HashSet<>();
300 
		//		Map<Integer, Set<String>> itemIdSerialNumbers = new HashMap<>();
301 
		//		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), itemIds); //change it
302 
		//
303 
		//		Map<Integer, Float> itemIdPriceDropAmount = new HashMap<>();
304 
		//
305 
		//		for(InventoryItem inventoryItem : inventoryItems){
306 
		//			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(inventoryItem.getItemId());
307 
		//			if(customFofoLineItem.getSerialNumbers().isEmpty()){
308 
		//				if(!(inventoryItem.getSerialNumber() == null && inventoryItem.getSerialNumber().equals(""))){
309 
		//					invalidItemIdSerialNumbers.add(inventoryItem.getItemId());
310 
		//				}
311 
		//			}
312 
		//			if(!customFofoLineItem.getSerialNumbers().isEmpty()){
313 
		//				if(!customFofoLineItem.getSerialNumbers().contains(inventoryItem.getSerialNumber())){
314 
		//					if(!itemIdSerialNumbers.containsKey(customFofoLineItem.getItemId())){
315 
		//						Set<String> serialNumbers = new HashSet<>();
316 
		//						serialNumbers.add(inventoryItem.getSerialNumber());
317 
		//						itemIdSerialNumbers.put(customFofoLineItem.getItemId(), serialNumbers);
318 
		//					}else{
319 
		//						itemIdSerialNumbers.get(customFofoLineItem.getItemId()).add(inventoryItem.getSerialNumber());
320 
		//				}
321 
		//			}
322 
		//			itemIdPriceDropAmount.put(inventoryItem.getItemId(), inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount());
323 
		//		}
324 
 
325 
		Map<Integer, Item>  itemMap = new HashMap<Integer, Item>();
326 
		List<Item> items = itemRepository.selectByIds(itemIds);
327 
		for (Item i : items){
328 
			itemMap.put(i.getId(), i);
329 
		}
330 
 
331 
		Set<Integer> nonSerializedItemIds = new HashSet<>();
332 
		Set<String> serialNumbers = new HashSet<>();
333 
 
334 
		Collection<CustomFofoLineItem> lineItemsValues = customFofoLineItemMap.values();
335 
		for (CustomFofoLineItem cli : lineItemsValues){
336 
 
337 
			Item item = itemMap.get(cli.getItemId());
338 
			if (item.getType().equals(ItemType.SERIALIZED)){
339 
				for (String s : cli.getSerialNumbers()){
340 
					serialNumbers.add(s);
21896 ashik.ali 341 
				}
342 
			}
21985 kshitij.so 343 
			else{
344 
				nonSerializedItemIds.add(cli.getItemId());
345 
			}
346 
 
347 
		}
348 
 
349 
 
350 
		Map<Integer, List<InventoryItem>> serializedInventoryItemMap = new HashMap<Integer, List<InventoryItem>>();
351 
		Map<Integer, List<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<Integer, List<InventoryItem>>();
352 
		Map<Integer, List<Float>> itemIdPriceDropAmount = new HashMap<>();
353 
 
354 
		if (serialNumbers.size() > 0 ){
355 
			List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoDetails.getFofoId(), serialNumbers);
356 
			for (InventoryItem it : serializedInventoryItems){
357 
				if (it.getGoodQuantity() == 1){
358 
					if (serializedInventoryItemMap.containsKey(it.getItemId())){
359 
						serializedInventoryItemMap.get(it.getItemId()).add(it);
360 
						itemIdPriceDropAmount.get(it.getItemId()).add(it.getUnitPrice() - (it.getPriceDropAmount()==null?0:it.getPriceDropAmount()));
21680 ashik.ali 361 
					}
21985 kshitij.so 362 
					else{
363 
						ArrayList<InventoryItem> tmp = new ArrayList<InventoryItem>();
364 
						tmp.add(it);
365 
						serializedInventoryItemMap.put(it.getItemId(), tmp);
366 
						ArrayList<Float> priceDropAmouts = new ArrayList<>();
367 
						priceDropAmouts.add(it.getUnitPrice() - (it.getPriceDropAmount()==null?0:it.getPriceDropAmount()));
368 
						itemIdPriceDropAmount.put(it.getItemId(), priceDropAmouts);
369 
					}
21680 ashik.ali 370 
				}
371 
			}
372 
		}
21985 kshitij.so 373 
 
374 
		if (nonSerializedItemIds.size() > 0){
375 
			List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), nonSerializedItemIds);
376 
			for (InventoryItem it : nonSerializedInventoryItems){
377 
				if (it.getGoodQuantity() > 0){
378 
					if (nonSerializedInventoryItemMap.containsKey(it.getItemId())){
379 
						nonSerializedInventoryItemMap.get(it.getItemId()).add(it);
380 
					}
381 
					else{
382 
						ArrayList<InventoryItem> tmp = new ArrayList<InventoryItem>();
383 
						tmp.add(it);
384 
						nonSerializedInventoryItemMap.put(it.getItemId(), tmp);
385 
					}
386 
				}
387 
			}
388 
		}
389 
 
390 
		List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();
391 
		List<Integer> itemIdSerialNumbers = new ArrayList<Integer>();
392 
 
393 
		for (Item i : items){
394 
			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(i.getId());
395 
			if (i.getType().equals(ItemType.SERIALIZED)){
396 
				if (customFofoLineItem ==null || customFofoLineItem.getSerialNumbers().size() ==0){
397 
					invalidItemIdSerialNumbers.add(i.getId());
398 
				}
399 
			}
400 
			else{
401 
				if (customFofoLineItem == null || customFofoLineItem.getSerialNumbers().size() > 0 ){
402 
					itemIdSerialNumbers.add(i.getId());
403 
				}
404 
			}
405 
		}
406 
 
21680 ashik.ali 407 
		if(!invalidItemIdSerialNumbers.isEmpty()){
408 
			LOGGER.error("Invalid itemId's serialNumbers {}", invalidItemIdSerialNumbers);
409 
			// itemId's are serialized you are saying these are not serialized
410 
			return "error";
411 
		}
21985 kshitij.so 412 
 
21680 ashik.ali 413 
		if(!itemIdSerialNumbers.isEmpty()){
414 
			LOGGER.error("Invalid itemId's serialNumbers {}", itemIdSerialNumbers);
415 
			// itemId's are non serialized you are saying these are serialized
416 
			return "error";
417 
		}
21985 kshitij.so 418 
 
21896 ashik.ali 419 
		if(items.size() != itemIds.size()){
420 
			LOGGER.error("Requested ItemIds not found in catalog");
421 
			// invalid itemIds
422 
			return "error";
423 
		}
21985 kshitij.so 424 
 
425 
		Map<Integer, List<InventoryItem>> inventoryItemsToBill = new HashMap<Integer,List<InventoryItem>>();
426 
		Map<Integer, Integer> inventoryItemQuantityUsed = new HashMap<>(); //to keep track of inventoryitem quanity used for scan records insertion
427 
 
428 
		//Lets reduce quantity and decide what inventory items to use.
429 
		for (Item i : items){
430 
			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(i.getId());
431 
			if (i.getType().equals(ItemType.SERIALIZED)){
432 
				//TODO:handle null
433 
				if (serializedInventoryItemMap.get(i.getId()) == null || customFofoLineItem.getSerialNumbers().size() != serializedInventoryItemMap.get(i.getId()).size()){
434 
					//not enough serial numbers
435 
					System.out.println("not enough serial numbers");
436 
					return "error";
437 
				}
438 
				List<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(i.getId());
439 
				for (InventoryItem it : inventoryItemsSerializedserialized){
440 
					it.setGoodQuantity(0);
441 
					inventoryItemQuantityUsed.put(it.getId(), 1);
442 
				}
443 
				inventoryItemsToBill.put(i.getId(), inventoryItemsSerializedserialized);
444 
			}
445 
			else{
446 
				List<InventoryItem> inventoryItemsNonSerialized = nonSerializedInventoryItemMap.get(i.getId());
447 
				int quantityToBill = customFofoLineItem.getQuantity();
448 
				int totalLeft = quantityToBill;
449 
				List<InventoryItem> inventoryItemsNonSerializedUsed = new ArrayList<InventoryItem>();
450 
				if (inventoryItemsNonSerialized!=null){
451 
					for (InventoryItem it : inventoryItemsNonSerialized){
452 
						if (totalLeft > 0){
453 
							int toUse = Math.min(totalLeft, it.getGoodQuantity());
454 
							inventoryItemQuantityUsed.put(it.getId(), toUse);
455 
							it.setGoodQuantity(it.getGoodQuantity()  - toUse);
456 
							totalLeft = totalLeft - toUse;
457 
							inventoryItemsNonSerializedUsed.add(it);
458 
						}
459 
					}
460 
				}
461 
 
462 
				if (totalLeft > 0){
463 
					//not enough quanity for non-serialized
464 
					System.out.println("not enough quanity for non-serialized");
465 
					return "error";
466 
				}
467 
				inventoryItemsToBill.put(i.getId(), inventoryItemsNonSerializedUsed);
468 
			}
469 
		}
470 
 
21680 ashik.ali 471 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
472 
		try{
473 
			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoDetails.getFofoId());
474 
			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
475 
			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
476 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
477 
			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
478 
			invoiceNumberGenerationSequence.setFofoId(fofoDetails.getFofoId());
479 
			invoiceNumberGenerationSequence.setPrefix("INVOICE");
22028 ashik.ali 480 
			invoiceNumberGenerationSequence.setSequence(1);
21680 ashik.ali 481 
			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
482 
		}
21985 kshitij.so 483 
 
21680 ashik.ali 484 
		CustomCustomer customCustomer = createOrderRequest.getCustomer();
21985 kshitij.so 485 
 
21680 ashik.ali 486 
		if(!StringUtils.isValidEmailAddress(customCustomer.getEmailId())){
487 
			LOGGER.error("invalid customer emailId {} ", customCustomer.getEmailId());
488 
			return "error";
489 
		}
21985 kshitij.so 490 
 
21680 ashik.ali 491 
		if(!StringUtils.isValidMobile(customCustomer.getMobileNumber())){
492 
			LOGGER.error("invalid customer mobileNumber {} ", customCustomer.getMobileNumber());
493 
			return "error";
494 
		}
21985 kshitij.so 495 
 
21680 ashik.ali 496 
		Customer customer = null;
21985 kshitij.so 497 
		try{
498 
			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
499 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
500 
			LOGGER.error("Error : ", profitMandiBusinessException);
21680 ashik.ali 501 
			customer = new Customer();
21883 kshitij.so 502 
			customer.setName(customCustomer.getName());
21680 ashik.ali 503 
			customer.setEmailId(customCustomer.getEmailId());
504 
			customer.setMobileNumber(customCustomer.getMobileNumber());
505 
			customerRepository.persist(customer);
506 
		}
21896 ashik.ali 507 
		//TODO:Check if createOrderRequest contains addressId
21711 ashik.ali 508 
		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress());
509 
		customerAddress.setCustomerId(customer.getId());
510 
		customerAddressRepository.persist(customerAddress);
21985 kshitij.so 511 
 
21680 ashik.ali 512 
		FofoOrder fofoOrder = new FofoOrder();
513 
		fofoOrder.setCustomerId(customer.getId());
514 
		fofoOrder.setFofoId(fofoDetails.getFofoId());
515 
		fofoOrder.setInvoiceNumber(invoiceNumberGenerationSequence.getPrefix() + invoiceNumberGenerationSequence.getSequence());
516 
		fofoOrder.setTotalAmount(totalAmount);
21886 kshitij.so 517 
		fofoOrder.setCustomerAddressId(customerAddress.getId());
21680 ashik.ali 518 
		fofoOrderRepository.persist(fofoOrder);
21985 kshitij.so 519 
 
21680 ashik.ali 520 
		for(CustomPaymentOption customPaymentOption : createOrderRequest.getPaymentOptions()){
521 
			PaymentOption paymentOption = new PaymentOption();
522 
			paymentOption.setOrderId(fofoOrder.getId());
523 
			paymentOption.setAmount(customPaymentOption.getAmount());
524 
			paymentOption.setType(customPaymentOption.getType());
525 
			paymentOptionRepository.persist(paymentOption);
526 
		}
21985 kshitij.so 527 
 
21896 ashik.ali 528 
		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoDetails.getFofoId()));
22064 ashik.ali 529 
		Map<String, GstRate> gstRateMap = null;
530 
		if(retailerAddress.getState().equals(customerAddress.getState())){
531 
			gstRateMap = Utils.getGstRates(retailerAddress.getState());
532 
		}else{
533 
			LOGGER.info("inter gstRate = true");
534 
			gstRateMap = Utils.getInterGstRates();
535 
		}
536 
		LOGGER.info("gstRateMap {}", gstRateMap);
21680 ashik.ali 537 
		for(CustomFofoLineItem customFofoLineItem : createOrderRequest.getFofoLineItems()){
538 
			FofoLineItem fofoLineItem = new FofoLineItem();
539 
			fofoLineItem.setItemId(customFofoLineItem.getItemId());
540 
			fofoLineItem.setQuantity(customFofoLineItem.getQuantity());
21690 ashik.ali 541 
			fofoLineItem.setSellingPrice(customFofoLineItem.getSellingPrice());
21680 ashik.ali 542 
			fofoLineItem.setOrderId(fofoOrder.getId());
543 
			fofoLineItem.setDp(customFofoLineItem.getSellingPrice());
21985 kshitij.so 544 
			Item item = itemMap.get(customFofoLineItem.getItemId());
21896 ashik.ali 545 
			GstRate gstRate = gstRateMap.get(item.getHsnCode());
546 
			fofoLineItem.setIgstRate(gstRate.getIgstRate());
547 
			fofoLineItem.setCgstRate(gstRate.getCgstRate());
548 
			fofoLineItem.setSgstRate(gstRate.getSgstRate());
21919 ashik.ali 549 
			fofoLineItem.setHsnCode(gstRate.getHsnCode());
21985 kshitij.so 550 
			List<Float> priceDropAmounts = itemIdPriceDropAmount.get(customFofoLineItem.getItemId());
551 
			float cost = 0;
552 
			if (priceDropAmounts!=null){
553 
				for (Float pda : priceDropAmounts){
554 
					cost = cost + pda;
555 
				}
556 
			}
557 
			else{
558 
				cost = customFofoLineItem.getSellingPrice()* customFofoLineItem.getQuantity();
559 
			}
560 
			fofoLineItem.setCost(cost);
21896 ashik.ali 561 
			fofoLineItem.setBrand(item.getBrand());
562 
			fofoLineItem.setModelName(item.getModelName());
563 
			fofoLineItem.setModelNumber(item.getModelNumber());
564 
			fofoLineItem.setColor(item.getColor());
21680 ashik.ali 565 
			fofoLineItemRepository.persist(fofoLineItem);
566 
			LOGGER.info("\n\n");
567 
			if(!customFofoLineItem.getSerialNumbers().isEmpty()){
568 
				for(String serialNumber : customFofoLineItem.getSerialNumbers()){
569 
					FofoLineItemSerialNumber fofoLineItemSerialNumber = new FofoLineItemSerialNumber();
570 
					fofoLineItemSerialNumber.setFofoLineItemId(fofoLineItem.getId());
571 
					fofoLineItemSerialNumber.setSerialNumber(serialNumber);
572 
					fofoLineItemSerialNumberRepository.persist(fofoLineItemSerialNumber);
573 
				}
574 
			}
21985 kshitij.so 575 
 
21896 ashik.ali 576 
			for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
577 
				FofoItemId fofoItemId = new FofoItemId();
578 
				fofoItemId.setFofoId(fofoDetails.getFofoId());
579 
				fofoItemId.setItemId(fofoLineItem.getItemId());
580 
				if(currentInventorySnapshot.getId().equals(fofoItemId)){
581 
					currentInventorySnapshotRepository.updateAvailabilityByFofoItemId(fofoItemId, currentInventorySnapshot.getAvailability() - customFofoLineItem.getQuantity());
582 
				}
583 
			}
21985 kshitij.so 584 
			List<InventoryItem> inventoryItems = inventoryItemsToBill.get(fofoLineItem.getItemId());
21680 ashik.ali 585 
			for(InventoryItem inventoryItem : inventoryItems){
21985 kshitij.so 586 
				inventoryItem.setLastScanType(ScanType.SALE);
587 
				inventoryItemRepository.persist(inventoryItem);
588 
				ScanRecord scanRecord = new ScanRecord();
589 
				scanRecord.setInventoryItemId(inventoryItem.getId());
590 
				scanRecord.setFofoId(fofoDetails.getFofoId());
591 
				//correct this
592 
				scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));
593 
				scanRecord.setType(ScanType.SALE);
594 
				scanRecordRepository.persist(scanRecord);
595 
			}
21680 ashik.ali 596 
		}
21612 ashik.ali 597 
		return null;
598 
	}
21985 kshitij.so 599 
 
21711 ashik.ali 600 
	private CustomerAddress createCustomerAddress(CustomAddress customAddress){
601 
		CustomerAddress customerAddress = new CustomerAddress();
602 
		customerAddress.setName(customAddress.getName());
603 
		customerAddress.setLine1(customAddress.getLine1());
604 
		customerAddress.setLine2(customAddress.getLine2());
605 
		customerAddress.setLandmark(customAddress.getLandmark());
606 
		customerAddress.setCity(customAddress.getCity());
607 
		customerAddress.setPinCode(customAddress.getPinCode());
608 
		customerAddress.setState(customAddress.getState());
609 
		customerAddress.setCountry(customAddress.getCountry());
610 
		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());
611 
		return customerAddress;
21680 ashik.ali 612 
	}
21985 kshitij.so 613 
 
21689 ashik.ali 614 
	private CustomAddress createCustomAddress(Address address){
615 
		CustomAddress customAddress = new CustomAddress();
616 
		customAddress.setName(address.getName());
617 
		customAddress.setLine1(address.getLine1());
618 
		customAddress.setLine2(address.getLine2());
619 
		customAddress.setLandmark(address.getLandmark());
620 
		customAddress.setCity(address.getCity());
621 
		customAddress.setPinCode(address.getPinCode());
622 
		customAddress.setState(address.getState());
623 
		customAddress.setCountry(address.getCountry());
624 
		customAddress.setPhoneNumber(address.getPhoneNumber());
625 
		return customAddress;
21680 ashik.ali 626 
	}
21985 kshitij.so 627 
 
21711 ashik.ali 628 
	private CustomAddress createCustomAddress(CustomerAddress customerAddress){
629 
		CustomAddress customAddress = new CustomAddress();
630 
		customAddress.setName(customerAddress.getName());
631 
		customAddress.setLine1(customerAddress.getLine1());
632 
		customAddress.setLine2(customerAddress.getLine2());
633 
		customAddress.setLandmark(customerAddress.getLandmark());
634 
		customAddress.setCity(customerAddress.getCity());
635 
		customAddress.setPinCode(customerAddress.getPinCode());
636 
		customAddress.setState(customerAddress.getState());
637 
		customAddress.setCountry(customerAddress.getCountry());
638 
		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());
639 
		return customAddress;
640 
	}
21985 kshitij.so 641 
 
21680 ashik.ali 642 
	private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount) throws ProfitMandiBusinessException
21612 ashik.ali 643 
	{
644 
		float calculatedAmount = 0;
645 
		Set<String> paymentOptionTypes = new HashSet<>();
646 
		for(CustomPaymentOption customPaymentOption : customPaymentOptions){
21680 ashik.ali 647 
			if(paymentOptionTypes.contains(customPaymentOption.getType().name())){
21612 ashik.ali 648 
				throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_TYPE, customPaymentOption.getType().name(), "");
21680 ashik.ali 649 
			}else{
650 
				paymentOptionTypes.add(customPaymentOption.getType().name());
651 
				calculatedAmount = calculatedAmount + customPaymentOption.getAmount();
21612 ashik.ali 652 
			}
653 
		}
654 
		if(calculatedAmount != totalAmount){
655 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_CALCULATED_AMOUNT, calculatedAmount, "");
656 
		}
657 
	}
21985 kshitij.so 658 
 
659 
 
21689 ashik.ali 660 
	@RequestMapping(value = "/generateInvoice")
21896 ashik.ali 661 
	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws Throwable{
22064 ashik.ali 662 
		LOGGER.info("Request received at url {} with params [{}={}] ", request.getRequestURI(), ProfitMandiConstants.ORDER_ID, orderId);
22026 ashik.ali 663 
		FofoDetails fofoDetails = cookiesFetcher.getCookiesObject(request);
664 
 
21689 ashik.ali 665 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
666 
		PdfModel pdfModel = new PdfModel();
667 
		pdfModel.setAuther("profitmandi");
668 
		pdfModel.setTitle("Retailer Invoice");
669 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
670 
		CustomCustomer customCustomer = new CustomCustomer();
671 
		customCustomer.setName(customer.getName());
672 
		customCustomer.setEmailId(customer.getEmailId());
673 
		customCustomer.setMobileNumber(customer.getMobileNumber());
21711 ashik.ali 674 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
21689 ashik.ali 675 
		customCustomer.setAddress(this.createCustomAddress(customerAddress));
676 
		pdfModel.setCustomer(customCustomer);
677 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
21965 ashik.ali 678 
		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
22026 ashik.ali 679 
 
21689 ashik.ali 680 
		Retailer retailer = retailerRepository.selectById(fofoDetails.getFofoId());
681 
		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));
682 
		CustomRetailer customRetailer = new CustomRetailer();
683 
		customRetailer.setBusinessName(retailer.getName());
684 
		customRetailer.setMobileNumber(user.getMobileNumber());
685 
		customRetailer.setTinNumber(retailer.getNumber());
686 
		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));
687 
		customRetailer.setAddress(this.createCustomAddress(retailerAddress));
688 
		pdfModel.setRetailer(customRetailer);
689 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByOrderId(fofoOrder.getId());
22026 ashik.ali 690 
 
21689 ashik.ali 691 
		Set<CustomFofoOrderItem> customerFofoOrderItems = new HashSet<>();
692 
		for(FofoLineItem fofoLineItem : fofoLineItems){
693 
			CustomFofoOrderItem customFofoOrderItem = new CustomFofoOrderItem();
22026 ashik.ali 694 
			float totalTaxRate = fofoLineItem.getIgstRate() + fofoLineItem.getSgstRate() + fofoLineItem.getCgstRate();
695 
			float taxableSellingPrice = fofoLineItem.getSellingPrice() / (1 + totalTaxRate / 100);
696 
 
697 
			customFofoOrderItem.setAmount(fofoLineItem.getQuantity() * taxableSellingPrice);
21689 ashik.ali 698 
			customFofoOrderItem.setDescription(fofoLineItem.getBrand() + " " + fofoLineItem.getModelName() + " " + fofoLineItem.getModelNumber() + " " + fofoLineItem.getColor());
22026 ashik.ali 699 
			customFofoOrderItem.setRate(taxableSellingPrice);
21689 ashik.ali 700 
			customFofoOrderItem.setQuantity(fofoLineItem.getQuantity());
22026 ashik.ali 701 
			float igstAmount = (customFofoOrderItem.getAmount() * fofoLineItem.getIgstRate()) / 100;
702 
			float cgstAmount = (customFofoOrderItem.getAmount() * fofoLineItem.getCgstRate()) / 100;
703 
			float sgstAmount = (customFofoOrderItem.getAmount() * fofoLineItem.getSgstRate()) / 100;
21896 ashik.ali 704 
			customFofoOrderItem.setIgstRate(fofoLineItem.getIgstRate());
22026 ashik.ali 705 
			customFofoOrderItem.setIgstAmount(igstAmount);
706 
			customFofoOrderItem.setCgstRate(fofoLineItem.getCgstRate());
707 
			customFofoOrderItem.setCgstAmount(cgstAmount);
708 
			customFofoOrderItem.setSgstRate(fofoLineItem.getSgstRate());
709 
			customFofoOrderItem.setSgstAmount(sgstAmount);
21896 ashik.ali 710 
			customFofoOrderItem.setHsnCode(fofoLineItem.getHsnCode());
21689 ashik.ali 711 
			customFofoOrderItem.setSerialNumbers(String.join(", ",this.toSerialNumbers(fofoLineItem.getFofoLineItemSerialNumbers())));
712 
			customerFofoOrderItems.add(customFofoOrderItem);
713 
		}
714 
		pdfModel.setOrderItems(customerFofoOrderItems);
715 
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
716 
		PdfUtils.generateAndWrite(pdfModel, byteArrayOutputStream);
717 
		//final MediaType mediaType=MediaType.parseMediaType(profilePhotoModel.getContentType().getValue());
718 
		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);
22026 ashik.ali 719 
        final HttpHeaders headers=new HttpHeaders();
720 
        headers.setContentType(MediaType.APPLICATION_PDF);
721 
        headers.set("Content-Disposition", "Order-"+orderId);
722 
        headers.setContentLength(byteArrayOutputStream.toByteArray().length);
723 
        final InputStream inputStream=new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
724 
        final InputStreamResource inputStreamResource=new InputStreamResource(inputStream);
725 
        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
21689 ashik.ali 726 
	}
21985 kshitij.so 727 
 
21689 ashik.ali 728 
	private Set<String> toSerialNumbers(Set<FofoLineItemSerialNumber> fofoLineItemSerialNumbers){
729 
		Set<String> serialNumbers = new HashSet<>(fofoLineItemSerialNumbers.size());
730 
		for(FofoLineItemSerialNumber fofoLineItemSerialNumber : fofoLineItemSerialNumbers){
731 
			serialNumbers.add(fofoLineItemSerialNumber.getSerialNumber());
732 
		}
733 
		return serialNumbers;
734 
	}
21985 kshitij.so 735 
 
736 
 
21612 ashik.ali 737 
}