Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
23365 ashik.ali 1 
package com.spice.profitmandi.service.order;
22859 ashik.ali 2 
 
3 
import java.time.DateTimeException;
4 
import java.time.LocalDate;
23202 ashik.ali 5 
import java.time.LocalDateTime;
22859 ashik.ali 6 
import java.util.ArrayList;
7 
import java.util.HashMap;
8 
import java.util.HashSet;
9 
import java.util.Iterator;
10 
import java.util.List;
11 
import java.util.Map;
12 
import java.util.Set;
22955 ashik.ali 13 
import java.util.function.Function;
14 
import java.util.stream.Collectors;
22859 ashik.ali 15 
 
16 
import org.json.JSONObject;
17 
import org.slf4j.Logger;
18 
import org.slf4j.LoggerFactory;
19 
import org.springframework.beans.factory.annotation.Autowired;
20 
import org.springframework.stereotype.Component;
21 
 
23202 ashik.ali 22 
import com.spice.profitmandi.common.enumuration.SearchType;
22859 ashik.ali 23 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
24 
import com.spice.profitmandi.common.model.CartFofo;
25 
import com.spice.profitmandi.common.model.CreateOrderRequest;
26 
import com.spice.profitmandi.common.model.CustomAddress;
27 
import com.spice.profitmandi.common.model.CustomCustomer;
28 
import com.spice.profitmandi.common.model.CustomFofoOrderItem;
29 
import com.spice.profitmandi.common.model.CustomInsurancePolicy;
30 
import com.spice.profitmandi.common.model.CustomOrderItem;
31 
import com.spice.profitmandi.common.model.CustomPaymentOption;
32 
import com.spice.profitmandi.common.model.CustomRetailer;
33 
import com.spice.profitmandi.common.model.GadgetCopsInsuranceModel;
23172 ashik.ali 34 
import com.spice.profitmandi.common.model.GstRate;
22859 ashik.ali 35 
import com.spice.profitmandi.common.model.ItemIdQuantityAvailability;
36 
import com.spice.profitmandi.common.model.PdfModel;
37 
import com.spice.profitmandi.common.model.PriceModel;
38 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
39 
import com.spice.profitmandi.common.model.Quantity;
40 
import com.spice.profitmandi.common.model.SerialNumberDetail;
41 
import com.spice.profitmandi.common.util.InsuranceUtils;
42 
import com.spice.profitmandi.common.util.StringUtils;
23172 ashik.ali 43 
import com.spice.profitmandi.common.util.Utils;
22859 ashik.ali 44 
import com.spice.profitmandi.dao.entity.catalog.Item;
45 
import com.spice.profitmandi.dao.entity.dtr.GadgetCopsInsuranceCalc;
46 
import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;
47 
import com.spice.profitmandi.dao.entity.dtr.InsuranceProvider;
48 
import com.spice.profitmandi.dao.entity.dtr.PolicyNumberGenerationSequence;
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;
54 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
55 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
56 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
23365 ashik.ali 57 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderPaymentOption;
23202 ashik.ali 58 
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
22859 ashik.ali 59 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
60 
import com.spice.profitmandi.dao.entity.fofo.InvoiceNumberGenerationSequence;
61 
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
62 
import com.spice.profitmandi.dao.entity.user.Address;
63 
import com.spice.profitmandi.dao.entity.user.Counter;
64 
import com.spice.profitmandi.dao.entity.user.PrivateDealUser;
65 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
66 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
23202 ashik.ali 67 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
22859 ashik.ali 68 
import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
69 
import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
70 
import com.spice.profitmandi.dao.repository.dtr.PolicyNumberGenerationSequenceRepository;
71 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
72 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
73 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
74 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
75 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
76 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
77 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
78 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
79 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
23365 ashik.ali 80 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderPaymentOptionRepository;
22859 ashik.ali 81 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
82 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
83 
import com.spice.profitmandi.dao.repository.fofo.InvoiceNumberGenerationSequenceRepository;
84 
import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
85 
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
86 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
87 
import com.spice.profitmandi.dao.repository.user.CounterRepository;
88 
import com.spice.profitmandi.dao.repository.user.PrivateDealUserRepository;
89 
import com.spice.profitmandi.service.pricing.PricingService;
90 
import com.spice.profitmandi.service.scheme.SchemeService;
91 
 
92 
import in.shop2020.model.v1.catalog.ItemType;
93 
 
94 
@Component
95 
public class OrderServiceImpl implements OrderService {
96 
 
97 
	private static final Logger LOGGER = LoggerFactory.getLogger(OrderServiceImpl.class);
98 
 
99 
	@Autowired
100 
	private InventoryItemRepository inventoryItemRepository;
101 
 
102 
	@Autowired
103 
	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
104 
 
105 
	@Autowired
106 
	private InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;
107 
 
108 
	@Autowired
109 
	private CustomerRepository customerRepository;
110 
 
111 
	@Autowired
112 
	private AddressRepository addressRepository;
113 
 
114 
	@Autowired
115 
	private FofoLineItemRepository fofoLineItemRepository;
116 
 
117 
	@Autowired
118 
	private FofoOrderItemRepository fofoOrderItemRepository;
119 
 
120 
	@Autowired
121 
	private PaymentOptionRepository paymentOptionRepository;
122 
 
123 
	@Autowired
124 
	private ScanRecordRepository scanRecordRepository;
125 
 
126 
	@Autowired
127 
	private FofoOrderRepository fofoOrderRepository;
128 
 
129 
	@Autowired
130 
	private RetailerRepository retailerRepository;
131 
 
132 
	@Autowired
133 
	private UserRepository userRepository;
134 
 
135 
	@Autowired
136 
	private UserAccountRepository userAccountRepository;
137 
 
138 
	@Autowired
139 
	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
140 
 
141 
	@Autowired
142 
	private CustomerAddressRepository customerAddressRepository;
143 
 
144 
	@Autowired
145 
	private ItemRepository itemRepository;
146 
 
147 
	@Autowired
148 
	private InsuranceProviderRepository insuranceProviderRepository;
149 
 
150 
	@Autowired
151 
	private InsurancePolicyRepository insurancePolicyRepository;
152 
 
153 
	@Autowired
154 
	private PolicyNumberGenerationSequenceRepository policyNumberGenerationSequenceRepository;
155 
 
156 
	@Autowired
157 
	private PricingService pricingService;
158 
 
159 
	@Autowired
160 
	private PrivateDealUserRepository privateDealUserRepository;
161 
 
162 
	@Autowired
163 
	private CounterRepository counterRepository;
164 
 
165 
	@Autowired
23202 ashik.ali 166 
	private FofoStoreRepository fofoStoreRepository;
167 
 
168 
	@Autowired
23365 ashik.ali 169 
	private FofoOrderPaymentOptionRepository fofoOrderPaymentOptionRepository;
170 
 
171 
	@Autowired
22859 ashik.ali 172 
	private SchemeService schemeService;
173 
 
174 
	@Override
175 
	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId) throws ProfitMandiBusinessException {
176 
 
22872 ashik.ali 177 
		CustomCustomer customCustomer = createOrderRequest.getCustomer();
178 
 
179 
		if(!StringUtils.isValidEmailAddress(customCustomer.getEmailId())){
180 
			LOGGER.error("invalid customer emailId {} ", customCustomer.getEmailId());
22925 ashik.ali 181 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EMAIL_ID, customCustomer.getEmailId(), "VE_1016");
22872 ashik.ali 182 
		}
183 
 
184 
		if(!StringUtils.isValidMobile(customCustomer.getMobileNumber())){
185 
			LOGGER.error("invalid customer mobileNumber {} ", customCustomer.getMobileNumber());
22925 ashik.ali 186 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.MOBILE_NUMBER, customCustomer.getMobileNumber(), "VE_1071");
22872 ashik.ali 187 
		}
188 
 
23370 ashik.ali 189 
		if(!StringUtils.isValidGstNumber(customCustomer.getGstNumber())) {
23369 ashik.ali 190 
			LOGGER.error("invalid customer gstNumber {} ", customCustomer.getGstNumber());
191 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.CUSTOMER_GST_NUMBER, customCustomer.getGstNumber(), "VE_1072");
192 
		}
193 
 
22859 ashik.ali 194 
		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); //this is for error
22872 ashik.ali 195 
		Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap = new HashMap<>();
22859 ashik.ali 196 
		Map<Integer, Float> lineItemPrice = new HashMap<>(); //this is for pricing error
197 
 
23377 ashik.ali 198 
 
199 
 
22859 ashik.ali 200 
		float totalAmount = 0;
201 
		for(CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()){
22872 ashik.ali 202 
			//itemIds.add(customFofoOrderItem.getItemId());
23377 ashik.ali 203 
			Set<String> serialNumbers = this.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());
204 
			if(!serialNumbers.isEmpty() && customFofoOrderItem.getQuantity() != serialNumbers.size()){
22859 ashik.ali 205 
				itemIdQuantity.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());
206 
			}
207 
			if(!(customFofoOrderItem.getSellingPrice() > 0)){
208 
				lineItemPrice.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getSellingPrice());
209 
			}else{
22863 ashik.ali 210 
				totalAmount = totalAmount + customFofoOrderItem.getSellingPrice() * customFofoOrderItem.getQuantity();
211 
				totalAmount = totalAmount - customFofoOrderItem.getDiscountAmount() * customFofoOrderItem.getQuantity();
22859 ashik.ali 212 
				for(SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()){
213 
					if(serialNumberDetail.isInsurance() && serialNumberDetail.getAmount() > 0){
214 
						totalAmount = totalAmount + serialNumberDetail.getAmount();
215 
					}
216 
				}
217 
			}
218 
 
22872 ashik.ali 219 
			itemIdCustomFofoOrderItemMap.put(customFofoOrderItem.getItemId(), customFofoOrderItem);
22859 ashik.ali 220 
		}
221 
		if(!itemIdQuantity.isEmpty()){
222 
			// if item quantity does not match with given serialnumbers size
223 
			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);
22925 ashik.ali 224 
			throw new ProfitMandiBusinessException("itemIdQuantity", itemIdQuantity, "FFORDR_1001");
22859 ashik.ali 225 
			//return "error";
226 
		}
227 
 
228 
		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);
229 
 
230 
		if(!lineItemPrice.isEmpty()){
231 
			// given fofo line item price must be greater than zero
232 
			LOGGER.error("requested itemId's selling price must greater than 0");
22925 ashik.ali 233 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PRICE, lineItemPrice, "FFORDR_1002");
22859 ashik.ali 234 
		}
235 
 
22872 ashik.ali 236 
		List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository.selectByFofoItemIds(fofoId, itemIdCustomFofoOrderItemMap.keySet());
22859 ashik.ali 237 
 
22872 ashik.ali 238 
		this.validateCurrentInventorySnapshotQuantities(currentInventorySnapshots, itemIdCustomFofoOrderItemMap);
22859 ashik.ali 239 
 
240 
 
22872 ashik.ali 241 
		List<Item> items = itemRepository.selectByIds(itemIdCustomFofoOrderItemMap.keySet());
242 
		if(items.size() != itemIdCustomFofoOrderItemMap.keySet().size()){
243 
			LOGGER.error("Requested ItemIds not found in catalog");
244 
			// invalid itemIds
22925 ashik.ali 245 
			throw new ProfitMandiBusinessException("invalidItemIds", itemIdCustomFofoOrderItemMap.keySet(), "FFORDR_1003");
22872 ashik.ali 246 
		}
247 
 
22859 ashik.ali 248 
		Map<Integer, Item>  itemMap = this.toItemMap(items);
249 
 
250 
		Set<Integer> nonSerializedItemIds = new HashSet<>();
251 
		Set<String> serialNumbers = new HashSet<>();
252 
		Map<String, Float> insuranceSerialNumberItemPrice = new HashMap<>();
253 
		Map<String, Float> insuranceSerialNumberSaleAmount = new HashMap<>();
254 
		Map<String, String> serialNumberModelName = new HashMap<>();
255 
		Map<String, String> serialNumberBrand = new HashMap<>();
22872 ashik.ali 256 
		for (CustomFofoOrderItem customFofoOrderItem: createOrderRequest.getFofoOrderItems()){
257 
			Item item = itemMap.get(customFofoOrderItem.getItemId());
22859 ashik.ali 258 
			if (item.getType().equals(ItemType.SERIALIZED)){
22872 ashik.ali 259 
				for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()){
22859 ashik.ali 260 
					serialNumbers.add(serialNumberDetail.getSerialNumber());
261 
					if(serialNumberDetail.isInsurance()){
22872 ashik.ali 262 
						insuranceSerialNumberItemPrice.put(serialNumberDetail.getSerialNumber(), customFofoOrderItem.getSellingPrice());
22859 ashik.ali 263 
						insuranceSerialNumberSaleAmount.put(serialNumberDetail.getSerialNumber(), serialNumberDetail.getAmount());
23393 amit.gupta 264 
						serialNumberModelName.put(serialNumberDetail.getSerialNumber(), (item.getModelName() + item.getModelNumber()).trim());
22859 ashik.ali 265 
						serialNumberBrand.put(serialNumberDetail.getSerialNumber(), item.getBrand());
266 
					}
267 
				}
268 
			}
269 
			else{
22872 ashik.ali 270 
				nonSerializedItemIds.add(customFofoOrderItem.getItemId());
22859 ashik.ali 271 
			}
272 
		}
273 
 
274 
		Map<Integer, Set<InventoryItem>> serializedInventoryItemMap = new HashMap<>();
275 
		Map<Integer, Set<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<>();
23382 amit.gupta 276 
		//Map<String, Float> serialNumberItemPrice = new HashMap<>();
22859 ashik.ali 277 
 
278 
		if (!nonSerializedItemIds.isEmpty()){
279 
			List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoId, nonSerializedItemIds);
22872 ashik.ali 280 
			LOGGER.info("nonSerializedInventoryItems {}", nonSerializedInventoryItems);
22859 ashik.ali 281 
			for (InventoryItem it : nonSerializedInventoryItems){
282 
				if (it.getGoodQuantity() > 0){
283 
					if (nonSerializedInventoryItemMap.containsKey(it.getItemId())){
284 
						nonSerializedInventoryItemMap.get(it.getItemId()).add(it);
23383 ashik.ali 285 
					}else{
22859 ashik.ali 286 
						Set<InventoryItem> tmp = new HashSet<>();
287 
						tmp.add(it);
288 
						nonSerializedInventoryItemMap.put(it.getItemId(), tmp);
289 
					}
290 
				}
291 
			}
292 
		}
293 
 
22872 ashik.ali 294 
		this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);
22859 ashik.ali 295 
 
296 
		Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();
297 
		Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); //to keep track of inventoryitem quanity used for scan records insertion
298 
 
299 
		LOGGER.info("itemMap keys {}", itemMap.keySet());
300 
		//Lets reduce quantity and decide what inventory items to use.
301 
		for (Item item : items){
302 
			if (item.getType().equals(ItemType.SERIALIZED)){
303 
				//TODO:handle null
22872 ashik.ali 304 
				if (serializedInventoryItemMap.get(item.getId()) == null || itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size() != serializedInventoryItemMap.get(item.getId()).size()){
22859 ashik.ali 305 
					//not enough serial numbers
306 
					//LOGGER.info("serialNumbers {}", serialNumbers);
22872 ashik.ali 307 
					//LOGGER.info("serializedInventoryItemMap {}", serializedInventoryItemMap);
308 
					LOGGER.error("itemId {} => mismatch size of requested serial numbers", item.getId());
22955 ashik.ali 309 
					Function<SerialNumberDetail, String> serialNumberDetailToSerialNumberFunction = new Function<SerialNumberDetail, String>() {
310 
						@Override
311 
						public String apply(SerialNumberDetail serialNumberDetail) {
312 
							return serialNumberDetail.getSerialNumber();
313 
						}
314 
					};
315 
					throw new ProfitMandiBusinessException("invalidSerialNumbers", itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().stream().map(serialNumberDetailToSerialNumberFunction).collect(Collectors.toList()), "FFORDR_1004");
22872 ashik.ali 316 
				}
22859 ashik.ali 317 
				Set<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(item.getId());
22872 ashik.ali 318 
				for (InventoryItem inventoryItem : inventoryItemsSerializedserialized){
319 
					inventoryItem.setGoodQuantity(0);
320 
					inventoryItemIdQuantityUsed.put(inventoryItem.getId(), 1);
22859 ashik.ali 321 
				}
322 
				inventoryItemsToBill.put(item.getId(), inventoryItemsSerializedserialized);
323 
			}
324 
			else{
325 
				Set<InventoryItem> inventoryItemsNonSerialized = nonSerializedInventoryItemMap.get(item.getId());
22872 ashik.ali 326 
				int quantityToBill = itemIdCustomFofoOrderItemMap.get(item.getId()).getQuantity();
22859 ashik.ali 327 
				int totalLeft = quantityToBill;
328 
				Set<InventoryItem> inventoryItemsNonSerializedUsed = new HashSet<>();
329 
				if (inventoryItemsNonSerialized!=null){
330 
					for (InventoryItem inventoryItem : inventoryItemsNonSerialized){
331 
						if (totalLeft > 0){
332 
							int toUse = Math.min(totalLeft, inventoryItem.getGoodQuantity());
333 
							inventoryItemIdQuantityUsed.put(inventoryItem.getId(), toUse);
334 
							inventoryItem.setGoodQuantity(inventoryItem.getGoodQuantity()  - toUse);
335 
							totalLeft = totalLeft - toUse;
336 
							inventoryItemsNonSerializedUsed.add(inventoryItem);
337 
						}
338 
					}
339 
				}
340 
 
341 
				if (totalLeft > 0){
342 
					//not enough quanity for non-serialized
343 
					LOGGER.error("not enough quanity for non-serialized");
22925 ashik.ali 344 
					throw new ProfitMandiBusinessException("notEnoughQuantityForNonSerialized", totalLeft, "FFORDR_1005");
22859 ashik.ali 345 
				}
346 
				inventoryItemsToBill.put(item.getId(), inventoryItemsNonSerializedUsed);
347 
			}
348 
		}
349 
 
22872 ashik.ali 350 
		Map<Integer, PriceModel> itemIdMopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIdCustomFofoOrderItemMap.keySet(), fofoId);
22859 ashik.ali 351 
 
22872 ashik.ali 352 
		this.validateMopPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);
23202 ashik.ali 353 
 
354 
		String fofoStoreCode = this.getFofoStoreCode(fofoId);
22859 ashik.ali 355 
 
23202 ashik.ali 356 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = this.createAndGetInvoiceNumberGenerationSequence(fofoId, fofoStoreCode);
22859 ashik.ali 357 
 
358 
		Customer customer = this.createAndGetCustomer(customCustomer);
359 
 
23191 ashik.ali 360 
		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress(), customer.getId());
22859 ashik.ali 361 
 
23369 ashik.ali 362 
		FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId, invoiceNumberGenerationSequence, totalAmount, customerAddress.getId());
22859 ashik.ali 363 
 
364 
		this.createPaymentOptions(fofoOrder.getId(), createOrderRequest.getPaymentOptions());
365 
 
23172 ashik.ali 366 
		int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);
367 
 
368 
		Address retailerAddress = addressRepository.selectById(retailerAddressId);
369 
 
370 
		Integer stateId = null;
371 
		if(customerAddress.getState().equals(retailerAddress.getState())){
372 
			try{
373 
				stateId = Long.valueOf(Utils.getStateInfo(customerAddress.getState()).getId()).intValue();
374 
			}catch(Exception e){
375 
				LOGGER.error("Unable to get state rates");
376 
			}
377 
		}
378 
 
22859 ashik.ali 379 
		for(CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()){
23393 amit.gupta 380 
			FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(), itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), stateId);
22859 ashik.ali 381 
 
382 
			Set<InventoryItem> inventoryItems = inventoryItemsToBill.get(customFofoOrderItem.getItemId());
383 
 
384 
			this.createFofoLineItem(fofoOrderItem.getId(), inventoryItems, inventoryItemIdQuantityUsed);
385 
 
386 
			this.updateCurrentInventorySnapshot(currentInventorySnapshots, fofoId, customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());
387 
 
388 
			this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed);
389 
		}
390 
 
391 
		// insurance calculation is insurance flag is enabled
392 
		if(!insuranceSerialNumberItemPrice.isEmpty()){
393 
			LOGGER.info("Processing for insurence for serialNumbers");
394 
			Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap = pricingService.getInsurancePrices(new HashSet<>(insuranceSerialNumberItemPrice.values()), ProfitMandiConstants.GADGET_COPS);
395 
			InsuranceProvider insuranceProvider = insuranceProviderRepository.selectByName(ProfitMandiConstants.GADGET_COPS);
396 
 
397 
			this.validateInsuranceAmount(insuranceSerialNumberItemPrice, insuranceSerialNumberSaleAmount, insurancePricesMap);
398 
 
22872 ashik.ali 399 
			this.validateInsuranceMargin(insuranceSerialNumberItemPrice, itemIdCustomFofoOrderItemMap, itemIdMopPriceMap, insurancePricesMap, insuranceSerialNumberSaleAmount);
22859 ashik.ali 400 
 
401 
			LocalDate customerDateOfBirth = this.validateCustomerDateOfBirth(createOrderRequest.getCustomerDateOfBirth());
402 
 
403 
			for(Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()){
404 
				PolicyNumberGenerationSequence policyNumberGenerationSequence = this.createPolicyNumberGenerationSequence();
405 
 
406 
				InsurancePolicy insurancePolicy = this.createInsurancePolicy(
23394 amit.gupta 407 
						fofoOrder.getInvoiceNumber(), fofoId,
22859 ashik.ali 408 
						insurancePricesMap.get(entry.getValue()).getDealerPrice(),
409 
						insuranceSerialNumberSaleAmount.get(entry.getKey()),entry.getValue(),
410 
						entry.getKey(), serialNumberModelName.get(entry.getKey()),
411 
						serialNumberBrand.get(entry.getKey()), policyNumberGenerationSequence.getSequence(),
412 
						insuranceProvider.getId(), customer, customerDateOfBirth, customerAddress);
413 
 
414 
				GadgetCopsInsuranceModel gadgetCopsInsuranceModel = this.createGadgetCopsInsuranceModel(serialNumberBrand.get(entry.getKey()), serialNumberModelName.get(entry.getKey()), entry.getKey(), customerDateOfBirth, customer, customerAddress, insurancePolicy);
415 
 
416 
				try{
417 
					InsuranceUtils.submitToGadgetCops(gadgetCopsInsuranceModel);
418 
					insurancePolicy.setPosted(true);
419 
				}catch (ProfitMandiBusinessException profitMandiBusinessException) {
420 
					LOGGER.info("Unable to submit insurance policy details to {}", insuranceProvider.getName(), profitMandiBusinessException);
421 
				}
422 
				insurancePolicyRepository.persist(insurancePolicy);
423 
			}
424 
		}
23365 ashik.ali 425 
		schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
426 
 
22859 ashik.ali 427 
		return fofoOrder.getId();
428 
	}
429 
 
23377 ashik.ali 430 
	private Set<String> serialNumberDetailsToSerialNumbers(Set<SerialNumberDetail> serialNumberDetails){
431 
		Set<String> serialNumbers = new HashSet<>();
432 
		for(SerialNumberDetail serialNumberDetail : serialNumberDetails) {
433 
			if(serialNumberDetail.getSerialNumber() != null && !serialNumberDetail.getSerialNumber().isEmpty()) {
434 
				serialNumbers.add(serialNumberDetail.getSerialNumber());
435 
			}
436 
		}
437 
		return serialNumbers;
438 
	}
439 
 
22859 ashik.ali 440 
	@Override
441 
	public PdfModel getInvoicePdfModel(int fofoId, int orderId) throws ProfitMandiBusinessException {
442 
 
443 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, orderId);
444 
 
445 
		PdfModel pdfModel = new PdfModel();
446 
		pdfModel.setAuther("profitmandi");
447 
		pdfModel.setTitle("Retailer Invoice");
448 
		pdfModel.setInvoiceDate(fofoOrder.getFormattedDate());
449 
 
450 
		// insurance calculation
22925 ashik.ali 451 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByRetailerIdInvoiceNumber(fofoId, fofoOrder.getInvoiceNumber());
22859 ashik.ali 452 
		Set<CustomInsurancePolicy> customInsurancePolicies = new HashSet<>();
453 
		final float totalInsuranceTaxRate = 18;
454 
		for(InsurancePolicy insurancePolicy : insurancePolicies){
455 
			float taxableInsurancePrice = insurancePolicy.getSaleAmount() / (1 + totalInsuranceTaxRate / 100);
456 
			CustomInsurancePolicy customInsurancePolicy = new CustomInsurancePolicy();
457 
			customInsurancePolicy.setDescription("Damage Protection Plan for device IMEI #" + insurancePolicy.getSerialNumber() + "\n Certificate No. " + insurancePolicy.getPolicyNumber());
458 
			customInsurancePolicy.setHsnCode("998716");
459 
			customInsurancePolicy.setRate(taxableInsurancePrice);
460 
			customInsurancePolicy.setIgstRate(18);
461 
			customInsurancePolicy.setIgstAmount(taxableInsurancePrice * 18 /100);
22936 amit.gupta 462 
			customInsurancePolicy.setCgstRate(9);
22859 ashik.ali 463 
			customInsurancePolicy.setCgstAmount(taxableInsurancePrice * 9 /100);
464 
			customInsurancePolicy.setSgstRate(9);
465 
			customInsurancePolicy.setSgstAmount(taxableInsurancePrice * 9 /100);
466 
			customInsurancePolicy.setNetAmount(insurancePolicy.getSaleAmount());
467 
			customInsurancePolicies.add(customInsurancePolicy);
468 
		}
469 
		pdfModel.setInsurancePolicies(customInsurancePolicies);
23001 amit.gupta 470 
		List<String> tncs = new ArrayList<>();
471 
		tncs.add("I agree that goods received are in good working condition");
472 
		tncs.add("Goods once sold cannot be exchanged or taken back");
473 
		tncs.add("Warranty for the goods received by me is the responsibility of the manufacturer only.");
474 
        if(pdfModel.getInsurancePolicies() != null && pdfModel.getInsurancePolicies().size() > 0) {
23370 ashik.ali 475 
        		tncs.add("Damage protection provided is the responisibility of Protection Provider only");
23001 amit.gupta 476 
        }
477 
		pdfModel.setTncs(tncs);
22859 ashik.ali 478 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
479 
		CustomCustomer customCustomer = new CustomCustomer();
480 
		customCustomer.setFirstName(customer.getFirstName());
481 
		customCustomer.setLastName(customer.getLastName());
482 
		customCustomer.setEmailId(customer.getEmailId());
483 
		customCustomer.setMobileNumber(customer.getMobileNumber());
23370 ashik.ali 484 
		customCustomer.setGstNumber(fofoOrder.getCustomerGstNumber());
22859 ashik.ali 485 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
486 
		customCustomer.setAddress(this.createCustomAddress(customerAddress));
487 
		pdfModel.setCustomer(customCustomer);
488 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
489 
		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
490 
 
491 
		Retailer retailer = retailerRepository.selectById(fofoId);
492 
		PrivateDealUser privateDealUser = null;
493 
		try{
494 
			privateDealUser = privateDealUserRepository.selectById(retailer.getId());
495 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
496 
			LOGGER.error("Private Deal User not found : ", profitMandiBusinessException);
497 
		}
498 
 
499 
		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));
500 
		CustomRetailer customRetailer = new CustomRetailer();
501 
		customRetailer.setBusinessName(retailer.getName());
502 
		customRetailer.setMobileNumber(user.getMobileNumber());
22933 ashik.ali 503 
		//customRetailer.setTinNumber(retailer.getNumber());
22859 ashik.ali 504 
		if(privateDealUser == null){
505 
			customRetailer.setGstNumber(null);
506 
		}else{
507 
			if(null != privateDealUser.getCounterId()){
508 
				Counter counter = counterRepository.selectById(privateDealUser.getCounterId());
509 
				customRetailer.setGstNumber(counter.getGstin());
510 
			}else{
511 
				customRetailer.setGstNumber(null);
512 
			}
513 
		}
514 
		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));
515 
		customRetailer.setAddress(this.createCustomAddress(retailerAddress));
516 
		pdfModel.setRetailer(customRetailer);
22925 ashik.ali 517 
		List<FofoOrderItem> fofoOrderItems = this.getByOrderId(fofoOrder.getId());
22859 ashik.ali 518 
 
519 
		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
520 
		for(FofoOrderItem fofoOrderItem : fofoOrderItems){
521 
			CustomOrderItem customFofoOrderItem = new CustomOrderItem();
522 
			float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate() + fofoOrderItem.getCgstRate();
523 
			float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
524 
			float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
525 
 
526 
			customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));
23377 ashik.ali 527 
			customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " " + fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
528 
			Set<String> serialNumbers = this.toSerialNumbers(fofoOrderItem.getFofoLineItems());
529 
			//LOGGER.info("serialNumbers {}", serialNumbers);
530 
			//LOGGER.info("serialNumbers is empty {}", serialNumbers.isEmpty());
531 
			if(!serialNumbers.isEmpty()) {
532 
				customFofoOrderItem.setDescription(customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
533 
			}
22859 ashik.ali 534 
			customFofoOrderItem.setRate(taxableSellingPrice);
535 
			customFofoOrderItem.setDiscount(taxableDiscountPrice);
536 
			customFofoOrderItem.setQuantity(fofoOrderItem.getQuantity());
537 
			customFofoOrderItem.setNetAmount((fofoOrderItem.getSellingPrice()-fofoOrderItem.getDiscount())*fofoOrderItem.getQuantity());
538 
			float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
539 
			float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
540 
			float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
541 
			customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
542 
			customFofoOrderItem.setIgstAmount(igstAmount);
543 
			customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
544 
			customFofoOrderItem.setCgstAmount(cgstAmount);
545 
			customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
546 
			customFofoOrderItem.setSgstAmount(sgstAmount);
547 
			customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
548 
			customerFofoOrderItems.add(customFofoOrderItem);
549 
		}
550 
		pdfModel.setOrderItems(customerFofoOrderItems);
551 
		return pdfModel;
552 
	}
553 
 
554 
	public String getBillingAddress(CustomerAddress customerAddress) {
555 
		StringBuilder address = new StringBuilder();
556 
		if ((customerAddress.getLine1() != null) && (!customerAddress.getLine1().isEmpty())) {
557 
			address.append(customerAddress.getLine1());
558 
			address.append(", ");
559 
		}
560 
 
561 
		if ((customerAddress.getLine2() != null) && (!customerAddress.getLine2().isEmpty())) {
562 
			address.append(customerAddress.getLine2());
563 
			address.append(", ");
564 
		}
565 
 
566 
		if ((customerAddress.getLandmark() != null) && (!customerAddress.getLandmark().isEmpty())) {
567 
			address.append(customerAddress.getLandmark());
568 
			address.append(", ");
569 
		}
570 
 
571 
		if ((customerAddress.getCity() != null) && (!customerAddress.getCity().isEmpty())) {
572 
			address.append(customerAddress.getCity());
573 
			address.append(", ");
574 
		}
575 
 
576 
		if ((customerAddress.getState() != null) && (!customerAddress.getState().isEmpty())) {
577 
			address.append(customerAddress.getState());
578 
		}
579 
 
580 
		if ((customerAddress.getPinCode() != null) && (!customerAddress.getPinCode().isEmpty())) {
581 
			address.append("- ");
582 
			address.append(customerAddress.getPinCode());
583 
		}
584 
 
585 
		return address.toString();
586 
	}
587 
 
588 
	@Override
589 
	public List<CartFofo> cartCheckout(String cartJson) throws ProfitMandiBusinessException{
590 
		try{
591 
			JSONObject cartObject = new JSONObject(cartJson);
592 
			Iterator<?> keys = cartObject.keys();
593 
 
594 
			Set<Integer> itemIds = new HashSet<>();
595 
			List<CartFofo> cartItems = new ArrayList<CartFofo>();
596 
 
597 
			while( keys.hasNext() ) {
598 
				String key = (String)keys.next();
599 
				if ( cartObject.get(key) instanceof JSONObject ) {
600 
					LOGGER.info(cartObject.get(key).toString());
601 
				}
602 
				CartFofo cf = new CartFofo();
603 
				cf.setItemId(cartObject.getJSONObject(key).getInt("itemId"));
604 
				cf.setQuantity(cartObject.getJSONObject(key).getInt("quantity"));
605 
 
606 
				if (cf.getQuantity() <= 0){
607 
					continue;
608 
				}
609 
				cartItems.add(cf);
610 
				itemIds.add(cartObject.getJSONObject(key).getInt("itemId"));
611 
			}
612 
			Map<Integer, Item>  itemMap = new HashMap<Integer, Item>();
613 
			if (itemIds.size() > 0){
614 
				List<Item> items = itemRepository.selectByIds(itemIds);
615 
				for (Item i : items){
616 
					itemMap.put(i.getId(), i);
617 
				}
618 
 
619 
			}
620 
			for (CartFofo cf : cartItems){
621 
				Item i = itemMap.get(cf.getItemId());
622 
				if (i == null){
623 
					continue;
624 
				}
625 
				cf.setDisplayName(getValidName(i.getBrand())+" "+getValidName(i.getModelName())+" "+getValidName(i.getModelNumber())+" "+getValidName(i.getColor()).replaceAll("\\s+", " "));
626 
				cf.setItemType(i.getType());
627 
			}
628 
			return cartItems;
629 
		}catch (Exception e) {
630 
			LOGGER.error("Unable to Prepare cart to place order...", e);
22925 ashik.ali 631 
			throw new ProfitMandiBusinessException("cartData", cartJson, "FFORDR_1006");
22859 ashik.ali 632 
		}
633 
	}
634 
 
23202 ashik.ali 635 
	@Override
636 
	public Map<String, Object> getSaleHistory(int fofoId, SearchType searchType, String searchValue, String startTimeString,
637 
			String endTimeString, int offset, int limit) throws ProfitMandiBusinessException {
638 
		LocalDateTime startDateTime = StringUtils.toDateTime(startTimeString);
639 
		LocalDateTime endDateTime = StringUtils.toDateTime(endTimeString);
640 
		long countItems = 0;
641 
		List<FofoOrder> fofoOrders = new ArrayList<>();
642 
 
643 
		if(searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()){
644 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
645 
			countItems = fofoOrderRepository.selectCountByCustomerMobileNumber(fofoId, searchValue, startDateTime, endDateTime);
646 
		}else if(searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()){
647 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
648 
			countItems = fofoOrderRepository.selectCountByCustomerName(fofoId, searchValue, startDateTime, endDateTime);
649 
		}else if(searchType == SearchType.IMEI && !searchValue.isEmpty()){
650 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
651 
			countItems = fofoOrderRepository.selectCountBySerialNumber(fofoId, searchValue, startDateTime, endDateTime);
652 
		}else if(searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()){
653 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
654 
			countItems = fofoOrderRepository.selectCountByItemName(fofoId, searchValue, startDateTime, endDateTime);
655 
		}else{
656 
			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDateTime, endDateTime, offset, limit);
23297 ashik.ali 657 
			countItems = fofoOrderRepository.selectCountByFofoId(fofoId, startDateTime, endDateTime);
23202 ashik.ali 658 
		}
659 
		Map<String, Object> map = new HashMap<>();
660 
 
661 
		map.put("saleHistories", fofoOrders);
662 
		map.put("start", offset + 1);
663 
		map.put("size", countItems);
664 
		map.put("searchType", searchType);
23351 ashik.ali 665 
		map.put("searchTypes", SearchType.values());
23202 ashik.ali 666 
		map.put(ProfitMandiConstants.START_TIME, startTimeString);
667 
		map.put(ProfitMandiConstants.END_TIME, endTimeString);
668 
		if (fofoOrders.size() < limit){
669 
			map.put("end", offset + fofoOrders.size());
670 
		}
671 
		else{
672 
			map.put("end", offset + limit);
673 
		}
674 
		return map;
675 
	}
676 
 
677 
	@Override
678 
	public Map<String, Object> getSaleHistoryPaginated(int fofoId, SearchType searchType, String searchValue, String startTimeString,
679 
			String endTimeString, int offset, int limit) throws ProfitMandiBusinessException {
680 
		LocalDateTime startDateTime = StringUtils.toDateTime(startTimeString);
681 
		LocalDateTime endDateTime = StringUtils.toDateTime(endTimeString);
682 
		List<FofoOrder> fofoOrders = new ArrayList<>();
683 
 
684 
		if(searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()){
685 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
686 
		}else if(searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()){
687 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
688 
		}else if(searchType == SearchType.IMEI && !searchValue.isEmpty()){
689 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
690 
		}else if(searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()){
691 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, startDateTime, endDateTime, offset, limit);
692 
		}else{
693 
			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDateTime, endDateTime, offset, limit);
694 
		}
695 
		Map<String, Object> map = new HashMap<>();
696 
 
697 
		map.put("saleHistories", fofoOrders);
698 
		return map;
699 
	}
700 
 
701 
	private String getFofoStoreCode(int fofoId) throws ProfitMandiBusinessException{
702 
		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
23370 ashik.ali 703 
		return fofoStore.getCode();
23202 ashik.ali 704 
	}
705 
 
706 
 
23191 ashik.ali 707 
	private CustomerAddress createCustomerAddress(CustomAddress customAddress, int customerId){
708 
		CustomerAddress customerAddress = null;
709 
		try{
710 
			//CustomAddress customAddress = customCustomer.getAddress();
711 
			customerAddress = customerAddressRepository.selectByParams(
712 
					customAddress.getName(), customAddress.getLine1(), customAddress.getLine2(),
713 
					customAddress.getLandmark(),customAddress.getCity(), customAddress.getPinCode(),
714 
					customAddress.getState(), customAddress.getPhoneNumber(), customAddress.getCountry(), customerId);
715 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
716 
			LOGGER.warn("Customer address not found : ", profitMandiBusinessException);
717 
			customerAddress = new CustomerAddress();
718 
			this.setCustomerAddress(customerAddress, customAddress);
719 
			customerAddress.setCustomerId(customerId);
720 
		}
721 
		customerAddressRepository.persist(customerAddress);
722 
		return customerAddress;
723 
	}
724 
 
22859 ashik.ali 725 
	private String getValidName(String name){
726 
		return name!=null?name:"";
727 
	}
728 
 
729 
	private Set<String> toSerialNumbers(Set<FofoLineItem> fofoLineItems){
23377 ashik.ali 730 
		Set<String> serialNumbers = new HashSet<>();
731 
		for(FofoLineItem fofoLineItem : fofoLineItems) {
23381 amit.gupta 732 
			if(fofoLineItem.getSerialNumber() != null && !fofoLineItem.getSerialNumber().isEmpty()) {
23377 ashik.ali 733 
				serialNumbers.add(fofoLineItem.getSerialNumber());
22955 ashik.ali 734 
			}
23377 ashik.ali 735 
		}
736 
		return serialNumbers;
22859 ashik.ali 737 
	}
738 
 
739 
 
740 
	private PolicyNumberGenerationSequence createPolicyNumberGenerationSequence(){
741 
		PolicyNumberGenerationSequence policyNumberGenerationSequence = null;
742 
		try{
743 
			policyNumberGenerationSequence = policyNumberGenerationSequenceRepository.select();
744 
			policyNumberGenerationSequence.setSequence(policyNumberGenerationSequence.getSequence() + 1);
745 
			policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
746 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
747 
			policyNumberGenerationSequence = new PolicyNumberGenerationSequence();
748 
			policyNumberGenerationSequence.setSequence(1);
749 
			policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
750 
		}
751 
		return policyNumberGenerationSequence;
752 
	}
753 
 
754 
	private GadgetCopsInsuranceModel createGadgetCopsInsuranceModel(String brand, String modelName, String serialNumber, LocalDate customerDateOfBirth, Customer customer, CustomerAddress customerAddress, InsurancePolicy insurancePolicy){
755 
		GadgetCopsInsuranceModel gadgetCopsInsuranceModel = new GadgetCopsInsuranceModel();
756 
		gadgetCopsInsuranceModel.setBrand(brand);
757 
		gadgetCopsInsuranceModel.setModelName(modelName);
758 
		gadgetCopsInsuranceModel.setSerialNumber(serialNumber);
759 
		gadgetCopsInsuranceModel.setCustomerFirstName(customer.getFirstName());
760 
		gadgetCopsInsuranceModel.setCustomerLastName(customer.getLastName());
761 
		gadgetCopsInsuranceModel.setCustomerDateOfBirth(customerDateOfBirth);
762 
		gadgetCopsInsuranceModel.setCustomerMobileNumber(customer.getMobileNumber());
763 
		gadgetCopsInsuranceModel.setCustomerEmailId(customer.getEmailId());
764 
		gadgetCopsInsuranceModel.setCustomerAddress1(customerAddress.getLine1());
765 
		gadgetCopsInsuranceModel.setCustomerAddress2(customerAddress.getLine2());
766 
		gadgetCopsInsuranceModel.setCustomerCity(customerAddress.getCity());
767 
		gadgetCopsInsuranceModel.setCustomerPinCode(customerAddress.getPinCode());
768 
		gadgetCopsInsuranceModel.setCustomerState(customerAddress.getState());
769 
		gadgetCopsInsuranceModel.setPrice(insurancePolicy.getSellingPrice());
770 
		gadgetCopsInsuranceModel.setInvoiceNumber(insurancePolicy.getInvoiceNumber());
771 
		gadgetCopsInsuranceModel.setPolicyNumber(insurancePolicy.getPolicyNumber());
772 
		return gadgetCopsInsuranceModel;
773 
	}
774 
 
23394 amit.gupta 775 
	private InsurancePolicy createInsurancePolicy(String invoiceNumber, int retailerId, float purchaseAmount, float saleAmount, float sellingPrice, String serialNumber, String modelName, String brand, int policyNumberGenerationSequence, int insuranceProviderId, Customer customer, LocalDate customerDateOfBirth, CustomerAddress customerAddress){
22859 ashik.ali 776 
		InsurancePolicy insurancePolicy = new InsurancePolicy();
23394 amit.gupta 777 
		insurancePolicy.setInvoiceNumber(invoiceNumber);
22859 ashik.ali 778 
		insurancePolicy.setRetailerId(retailerId);
779 
		insurancePolicy.setPurchaseAmount(purchaseAmount);
780 
		insurancePolicy.setSaleAmount(saleAmount);
781 
		insurancePolicy.setSellingPrice(sellingPrice);
782 
		insurancePolicy.setSerialNumber(serialNumber);
783 
		insurancePolicy.setModelName(modelName);
784 
		insurancePolicy.setBrand(brand);
785 
		insurancePolicy.setPolicyNumber(StringUtils.generatePolicyNumber(ProfitMandiConstants.POLICY_NUMBER_PREFIX, policyNumberGenerationSequence));
786 
		insurancePolicy.setProviderId(insuranceProviderId);
787 
		insurancePolicy.setCustomerFirstName(customer.getFirstName());
788 
		insurancePolicy.setCustomerLastName(customer.getLastName());
789 
		insurancePolicy.setCustomerMobileNumber(customer.getMobileNumber());
790 
		insurancePolicy.setCustomerEmailId(customer.getEmailId());
791 
		insurancePolicy.setCustomerDateOfBirth(customerDateOfBirth);
792 
		insurancePolicy.setCustomerAddress1(customerAddress.getLine1());
793 
		insurancePolicy.setCustomerAddress2(customerAddress.getLine2());
794 
		insurancePolicy.setCustomerCity(customerAddress.getCity());
795 
		insurancePolicy.setCustomerPinCode(customerAddress.getPinCode());
796 
		insurancePolicy.setCustomerState(customerAddress.getState());
797 
		return insurancePolicy;
798 
	}
799 
 
22872 ashik.ali 800 
	private void validateInsuranceMargin(Map<String, Float> insuranceSerialNumberItemPrice, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap, Map<Integer, PriceModel> itemIdMopPriceMap, Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap, Map<String, Float> insuranceSerialNumberSaleAmount) throws ProfitMandiBusinessException{
22859 ashik.ali 801 
		Map<Float, Float> invalidInsuranceMarginAmount = new HashMap<>();
802 
		for(Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()){
22872 ashik.ali 803 
			int itemId = this.getItemIdFromSerialNumber(itemIdCustomFofoOrderItemMap, entry.getKey());
22859 ashik.ali 804 
			float itemPurchasePrice = itemIdMopPriceMap.get(itemId).getPrice();
805 
			float itemSellingPrice = entry.getValue();
806 
			float itemMargin = itemSellingPrice - itemPurchasePrice;
807 
			float insurancePurchasePrice = insurancePricesMap.get(entry.getValue()).getDealerPrice();
808 
			float insuranceSellingPrice = insuranceSerialNumberSaleAmount.get(entry.getKey());
809 
			float insuranceMargin = insuranceSellingPrice - insurancePurchasePrice;
810 
			if(insuranceMargin < (itemMargin * 30 / 100)){
811 
				invalidInsuranceMarginAmount.put(insuranceMargin, (itemMargin * 30 / 100));
812 
			}
813 
		}
814 
		if(!invalidInsuranceMarginAmount.isEmpty()){
815 
			LOGGER.error("insurance marging should be greater than equal to item profit margin insuranceMarginItemIdMargin {}", invalidInsuranceMarginAmount);
22925 ashik.ali 816 
			throw new ProfitMandiBusinessException("invalidInsuranceMarginAmount", invalidInsuranceMarginAmount, "FFORDR_1007");
22859 ashik.ali 817 
		}
818 
	}
819 
 
820 
	private void validateInsuranceAmount(Map<String, Float> insuranceSerialNumberItemPrice, Map<String, Float> insuranceSerialNumberSaleAmount, Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap) throws ProfitMandiBusinessException{
821 
		Map<Float, Float> invalidInsurancePurchaseSaleAmount = new HashMap<>();
822 
		Map<Float, Float> invalidInsuranceSalePurchaseAmount = new HashMap<>();
823 
		for(Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()){
824 
			if(insuranceSerialNumberSaleAmount.get(entry.getKey()) < insurancePricesMap.get(entry.getValue()).getDealerPrice()){
825 
				invalidInsurancePurchaseSaleAmount.put(insurancePricesMap.get(entry.getValue()).getDealerPrice(), insuranceSerialNumberSaleAmount.get(entry.getKey()));
826 
			}
827 
 
828 
			if(insuranceSerialNumberSaleAmount.get(entry.getKey()) > insurancePricesMap.get(entry.getValue()).getSellingPrice()){
829 
				invalidInsuranceSalePurchaseAmount.put(insuranceSerialNumberSaleAmount.get(entry.getKey()), insurancePricesMap.get(entry.getValue()).getDealerPrice());
830 
			}
831 
		}
832 
 
833 
		// insurance sale amount can not be lesser than insurance purchase amount
834 
		if(!invalidInsurancePurchaseSaleAmount.isEmpty()){
835 
			LOGGER.error("Invalid Insurance prices [{}], insurance sale amount can not be lesser than insurance purchase amount", invalidInsurancePurchaseSaleAmount);
22925 ashik.ali 836 
			throw new ProfitMandiBusinessException("invalidInsurancePurchaseSaleAmount", invalidInsurancePurchaseSaleAmount, "FFORDR_1008");
22859 ashik.ali 837 
		}
838 
 
839 
		if(!invalidInsuranceSalePurchaseAmount.isEmpty()){
840 
			LOGGER.error("Invalid Insurance prices [{}], insurance sale amount can not be greater than than insurance max amount", invalidInsuranceSalePurchaseAmount);
22925 ashik.ali 841 
			throw new ProfitMandiBusinessException("invalidInsuranceSalePurchaseAmount", invalidInsuranceSalePurchaseAmount, "FFORDR_1009");
22859 ashik.ali 842 
		}
843 
	}
844 
 
22872 ashik.ali 845 
	private void validateMopPrice(Map<Integer, PriceModel> itemIdMopPriceMap, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException{
22859 ashik.ali 846 
		Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
847 
		Map<Integer, Float> invalidDiscountAmountMap = new HashMap<>();
848 
		//Map<Integer, PriceModel> itemIdMopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIds, fofoId);
849 
		for(Map.Entry<Integer, PriceModel> entry : itemIdMopPriceMap.entrySet()){
22872 ashik.ali 850 
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoLineItemMap.get(entry.getKey());
851 
			if(entry.getValue().getPrice() < Float.MAX_VALUE && customFofoOrderItem.getSellingPrice() < entry.getValue().getPrice()){
852 
				invalidMopItemIdPriceMap.put(entry.getKey(), customFofoOrderItem.getSellingPrice());
22859 ashik.ali 853 
			}
22872 ashik.ali 854 
			if(entry.getValue().isMop() && customFofoOrderItem.getDiscountAmount() > entry.getValue().getMaxDiscountAmount()){
855 
				invalidDiscountAmountMap.put(entry.getKey(), customFofoOrderItem.getDiscountAmount());
856 
			}
22859 ashik.ali 857 
		}
858 
 
859 
		if(!invalidMopItemIdPriceMap.isEmpty()){
860 
			LOGGER.error("Invalid itemIds selling prices{} should be greater than mop prices {}", invalidMopItemIdPriceMap, itemIdMopPriceMap);
22925 ashik.ali 861 
			throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidMopItemIdPriceMap, "FFORDR_1010");
22859 ashik.ali 862 
		}
863 
 
864 
		if(!invalidMopItemIdPriceMap.isEmpty()){
865 
			LOGGER.error("Invalid itemIds discount amounts {} should be less than maxDiscount prices {}", invalidDiscountAmountMap, itemIdMopPriceMap);
22925 ashik.ali 866 
			throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidDiscountAmountMap, "FFORDR_1011");
22859 ashik.ali 867 
		}
868 
	}
869 
 
870 
	private LocalDate validateCustomerDateOfBirth(String customerDateOfBirthString) throws ProfitMandiBusinessException{
871 
		LocalDate customerDateOfBirth = null;
872 
		try{
873 
			customerDateOfBirth = StringUtils.toDate(customerDateOfBirthString);
874 
		}catch(DateTimeException dateTimeException){
875 
			LOGGER.error("Unable to parse dateOfBirth", dateTimeException);
22925 ashik.ali 876 
			throw new ProfitMandiBusinessException("dateOfBirth", customerDateOfBirthString, "FFORDR_1012");
22859 ashik.ali 877 
		}
878 
		return customerDateOfBirth;
879 
	}
880 
 
881 
	private void updateInventoryItemsAndScanRecord(Set<InventoryItem> inventoryItems, int fofoId, Map<Integer, Integer> inventoryItemQuantityUsed){
882 
		for(InventoryItem inventoryItem : inventoryItems){
883 
			inventoryItem.setLastScanType(ScanType.SALE);
884 
			inventoryItemRepository.persist(inventoryItem);
885 
			ScanRecord scanRecord = new ScanRecord();
886 
			scanRecord.setInventoryItemId(inventoryItem.getId());
887 
			scanRecord.setFofoId(fofoId);
888 
			//correct this
889 
			scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));
890 
			scanRecord.setType(ScanType.SALE);
891 
			scanRecordRepository.persist(scanRecord);
892 
		}
893 
	}
894 
 
895 
	private void createFofoLineItem(int fofoOrderItemId, Set<InventoryItem> inventoryItems, Map<Integer, Integer> inventoryItemIdQuantityUsed){
896 
		for(InventoryItem inventoryItem : inventoryItems){
897 
			FofoLineItem fofoLineItem = new FofoLineItem();
898 
			fofoLineItem.setFofoOrderItemId(fofoOrderItemId);
899 
			fofoLineItem.setSerialNumber(inventoryItem.getSerialNumber());
900 
			fofoLineItem.setInventoryItemId(inventoryItem.getId());
901 
			fofoLineItem.setQuantity(inventoryItemIdQuantityUsed.get(inventoryItem.getId()));
902 
			fofoLineItemRepository.persist(fofoLineItem);
903 
		}
904 
	}
905 
 
23393 amit.gupta 906 
	private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId, Map<Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId) throws ProfitMandiBusinessException{
22859 ashik.ali 907 
		FofoOrderItem fofoOrderItem = new FofoOrderItem();
908 
		fofoOrderItem.setItemId(customFofoOrderItem.getItemId());
909 
		fofoOrderItem.setQuantity(customFofoOrderItem.getQuantity());
910 
		fofoOrderItem.setSellingPrice(customFofoOrderItem.getSellingPrice());
911 
		fofoOrderItem.setOrderId(fofoOrderId);
912 
		fofoOrderItem.setDp(customFofoOrderItem.getSellingPrice());
913 
		fofoOrderItem.setDiscount(customFofoOrderItem.getDiscountAmount());
914 
		Item item = itemMap.get(customFofoOrderItem.getItemId());
23172 ashik.ali 915 
		Map<Integer, GstRate> itemIdStateTaxRateMap = null;
916 
		Map<Integer, Float> itemIdIgstTaxRateMap = null;
917 
		if(stateId != null){
918 
			itemIdStateTaxRateMap = Utils.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);
919 
		}else{
920 
			itemIdIgstTaxRateMap = Utils.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));
921 
		}
23393 amit.gupta 922 
		float cost = 0;
22859 ashik.ali 923 
		for(InventoryItem inventoryItem : inventoryItems){
23172 ashik.ali 924 
			if(stateId == null){
925 
				fofoOrderItem.setIgstRate(itemIdIgstTaxRateMap.get(inventoryItem.getItemId()));
926 
			}else{
927 
				fofoOrderItem.setCgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getCgstRate());
928 
				fofoOrderItem.setSgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getSgstRate());
929 
			}
22859 ashik.ali 930 
			fofoOrderItem.setHsnCode(inventoryItem.getHsnCode());
931 
			break;
932 
		}
23393 amit.gupta 933 
		for(InventoryItem inventoryItem : inventoryItems){
934 
			if(inventoryItem.getSerialNumber() != null) {
935 
				cost += inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
936 
			} else {
937 
				cost += inventoryItem.getUnitPrice();
23382 amit.gupta 938 
			}
939 
		}
23393 amit.gupta 940 
		cost = cost/customFofoOrderItem.getQuantity();
23382 amit.gupta 941 
		fofoOrderItem.setCost(cost);
22859 ashik.ali 942 
		fofoOrderItem.setBrand(item.getBrand());
943 
		fofoOrderItem.setModelName(item.getModelName());
944 
		fofoOrderItem.setModelNumber(item.getModelNumber());
945 
		fofoOrderItem.setColor(item.getColor());
946 
		fofoOrderItemRepository.persist(fofoOrderItem);
947 
		return fofoOrderItem;
948 
	}
949 
 
950 
	private void updateCurrentInventorySnapshot(List<CurrentInventorySnapshot> currentInventorySnapshots, int fofoId, int itemId, int quantity) throws ProfitMandiBusinessException{
951 
		for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
952 
			if(currentInventorySnapshot.getItemId() == itemId && currentInventorySnapshot.getFofoId() == fofoId){
953 
				currentInventorySnapshotRepository.updateAvailabilityByItemIdAndFofoId(itemId, fofoId, currentInventorySnapshot.getAvailability() - quantity);
954 
			}
955 
		}
956 
	}
957 
 
23365 ashik.ali 958 
	private void createPaymentOptions(int fofoOrderId, Set<CustomPaymentOption> customPaymentOptions) throws ProfitMandiBusinessException{
22859 ashik.ali 959 
		for(CustomPaymentOption customPaymentOption : customPaymentOptions){
23371 ashik.ali 960 
			if(customPaymentOption.getAmount() > 0) {
961 
				FofoOrderPaymentOption fofoOrderPaymentOption = new FofoOrderPaymentOption();
962 
				fofoOrderPaymentOption.setFofoOrderId(fofoOrderId);
963 
				fofoOrderPaymentOption.setPaymentOptionId(customPaymentOption.getPaymentOptionId());
964 
				fofoOrderPaymentOption.setAmount(customPaymentOption.getAmount());
965 
				fofoOrderPaymentOptionRepository.persist(fofoOrderPaymentOption);
966 
			}
22859 ashik.ali 967 
		}
968 
	}
969 
 
23369 ashik.ali 970 
	private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId, InvoiceNumberGenerationSequence invoiceNumberGenerationSequence, float totalAmount, int customerAddressId){
22859 ashik.ali 971 
		FofoOrder fofoOrder = new FofoOrder();
23369 ashik.ali 972 
		fofoOrder.setCustomerGstNumber(customerGstNumber);
22859 ashik.ali 973 
		fofoOrder.setCustomerId(customerId);
974 
		fofoOrder.setFofoId(fofoId);
23370 ashik.ali 975 
		fofoOrder.setInvoiceNumber(invoiceNumberGenerationSequence.getPrefix() + "/" + invoiceNumberGenerationSequence.getSequence());
22859 ashik.ali 976 
		fofoOrder.setTotalAmount(totalAmount);
977 
		fofoOrder.setCustomerAddressId(customerAddressId);
978 
		fofoOrderRepository.persist(fofoOrder);
979 
		return fofoOrder;
980 
	}
981 
 
982 
	private Customer createAndGetCustomer(CustomCustomer customCustomer) throws ProfitMandiBusinessException{
983 
		Customer customer = null;
984 
		try{
985 
			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
986 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
987 
			LOGGER.error("Error : ", profitMandiBusinessException);
988 
			customer = new Customer();
989 
		}
23190 ashik.ali 990 
		customer.setFirstName(customCustomer.getFirstName());
991 
		customer.setLastName(customCustomer.getLastName());
992 
		customer.setEmailId(customCustomer.getEmailId());
993 
		customer.setMobileNumber(customCustomer.getMobileNumber());
994 
		customerRepository.persist(customer);
22859 ashik.ali 995 
		return customer;
996 
	}
997 
 
23202 ashik.ali 998 
	private InvoiceNumberGenerationSequence createAndGetInvoiceNumberGenerationSequence(int fofoId, String fofoStoreCode){
22859 ashik.ali 999 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
1000 
		try{
1001 
			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);
1002 
			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
1003 
		}catch(ProfitMandiBusinessException profitMandiBusinessException){
1004 
			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
1005 
			invoiceNumberGenerationSequence.setFofoId(fofoId);
23370 ashik.ali 1006 
			invoiceNumberGenerationSequence.setPrefix(fofoStoreCode);
22859 ashik.ali 1007 
			invoiceNumberGenerationSequence.setSequence(1);
1008 
		}
1009 
		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
1010 
		return invoiceNumberGenerationSequence;
1011 
	}
1012 
 
22872 ashik.ali 1013 
	private void validateItemsSerializedNonSerialized(List<Item> items, Map<Integer, CustomFofoOrderItem> customFofoOrderItemMap) throws ProfitMandiBusinessException{
22859 ashik.ali 1014 
 		List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();
1015 
		List<Integer> itemIdNonSerializedSerialNumbers = new ArrayList<Integer>();
1016 
		for (Item i : items){
22872 ashik.ali 1017 
			CustomFofoOrderItem customFofoOrderItem = customFofoOrderItemMap.get(i.getId());
1018 
			if (i.getType().equals(ItemType.SERIALIZED)){
1019 
				if (customFofoOrderItem == null || customFofoOrderItem.getSerialNumberDetails().isEmpty()){
1020 
					invalidItemIdSerialNumbers.add(i.getId());
22859 ashik.ali 1021 
				}
23202 ashik.ali 1022 
			}else{
23377 ashik.ali 1023 
				Set<String> serialNumbers = this.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());
1024 
				if (customFofoOrderItem == null || !serialNumbers.isEmpty()){
22872 ashik.ali 1025 
					itemIdNonSerializedSerialNumbers.add(i.getId());
22859 ashik.ali 1026 
				}
1027 
			}
1028 
		}
1029 
 
1030 
		if(!invalidItemIdSerialNumbers.isEmpty()){
1031 
			LOGGER.error("Invalid itemId's serialNumbers for serialized{}", invalidItemIdSerialNumbers);
1032 
			// itemId's are serialized you are saying these are not serialized
22925 ashik.ali 1033 
			throw new ProfitMandiBusinessException("invalidItemIdSerialNumbers", invalidItemIdSerialNumbers, "FFORDR_1013");
22859 ashik.ali 1034 
		}
1035 
 
1036 
		if(!itemIdNonSerializedSerialNumbers.isEmpty()){
1037 
			LOGGER.error("Invalid itemId's serialNumbers for non serialized{}", itemIdNonSerializedSerialNumbers);
1038 
			// itemId's are non serialized you are saying these are serialized
22925 ashik.ali 1039 
			throw new ProfitMandiBusinessException("itemIdNonSerializedSerialNumbers", itemIdNonSerializedSerialNumbers, "FFORDR_1014");
22859 ashik.ali 1040 
		}
1041 
	}
1042 
 
22872 ashik.ali 1043 
	private void validateCurrentInventorySnapshotQuantities(List<CurrentInventorySnapshot> currentInventorySnapshots, Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap) throws ProfitMandiBusinessException{
1044 
		if(itemIdCustomFofoOrderItemMap.keySet().size() != currentInventorySnapshots.size()){
22859 ashik.ali 1045 
			throw new ProfitMandiBusinessException("quantiiesSize", currentInventorySnapshots.size(), "");
1046 
		}
1047 
		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); //this is for error
1048 
		LOGGER.info("currentInventorySnapshots "+currentInventorySnapshots);
22872 ashik.ali 1049 
		LOGGER.info("CustomFofoLineItemMap {}", itemIdCustomFofoOrderItemMap);
22859 ashik.ali 1050 
		for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
22872 ashik.ali 1051 
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoOrderItemMap.get(currentInventorySnapshot.getItemId());
1052 
			LOGGER.info("customFofoOrderItem {}", customFofoOrderItem);
1053 
			if(customFofoOrderItem.getQuantity() > currentInventorySnapshot.getAvailability()){
22859 ashik.ali 1054 
					ItemIdQuantityAvailability itemIdQuantityAvailability = new ItemIdQuantityAvailability();
1055 
					itemIdQuantityAvailability.setItemId(customFofoOrderItem.getItemId());
1056 
					Quantity quantity = new Quantity();
1057 
					quantity.setAvailable(currentInventorySnapshot.getAvailability());
1058 
					quantity.setRequested(customFofoOrderItem.getQuantity());
1059 
					itemIdQuantityAvailability.setQuantity(quantity);
1060 
					itemIdQuantityAvailabilities.add(itemIdQuantityAvailability);
1061 
				}
1062 
 
1063 
		}
1064 
 
1065 
 
1066 
 
1067 
		if(!itemIdQuantityAvailabilities.isEmpty()){
1068 
			// itemIdQuantity request is not valid
1069 
			LOGGER.error("Requested quantities should not be greater than currently available quantities {}", itemIdQuantityAvailabilities);
22925 ashik.ali 1070 
			throw new ProfitMandiBusinessException("itemIdQuantityAvailabilities", itemIdQuantityAvailabilities, "FFORDR_1015");
22859 ashik.ali 1071 
		}
1072 
	}
1073 
 
22872 ashik.ali 1074 
	private int getItemIdFromSerialNumber(Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap, String serialNumber){
1075 
		int itemId = 0;
1076 
		for(Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoOrderItemMap.entrySet()){
1077 
			Set<SerialNumberDetail> serialNumberDetails = entry.getValue().getSerialNumberDetails();
1078 
			for(SerialNumberDetail serialNumberDetail : serialNumberDetails){
1079 
				if(serialNumberDetail.getSerialNumber().equals(serialNumber)){
1080 
					itemId = entry.getKey();
1081 
					break;
1082 
				}
22859 ashik.ali 1083 
			}
1084 
		}
22872 ashik.ali 1085 
		return itemId;
22859 ashik.ali 1086 
	}
1087 
 
1088 
	private Map<Integer, Item> toItemMap(List<Item> items){
22955 ashik.ali 1089 
		Function<Item, Integer> itemIdFunction = new Function<Item, Integer>() {
1090 
			@Override
1091 
			public Integer apply(Item item) {
1092 
				return item.getId();
1093 
			}
1094 
		};
1095 
		Function<Item, Item> itemFunction = new Function<Item, Item>() {
1096 
			@Override
1097 
			public Item apply(Item item) {
1098 
				return item;
1099 
			}
1100 
		};
1101 
		return items.stream().collect(Collectors.toMap(itemIdFunction, itemFunction));
22859 ashik.ali 1102 
	}
1103 
 
23190 ashik.ali 1104 
	private void setCustomerAddress(CustomerAddress customerAddress, CustomAddress customAddress){
22859 ashik.ali 1105 
		customerAddress.setName(customAddress.getName());
1106 
		customerAddress.setLine1(customAddress.getLine1());
1107 
		customerAddress.setLine2(customAddress.getLine2());
1108 
		customerAddress.setLandmark(customAddress.getLandmark());
1109 
		customerAddress.setCity(customAddress.getCity());
1110 
		customerAddress.setPinCode(customAddress.getPinCode());
1111 
		customerAddress.setState(customAddress.getState());
1112 
		customerAddress.setCountry(customAddress.getCountry());
1113 
		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());
1114 
	}
1115 
 
1116 
	private CustomAddress createCustomAddress(Address address){
1117 
		CustomAddress customAddress = new CustomAddress();
1118 
		customAddress.setName(address.getName());
1119 
		customAddress.setLine1(address.getLine1());
1120 
		customAddress.setLine2(address.getLine2());
1121 
		customAddress.setLandmark(address.getLandmark());
1122 
		customAddress.setCity(address.getCity());
1123 
		customAddress.setPinCode(address.getPinCode());
1124 
		customAddress.setState(address.getState());
1125 
		customAddress.setCountry(address.getCountry());
1126 
		customAddress.setPhoneNumber(address.getPhoneNumber());
1127 
		return customAddress;
1128 
	}
1129 
 
1130 
	private CustomAddress createCustomAddress(CustomerAddress customerAddress){
1131 
		CustomAddress customAddress = new CustomAddress();
1132 
		customAddress.setName(customerAddress.getName());
1133 
		customAddress.setLine1(customerAddress.getLine1());
1134 
		customAddress.setLine2(customerAddress.getLine2());
1135 
		customAddress.setLandmark(customerAddress.getLandmark());
1136 
		customAddress.setCity(customerAddress.getCity());
1137 
		customAddress.setPinCode(customerAddress.getPinCode());
1138 
		customAddress.setState(customerAddress.getState());
1139 
		customAddress.setCountry(customerAddress.getCountry());
1140 
		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());
1141 
		return customAddress;
1142 
	}
1143 
 
1144 
	private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount) throws ProfitMandiBusinessException
1145 
	{
23365 ashik.ali 1146 
		Set<Integer> paymentOptionIds = new HashSet<>();
1147 
 
22859 ashik.ali 1148 
		float calculatedAmount = 0;
1149 
		for(CustomPaymentOption customPaymentOption : customPaymentOptions){
23365 ashik.ali 1150 
			paymentOptionIds.add(customPaymentOption.getPaymentOptionId());
1151 
			calculatedAmount = calculatedAmount + customPaymentOption.getAmount();
22859 ashik.ali 1152 
		}
1153 
		if(calculatedAmount != totalAmount){
22863 ashik.ali 1154 
			LOGGER.warn("Error occured while validating payment options amount[{}] != TotalAmount [{}]", calculatedAmount, totalAmount);
22925 ashik.ali 1155 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_CALCULATED_AMOUNT, calculatedAmount, "FFORDR_1016");
22859 ashik.ali 1156 
		}
23365 ashik.ali 1157 
 
1158 
		List<Integer> foundPaymentOptionIds = paymentOptionRepository.selectIdsByIds(paymentOptionIds);
1159 
		if(foundPaymentOptionIds.size() != paymentOptionIds.size()) {
1160 
			paymentOptionIds.removeAll(foundPaymentOptionIds);
1161 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_ID, paymentOptionIds, "FFORDR_1017");
1162 
		}
22859 ashik.ali 1163 
	}
22925 ashik.ali 1164 
 
1165 
	@Override
1166 
	public List<FofoOrderItem> getByOrderId(int orderId) throws ProfitMandiBusinessException {
1167 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(orderId);
1168 
		if(!fofoOrderItems.isEmpty()){
1169 
			List<FofoOrderItem> newFofoOrderItems = new ArrayList<>();
1170 
			Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = this.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
1171 
			Iterator<FofoOrderItem> fofoOrderItemsIterator = fofoOrderItems.iterator();
1172 
			while(fofoOrderItemsIterator.hasNext()){
1173 
				FofoOrderItem fofoOrderItem = fofoOrderItemsIterator.next();
1174 
				fofoOrderItem.setFofoLineItems(fofoOrderItemIdFofoLineItemsMap.get(fofoOrderItem.getId()));
1175 
				newFofoOrderItems.add(fofoOrderItem);
1176 
				fofoOrderItemsIterator.remove();
1177 
			}
1178 
			fofoOrderItems = newFofoOrderItems;
1179 
		}
1180 
		return fofoOrderItems;
1181 
	}
1182 
 
1183 
	private Set<Integer> toFofoOrderItemIds(List<FofoOrderItem> fofoOrderItems){
22955 ashik.ali 1184 
		Function<FofoOrderItem, Integer> fofoOrderItemToFofoOrderItemIdFunction = new Function<FofoOrderItem, Integer>() {
1185 
			@Override
1186 
			public Integer apply(FofoOrderItem fofoOrderItem) {
1187 
				return fofoOrderItem.getId();
1188 
			}
1189 
		};
1190 
		return fofoOrderItems.stream().map(fofoOrderItemToFofoOrderItemIdFunction).collect(Collectors.toSet());
22925 ashik.ali 1191 
	}
1192 
 
1193 
	private Map<Integer, Set<FofoLineItem>> toFofoOrderItemIdFofoLineItems(List<FofoOrderItem> fofoOrderItems){
1194 
		Set<Integer> fofoOrderItemIds = this.toFofoOrderItemIds(fofoOrderItems);
1195 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);
1196 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = new HashMap<>();
1197 
		for(FofoLineItem fofoLineItem : fofoLineItems){
1198 
			if(!fofoOrderItemIdFofoLineItemsMap.containsKey(fofoLineItem.getFofoOrderItemId())){
1199 
				Set<FofoLineItem> fofoLineItems2 = new HashSet<>();
1200 
				fofoLineItems2.add(fofoLineItem);
1201 
				fofoOrderItemIdFofoLineItemsMap.put(fofoLineItem.getFofoOrderItemId(), fofoLineItems2);
1202 
			}else{
1203 
				fofoOrderItemIdFofoLineItemsMap.get(fofoLineItem.getFofoOrderItemId()).add(fofoLineItem);
1204 
			}
1205 
		}
1206 
		return fofoOrderItemIdFofoLineItemsMap;
1207 
	}
22859 ashik.ali 1208 
 
1209 
}