Subversion Repositories SmartDukaan

Rev

Rev 23973 | Rev 24121 | 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;
23655 amit.gupta 7 
import java.util.Arrays;
22859 ashik.ali 8 
import java.util.HashMap;
9 
import java.util.HashSet;
10 
import java.util.Iterator;
11 
import java.util.List;
12 
import java.util.Map;
13 
import java.util.Set;
22955 ashik.ali 14 
import java.util.function.Function;
15 
import java.util.stream.Collectors;
22859 ashik.ali 16 
 
23638 amit.gupta 17 
import org.apache.logging.log4j.LogManager;
18 
import org.apache.logging.log4j.Logger;
22859 ashik.ali 19 
import org.json.JSONObject;
20 
import org.springframework.beans.factory.annotation.Autowired;
23781 ashik.ali 21 
import org.springframework.beans.factory.annotation.Qualifier;
22859 ashik.ali 22 
import org.springframework.stereotype.Component;
23 
 
23202 ashik.ali 24 
import com.spice.profitmandi.common.enumuration.SearchType;
22859 ashik.ali 25 
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
23638 amit.gupta 26 
import com.spice.profitmandi.common.model.BadReturnRequest;
22859 ashik.ali 27 
import com.spice.profitmandi.common.model.CartFofo;
28 
import com.spice.profitmandi.common.model.CreateOrderRequest;
23638 amit.gupta 29 
import com.spice.profitmandi.common.model.CreditNotePdfModel;
22859 ashik.ali 30 
import com.spice.profitmandi.common.model.CustomAddress;
31 
import com.spice.profitmandi.common.model.CustomCustomer;
32 
import com.spice.profitmandi.common.model.CustomFofoOrderItem;
33 
import com.spice.profitmandi.common.model.CustomInsurancePolicy;
34 
import com.spice.profitmandi.common.model.CustomOrderItem;
35 
import com.spice.profitmandi.common.model.CustomPaymentOption;
36 
import com.spice.profitmandi.common.model.CustomRetailer;
23638 amit.gupta 37 
import com.spice.profitmandi.common.model.FoiBadReturnRequest;
22859 ashik.ali 38 
import com.spice.profitmandi.common.model.GadgetCopsInsuranceModel;
23172 ashik.ali 39 
import com.spice.profitmandi.common.model.GstRate;
22859 ashik.ali 40 
import com.spice.profitmandi.common.model.ItemIdQuantityAvailability;
41 
import com.spice.profitmandi.common.model.PdfModel;
42 
import com.spice.profitmandi.common.model.PriceModel;
43 
import com.spice.profitmandi.common.model.ProfitMandiConstants;
44 
import com.spice.profitmandi.common.model.Quantity;
45 
import com.spice.profitmandi.common.model.SerialNumberDetail;
23650 amit.gupta 46 
import com.spice.profitmandi.common.util.FormattingUtils;
22859 ashik.ali 47 
import com.spice.profitmandi.common.util.InsuranceUtils;
48 
import com.spice.profitmandi.common.util.StringUtils;
23172 ashik.ali 49 
import com.spice.profitmandi.common.util.Utils;
22859 ashik.ali 50 
import com.spice.profitmandi.dao.entity.catalog.Item;
51 
import com.spice.profitmandi.dao.entity.dtr.GadgetCopsInsuranceCalc;
52 
import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;
53 
import com.spice.profitmandi.dao.entity.dtr.InsuranceProvider;
23546 ashik.ali 54 
import com.spice.profitmandi.dao.entity.dtr.PaymentOptionTransaction;
22859 ashik.ali 55 
import com.spice.profitmandi.dao.entity.dtr.PolicyNumberGenerationSequence;
56 
import com.spice.profitmandi.dao.entity.dtr.Retailer;
57 
import com.spice.profitmandi.dao.entity.dtr.User;
58 
import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;
59 
import com.spice.profitmandi.dao.entity.fofo.Customer;
60 
import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
23650 amit.gupta 61 
import com.spice.profitmandi.dao.entity.fofo.CustomerCreditNote;
62 
import com.spice.profitmandi.dao.entity.fofo.CustomerReturnItem;
22859 ashik.ali 63 
import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;
64 
import com.spice.profitmandi.dao.entity.fofo.FofoOrder;
65 
import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
23202 ashik.ali 66 
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
22859 ashik.ali 67 
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
68 
import com.spice.profitmandi.dao.entity.fofo.InvoiceNumberGenerationSequence;
69 
import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
70 
import com.spice.profitmandi.dao.entity.user.Address;
71 
import com.spice.profitmandi.dao.entity.user.Counter;
72 
import com.spice.profitmandi.dao.entity.user.PrivateDealUser;
23546 ashik.ali 73 
import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;
23650 amit.gupta 74 
import com.spice.profitmandi.dao.enumuration.fofo.ReturnType;
22859 ashik.ali 75 
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
23655 amit.gupta 76 
import com.spice.profitmandi.dao.enumuration.fofo.SettlementType;
22859 ashik.ali 77 
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
23202 ashik.ali 78 
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
22859 ashik.ali 79 
import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
80 
import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
23552 amit.gupta 81 
import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;
22859 ashik.ali 82 
import com.spice.profitmandi.dao.repository.dtr.PolicyNumberGenerationSequenceRepository;
83 
import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
84 
import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
85 
import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
86 
import com.spice.profitmandi.dao.repository.dtr.UserRepository;
87 
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
88 
import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;
23650 amit.gupta 89 
import com.spice.profitmandi.dao.repository.fofo.CustomerCreditNoteRepository;
22859 ashik.ali 90 
import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;
23650 amit.gupta 91 
import com.spice.profitmandi.dao.repository.fofo.CustomerReturnItemRepository;
22859 ashik.ali 92 
import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;
93 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
94 
import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
95 
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
96 
import com.spice.profitmandi.dao.repository.fofo.InvoiceNumberGenerationSequenceRepository;
97 
import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;
23566 amit.gupta 98 
import com.spice.profitmandi.dao.repository.fofo.PurchaseReturnItemRepository;
22859 ashik.ali 99 
import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
100 
import com.spice.profitmandi.dao.repository.user.AddressRepository;
101 
import com.spice.profitmandi.dao.repository.user.CounterRepository;
102 
import com.spice.profitmandi.dao.repository.user.PrivateDealUserRepository;
23418 ashik.ali 103 
import com.spice.profitmandi.service.inventory.InventoryService;
23655 amit.gupta 104 
import com.spice.profitmandi.service.inventory.PurchaseReturnService;
22859 ashik.ali 105 
import com.spice.profitmandi.service.pricing.PricingService;
106 
import com.spice.profitmandi.service.scheme.SchemeService;
23655 amit.gupta 107 
import com.spice.profitmandi.service.user.RetailerService;
23395 amit.gupta 108 
import com.spice.profitmandi.service.wallet.WalletService;
22859 ashik.ali 109 
 
110 
import in.shop2020.model.v1.catalog.ItemType;
23395 amit.gupta 111 
import in.shop2020.model.v1.order.WalletReferenceType;
22859 ashik.ali 112 
 
113 
@Component
114 
public class OrderServiceImpl implements OrderService {
115 
 
23568 govind 116 
	private static final Logger LOGGER = LogManager.getLogger(OrderServiceImpl.class);
22859 ashik.ali 117 
 
118 
	@Autowired
23781 ashik.ali 119 
	@Qualifier("fofoInventoryItemRepository")
22859 ashik.ali 120 
	private InventoryItemRepository inventoryItemRepository;
23650 amit.gupta 121 
 
23395 amit.gupta 122 
	@Autowired
123 
	private WalletService walletService;
22859 ashik.ali 124 
 
125 
	@Autowired
23781 ashik.ali 126 
	@Qualifier("fofoCurrentInventorySnapshotRepository")
22859 ashik.ali 127 
	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;
128 
 
129 
	@Autowired
130 
	private InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;
131 
 
132 
	@Autowired
23655 amit.gupta 133 
	private PurchaseReturnService purchaseReturnService;
134 
 
135 
	@Autowired
136 
	private RetailerService retailerService;
137 
 
138 
	@Autowired
22859 ashik.ali 139 
	private CustomerRepository customerRepository;
23650 amit.gupta 140 
 
23566 amit.gupta 141 
	@Autowired
142 
	private PurchaseReturnItemRepository purchaseReturnItemRepository;
22859 ashik.ali 143 
 
144 
	@Autowired
145 
	private AddressRepository addressRepository;
146 
 
147 
	@Autowired
148 
	private FofoLineItemRepository fofoLineItemRepository;
149 
 
150 
	@Autowired
151 
	private FofoOrderItemRepository fofoOrderItemRepository;
23650 amit.gupta 152 
 
22859 ashik.ali 153 
	@Autowired
154 
	private PaymentOptionRepository paymentOptionRepository;
155 
 
156 
	@Autowired
23650 amit.gupta 157 
	private CustomerReturnItemRepository customerReturnItemRepository;
158 
 
159 
	@Autowired
23781 ashik.ali 160 
	@Qualifier("fofoScanRecordRepository")
22859 ashik.ali 161 
	private ScanRecordRepository scanRecordRepository;
162 
 
163 
	@Autowired
164 
	private FofoOrderRepository fofoOrderRepository;
165 
 
166 
	@Autowired
167 
	private RetailerRepository retailerRepository;
168 
 
169 
	@Autowired
170 
	private UserRepository userRepository;
171 
 
172 
	@Autowired
173 
	private UserAccountRepository userAccountRepository;
174 
 
175 
	@Autowired
176 
	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
177 
 
178 
	@Autowired
179 
	private CustomerAddressRepository customerAddressRepository;
180 
 
181 
	@Autowired
23781 ashik.ali 182 
	@Qualifier("catalogItemRepository")
22859 ashik.ali 183 
	private ItemRepository itemRepository;
23650 amit.gupta 184 
 
22859 ashik.ali 185 
	@Autowired
186 
	private InsuranceProviderRepository insuranceProviderRepository;
23650 amit.gupta 187 
 
22859 ashik.ali 188 
	@Autowired
189 
	private InsurancePolicyRepository insurancePolicyRepository;
23650 amit.gupta 190 
 
22859 ashik.ali 191 
	@Autowired
192 
	private PolicyNumberGenerationSequenceRepository policyNumberGenerationSequenceRepository;
23650 amit.gupta 193 
 
22859 ashik.ali 194 
	@Autowired
195 
	private PricingService pricingService;
23650 amit.gupta 196 
 
22859 ashik.ali 197 
	@Autowired
198 
	private PrivateDealUserRepository privateDealUserRepository;
23650 amit.gupta 199 
 
22859 ashik.ali 200 
	@Autowired
201 
	private CounterRepository counterRepository;
23650 amit.gupta 202 
 
22859 ashik.ali 203 
	@Autowired
23202 ashik.ali 204 
	private FofoStoreRepository fofoStoreRepository;
23650 amit.gupta 205 
 
23202 ashik.ali 206 
	@Autowired
23546 ashik.ali 207 
	private PaymentOptionTransactionRepository paymentOptionTransactionRepository;
23650 amit.gupta 208 
 
23365 ashik.ali 209 
	@Autowired
22859 ashik.ali 210 
	private SchemeService schemeService;
23650 amit.gupta 211 
 
23418 ashik.ali 212 
	@Autowired
23781 ashik.ali 213 
	@Qualifier("fofoInventoryService")
23418 ashik.ali 214 
	private InventoryService inventoryService;
23650 amit.gupta 215 
 
23418 ashik.ali 216 
	@Autowired
23650 amit.gupta 217 
	private CustomerCreditNoteRepository customerCreditNoteRepository;
218 
 
22859 ashik.ali 219 
	@Override
23823 amit.gupta 220 
	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId, boolean accessoriesDeals) throws ProfitMandiBusinessException {
23650 amit.gupta 221 
 
22872 ashik.ali 222 
		CustomCustomer customCustomer = createOrderRequest.getCustomer();
223 
 
23650 amit.gupta 224 
		if (!StringUtils.isValidEmailAddress(customCustomer.getEmailId())) {
22872 ashik.ali 225 
			LOGGER.error("invalid customer emailId {} ", customCustomer.getEmailId());
23650 amit.gupta 226 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.EMAIL_ID, customCustomer.getEmailId(),
227 
					"VE_1016");
22872 ashik.ali 228 
		}
229 
 
23650 amit.gupta 230 
		if (!StringUtils.isValidMobile(customCustomer.getMobileNumber())) {
22872 ashik.ali 231 
			LOGGER.error("invalid customer mobileNumber {} ", customCustomer.getMobileNumber());
23650 amit.gupta 232 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.MOBILE_NUMBER, customCustomer.getMobileNumber(),
233 
					"VE_1071");
22872 ashik.ali 234 
		}
23650 amit.gupta 235 
 
236 
		if (!StringUtils.isValidGstNumber(customCustomer.getGstNumber())) {
23369 ashik.ali 237 
			LOGGER.error("invalid customer gstNumber {} ", customCustomer.getGstNumber());
23650 amit.gupta 238 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.CUSTOMER_GST_NUMBER,
239 
					customCustomer.getGstNumber(), "VE_1072");
23369 ashik.ali 240 
		}
23650 amit.gupta 241 
 
242 
		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); // this is for error
22872 ashik.ali 243 
		Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap = new HashMap<>();
23650 amit.gupta 244 
		Map<Integer, Float> lineItemPrice = new HashMap<>(); // this is for pricing error
245 
 
246 
 
22859 ashik.ali 247 
		float totalAmount = 0;
23650 amit.gupta 248 
		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
249 
			// itemIds.add(customFofoOrderItem.getItemId());
250 
			Set<String> serialNumbers = this
251 
					.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());
252 
			if (!serialNumbers.isEmpty() && customFofoOrderItem.getQuantity() != serialNumbers.size()) {
22859 ashik.ali 253 
				itemIdQuantity.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());
254 
			}
23650 amit.gupta 255 
			if (!(customFofoOrderItem.getSellingPrice() > 0)) {
22859 ashik.ali 256 
				lineItemPrice.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getSellingPrice());
23650 amit.gupta 257 
			} else {
22863 ashik.ali 258 
				totalAmount = totalAmount + customFofoOrderItem.getSellingPrice() * customFofoOrderItem.getQuantity();
259 
				totalAmount = totalAmount - customFofoOrderItem.getDiscountAmount() * customFofoOrderItem.getQuantity();
23650 amit.gupta 260 
				for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {
261 
					if (serialNumberDetail.isInsurance() && serialNumberDetail.getAmount() > 0) {
22859 ashik.ali 262 
						totalAmount = totalAmount + serialNumberDetail.getAmount();
263 
					}
264 
				}
265 
			}
23650 amit.gupta 266 
 
22872 ashik.ali 267 
			itemIdCustomFofoOrderItemMap.put(customFofoOrderItem.getItemId(), customFofoOrderItem);
22859 ashik.ali 268 
		}
23650 amit.gupta 269 
		if (!itemIdQuantity.isEmpty()) {
22859 ashik.ali 270 
			// if item quantity does not match with given serialnumbers size
271 
			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);
22925 ashik.ali 272 
			throw new ProfitMandiBusinessException("itemIdQuantity", itemIdQuantity, "FFORDR_1001");
23650 amit.gupta 273 
			// return "error";
22859 ashik.ali 274 
		}
23650 amit.gupta 275 
 
276 
 
277 
		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(),
24087 amit.gupta 278 
				totalAmount);
23650 amit.gupta 279 
 
280 
		if (!lineItemPrice.isEmpty()) {
22859 ashik.ali 281 
			// given fofo line item price must be greater than zero
282 
			LOGGER.error("requested itemId's selling price must greater than 0");
22925 ashik.ali 283 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PRICE, lineItemPrice, "FFORDR_1002");
22859 ashik.ali 284 
		}
285 
 
23650 amit.gupta 286 
		List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository
287 
				.selectByFofoItemIds(fofoId, itemIdCustomFofoOrderItemMap.keySet());
288 
 
22872 ashik.ali 289 
		this.validateCurrentInventorySnapshotQuantities(currentInventorySnapshots, itemIdCustomFofoOrderItemMap);
22859 ashik.ali 290 
 
22872 ashik.ali 291 
		List<Item> items = itemRepository.selectByIds(itemIdCustomFofoOrderItemMap.keySet());
23650 amit.gupta 292 
		if (items.size() != itemIdCustomFofoOrderItemMap.keySet().size()) {
22872 ashik.ali 293 
			LOGGER.error("Requested ItemIds not found in catalog");
23650 amit.gupta 294 
			// invalid itemIds
295 
			throw new ProfitMandiBusinessException("invalidItemIds", itemIdCustomFofoOrderItemMap.keySet(),
296 
					"FFORDR_1003");
22872 ashik.ali 297 
		}
23650 amit.gupta 298 
 
299 
		Map<Integer, Item> itemMap = this.toItemMap(items);
300 
 
22859 ashik.ali 301 
		Set<Integer> nonSerializedItemIds = new HashSet<>();
302 
		Set<String> serialNumbers = new HashSet<>();
303 
		Map<String, Float> insuranceSerialNumberItemPrice = new HashMap<>();
304 
		Map<String, Float> insuranceSerialNumberSaleAmount = new HashMap<>();
305 
		Map<String, String> serialNumberModelName = new HashMap<>();
306 
		Map<String, String> serialNumberBrand = new HashMap<>();
23650 amit.gupta 307 
		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
22872 ashik.ali 308 
			Item item = itemMap.get(customFofoOrderItem.getItemId());
23650 amit.gupta 309 
			if (item.getType().equals(ItemType.SERIALIZED)) {
310 
				for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {
22859 ashik.ali 311 
					serialNumbers.add(serialNumberDetail.getSerialNumber());
23650 amit.gupta 312 
					if (serialNumberDetail.isInsurance()) {
313 
						insuranceSerialNumberItemPrice.put(serialNumberDetail.getSerialNumber(),
314 
								customFofoOrderItem.getSellingPrice());
315 
						insuranceSerialNumberSaleAmount.put(serialNumberDetail.getSerialNumber(),
316 
								serialNumberDetail.getAmount());
317 
						serialNumberModelName.put(serialNumberDetail.getSerialNumber(),
318 
								(item.getModelName() + item.getModelNumber()).trim());
22859 ashik.ali 319 
						serialNumberBrand.put(serialNumberDetail.getSerialNumber(), item.getBrand());
320 
					}
321 
				}
23650 amit.gupta 322 
			} else {
22872 ashik.ali 323 
				nonSerializedItemIds.add(customFofoOrderItem.getItemId());
22859 ashik.ali 324 
			}
325 
		}
23650 amit.gupta 326 
 
22859 ashik.ali 327 
		Map<Integer, Set<InventoryItem>> serializedInventoryItemMap = new HashMap<>();
328 
		Map<Integer, Set<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<>();
23650 amit.gupta 329 
		// Map<String, Float> serialNumberItemPrice = new HashMap<>();
330 
 
331 
		if (!serialNumbers.isEmpty()) {
332 
			List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId,
23968 amit.gupta 333 
					serialNumbers, false);
23397 amit.gupta 334 
			LOGGER.info("serializedInventoryItems {}", serializedInventoryItems);
23650 amit.gupta 335 
			for (InventoryItem inventoryItem : serializedInventoryItems) {
336 
				if (inventoryItem.getGoodQuantity() == 1) {
337 
					if (serializedInventoryItemMap.containsKey(inventoryItem.getItemId())) {
23397 amit.gupta 338 
						serializedInventoryItemMap.get(inventoryItem.getItemId()).add(inventoryItem);
23650 amit.gupta 339 
					} else {
23397 amit.gupta 340 
						Set<InventoryItem> itemIdInventoryItems = new HashSet<>();
341 
						itemIdInventoryItems.add(inventoryItem);
342 
						serializedInventoryItemMap.put(inventoryItem.getItemId(), itemIdInventoryItems);
343 
					}
344 
				}
345 
			}
346 
		}
23418 ashik.ali 347 
 
23650 amit.gupta 348 
		if (!nonSerializedItemIds.isEmpty()) {
349 
			List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoId,
350 
					nonSerializedItemIds);
22872 ashik.ali 351 
			LOGGER.info("nonSerializedInventoryItems {}", nonSerializedInventoryItems);
23650 amit.gupta 352 
			for (InventoryItem it : nonSerializedInventoryItems) {
353 
				if (it.getGoodQuantity() > 0) {
354 
					if (nonSerializedInventoryItemMap.containsKey(it.getItemId())) {
22859 ashik.ali 355 
						nonSerializedInventoryItemMap.get(it.getItemId()).add(it);
23650 amit.gupta 356 
					} else {
22859 ashik.ali 357 
						Set<InventoryItem> tmp = new HashSet<>();
358 
						tmp.add(it);
359 
						nonSerializedInventoryItemMap.put(it.getItemId(), tmp);
360 
					}
361 
				}
362 
			}
363 
		}
23650 amit.gupta 364 
 
22872 ashik.ali 365 
		this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);
22859 ashik.ali 366 
 
367 
		Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();
23650 amit.gupta 368 
		Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity
369 
																				// used for scan records insertion
22859 ashik.ali 370 
 
371 
		LOGGER.info("itemMap keys {}", itemMap.keySet());
23650 amit.gupta 372 
		// Lets reduce quantity and decide what inventory items to use.
373 
		for (Item item : items) {
374 
			if (item.getType().equals(ItemType.SERIALIZED)) {
375 
				// TODO:handle null
376 
				if (serializedInventoryItemMap.get(item.getId()) == null
377 
						|| itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails()
378 
								.size() != serializedInventoryItemMap.get(item.getId()).size()) {
379 
					// not enough serial numbers
380 
					// LOGGER.info("serialNumbers {}", serialNumbers);
381 
					// LOGGER.info("serializedInventoryItemMap {}", serializedInventoryItemMap);
22872 ashik.ali 382 
					LOGGER.error("itemId {} => mismatch size of requested serial numbers", item.getId());
22955 ashik.ali 383 
					Function<SerialNumberDetail, String> serialNumberDetailToSerialNumberFunction = new Function<SerialNumberDetail, String>() {
384 
						@Override
385 
						public String apply(SerialNumberDetail serialNumberDetail) {
386 
							return serialNumberDetail.getSerialNumber();
387 
						}
388 
					};
23650 amit.gupta 389 
					throw new ProfitMandiBusinessException("invalidSerialNumbers",
390 
							itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().stream()
391 
									.map(serialNumberDetailToSerialNumberFunction).collect(Collectors.toList()),
392 
							"FFORDR_1004");
22872 ashik.ali 393 
				}
22859 ashik.ali 394 
				Set<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(item.getId());
23650 amit.gupta 395 
				for (InventoryItem inventoryItem : inventoryItemsSerializedserialized) {
22872 ashik.ali 396 
					inventoryItem.setGoodQuantity(0);
397 
					inventoryItemIdQuantityUsed.put(inventoryItem.getId(), 1);
22859 ashik.ali 398 
				}
399 
				inventoryItemsToBill.put(item.getId(), inventoryItemsSerializedserialized);
23650 amit.gupta 400 
			} else {
22859 ashik.ali 401 
				Set<InventoryItem> inventoryItemsNonSerialized = nonSerializedInventoryItemMap.get(item.getId());
22872 ashik.ali 402 
				int quantityToBill = itemIdCustomFofoOrderItemMap.get(item.getId()).getQuantity();
22859 ashik.ali 403 
				int totalLeft = quantityToBill;
404 
				Set<InventoryItem> inventoryItemsNonSerializedUsed = new HashSet<>();
23650 amit.gupta 405 
				if (inventoryItemsNonSerialized != null) {
406 
					for (InventoryItem inventoryItem : inventoryItemsNonSerialized) {
407 
						if (totalLeft > 0) {
22859 ashik.ali 408 
							int toUse = Math.min(totalLeft, inventoryItem.getGoodQuantity());
409 
							inventoryItemIdQuantityUsed.put(inventoryItem.getId(), toUse);
23650 amit.gupta 410 
							inventoryItem.setGoodQuantity(inventoryItem.getGoodQuantity() - toUse);
22859 ashik.ali 411 
							totalLeft = totalLeft - toUse;
412 
							inventoryItemsNonSerializedUsed.add(inventoryItem);
413 
						}
414 
					}
415 
				}
23650 amit.gupta 416 
 
417 
				if (totalLeft > 0) {
418 
					// not enough quanity for non-serialized
22859 ashik.ali 419 
					LOGGER.error("not enough quanity for non-serialized");
23650 amit.gupta 420 
					throw new ProfitMandiBusinessException("notEnoughQuantityForNonSerialized", totalLeft,
421 
							"FFORDR_1005");
22859 ashik.ali 422 
				}
423 
				inventoryItemsToBill.put(item.getId(), inventoryItemsNonSerializedUsed);
424 
			}
425 
		}
23650 amit.gupta 426 
 
427 
		Map<Integer, PriceModel> itemIdMopPriceMap = pricingService
428 
				.getPurchasePriceMopPriceNotFound(itemIdCustomFofoOrderItemMap.keySet(), fofoId);
23823 amit.gupta 429 
		if(accessoriesDeals) {
430 
			this.validateDpPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);
431 
		} else {
432 
			this.validateMopPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);
433 
		}
23650 amit.gupta 434 
 
23202 ashik.ali 435 
		String fofoStoreCode = this.getFofoStoreCode(fofoId);
22859 ashik.ali 436 
 
23650 amit.gupta 437 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = this
438 
				.createAndGetInvoiceNumberGenerationSequence(fofoId, fofoStoreCode);
439 
 
22859 ashik.ali 440 
		Customer customer = this.createAndGetCustomer(customCustomer);
23650 amit.gupta 441 
 
23191 ashik.ali 442 
		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress(), customer.getId());
23650 amit.gupta 443 
 
444 
		FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId,
445 
				invoiceNumberGenerationSequence, totalAmount, customerAddress.getId());
446 
 
23612 amit.gupta 447 
		this.createPaymentOptions(fofoOrder, createOrderRequest.getPaymentOptions());
23650 amit.gupta 448 
 
23172 ashik.ali 449 
		int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);
23650 amit.gupta 450 
 
23172 ashik.ali 451 
		Address retailerAddress = addressRepository.selectById(retailerAddressId);
23650 amit.gupta 452 
 
23172 ashik.ali 453 
		Integer stateId = null;
23650 amit.gupta 454 
		if (customerAddress.getState().equals(retailerAddress.getState())) {
455 
			try {
23172 ashik.ali 456 
				stateId = Long.valueOf(Utils.getStateInfo(customerAddress.getState()).getId()).intValue();
23650 amit.gupta 457 
			} catch (Exception e) {
23172 ashik.ali 458 
				LOGGER.error("Unable to get state rates");
459 
			}
460 
		}
23650 amit.gupta 461 
 
462 
		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {
463 
			FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(),
464 
					itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), stateId);
465 
 
22859 ashik.ali 466 
			Set<InventoryItem> inventoryItems = inventoryItemsToBill.get(customFofoOrderItem.getItemId());
23650 amit.gupta 467 
 
22859 ashik.ali 468 
			this.createFofoLineItem(fofoOrderItem.getId(), inventoryItems, inventoryItemIdQuantityUsed);
23650 amit.gupta 469 
 
470 
			this.updateCurrentInventorySnapshot(currentInventorySnapshots, fofoId, customFofoOrderItem.getItemId(),
471 
					customFofoOrderItem.getQuantity());
472 
 
22859 ashik.ali 473 
			this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed);
474 
		}
23650 amit.gupta 475 
 
22859 ashik.ali 476 
		// insurance calculation is insurance flag is enabled
23650 amit.gupta 477 
		if (!insuranceSerialNumberItemPrice.isEmpty()) {
22859 ashik.ali 478 
			LOGGER.info("Processing for insurence for serialNumbers");
23650 amit.gupta 479 
			Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap = pricingService.getInsurancePrices(
480 
					new HashSet<>(insuranceSerialNumberItemPrice.values()), ProfitMandiConstants.GADGET_COPS);
481 
			InsuranceProvider insuranceProvider = insuranceProviderRepository
482 
					.selectByName(ProfitMandiConstants.GADGET_COPS);
483 
 
484 
			this.validateInsuranceAmount(insuranceSerialNumberItemPrice, insuranceSerialNumberSaleAmount,
485 
					insurancePricesMap);
486 
 
487 
			this.validateInsuranceMargin(insuranceSerialNumberItemPrice, itemIdCustomFofoOrderItemMap,
488 
					itemIdMopPriceMap, insurancePricesMap, insuranceSerialNumberSaleAmount);
489 
 
490 
			LocalDate customerDateOfBirth = this
491 
					.validateCustomerDateOfBirth(createOrderRequest.getCustomerDateOfBirth());
492 
 
493 
			for (Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()) {
494 
				PolicyNumberGenerationSequence policyNumberGenerationSequence = this
495 
						.createPolicyNumberGenerationSequence();
496 
 
497 
				InsurancePolicy insurancePolicy = this.createInsurancePolicy(fofoOrder.getInvoiceNumber(), fofoId,
22859 ashik.ali 498 
						insurancePricesMap.get(entry.getValue()).getDealerPrice(),
23650 amit.gupta 499 
						insuranceSerialNumberSaleAmount.get(entry.getKey()), entry.getValue(), entry.getKey(),
500 
						serialNumberModelName.get(entry.getKey()), serialNumberBrand.get(entry.getKey()),
501 
						policyNumberGenerationSequence.getSequence(), insuranceProvider.getId(), customer,
502 
						customerDateOfBirth, customerAddress);
503 
 
504 
				GadgetCopsInsuranceModel gadgetCopsInsuranceModel = this.createGadgetCopsInsuranceModel(
505 
						serialNumberBrand.get(entry.getKey()), serialNumberModelName.get(entry.getKey()),
506 
						entry.getKey(), customerDateOfBirth, customer, customerAddress, insurancePolicy);
507 
				String walletDescription = "Sale of " + insurancePolicy.getPolicyNumber() + " for "
508 
						+ fofoOrder.getInvoiceNumber();
509 
				walletService.consumeAmountFromWallet(fofoId, insurancePolicy.getId(),
23395 amit.gupta 510 
						WalletReferenceType.DAMAGE_PROTECTION, walletDescription, insurancePolicy.getPurchaseAmount());
23650 amit.gupta 511 
 
512 
				try {
22859 ashik.ali 513 
					InsuranceUtils.submitToGadgetCops(gadgetCopsInsuranceModel);
514 
					insurancePolicy.setPosted(true);
23650 amit.gupta 515 
				} catch (ProfitMandiBusinessException profitMandiBusinessException) {
516 
					LOGGER.info("Unable to submit insurance policy details to {}", insuranceProvider.getName(),
517 
							profitMandiBusinessException);
22859 ashik.ali 518 
				}
519 
				insurancePolicyRepository.persist(insurancePolicy);
520 
			}
521 
		}
23365 ashik.ali 522 
		schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
23650 amit.gupta 523 
 
22859 ashik.ali 524 
		return fofoOrder.getId();
525 
	}
23650 amit.gupta 526 
 
527 
	private Set<String> serialNumberDetailsToSerialNumbers(Set<SerialNumberDetail> serialNumberDetails) {
23377 ashik.ali 528 
		Set<String> serialNumbers = new HashSet<>();
23650 amit.gupta 529 
		for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
530 
			if (serialNumberDetail.getSerialNumber() != null && !serialNumberDetail.getSerialNumber().isEmpty()) {
23377 ashik.ali 531 
				serialNumbers.add(serialNumberDetail.getSerialNumber());
532 
			}
533 
		}
534 
		return serialNumbers;
535 
	}
23650 amit.gupta 536 
 
22859 ashik.ali 537 
	@Override
23596 ashik.ali 538 
	public PdfModel getInvoicePdfModel(int orderId) throws ProfitMandiBusinessException {
539 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);
540 
		return this.getInvoicePdfModel(fofoOrder);
541 
	}
23650 amit.gupta 542 
 
543 
	private PdfModel getInvoicePdfModel(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
544 
 
545 
		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository
546 
				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
547 
 
23552 amit.gupta 548 
		List<CustomPaymentOption> paymentOptions = new ArrayList<>();
549 
 
22859 ashik.ali 550 
		PdfModel pdfModel = new PdfModel();
23650 amit.gupta 551 
 
552 
		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
23552 amit.gupta 553 
			CustomPaymentOption cpi = new CustomPaymentOption();
554 
			cpi.setAmount(paymentOptionTransaction.getAmount());
23650 amit.gupta 555 
			cpi.setPaymentOption(
556 
					paymentOptionRepository.selectById(paymentOptionTransaction.getPaymentOptionId()).getName());
23558 amit.gupta 557 
			paymentOptions.add(cpi);
23552 amit.gupta 558 
		}
559 
		pdfModel.setPaymentOptions(paymentOptions);
22859 ashik.ali 560 
		pdfModel.setAuther("profitmandi");
561 
		pdfModel.setTitle("Retailer Invoice");
562 
		pdfModel.setInvoiceDate(fofoOrder.getFormattedDate());
23650 amit.gupta 563 
 
22859 ashik.ali 564 
		// insurance calculation
23650 amit.gupta 565 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
566 
				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
22859 ashik.ali 567 
		Set<CustomInsurancePolicy> customInsurancePolicies = new HashSet<>();
568 
		final float totalInsuranceTaxRate = 18;
23650 amit.gupta 569 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
22859 ashik.ali 570 
			float taxableInsurancePrice = insurancePolicy.getSaleAmount() / (1 + totalInsuranceTaxRate / 100);
571 
			CustomInsurancePolicy customInsurancePolicy = new CustomInsurancePolicy();
23650 amit.gupta 572 
			customInsurancePolicy.setDescription("Damage Protection Plan for device IMEI #"
573 
					+ insurancePolicy.getSerialNumber() + "\n Certificate No. " + insurancePolicy.getPolicyNumber());
22859 ashik.ali 574 
			customInsurancePolicy.setHsnCode("998716");
575 
			customInsurancePolicy.setRate(taxableInsurancePrice);
576 
			customInsurancePolicy.setIgstRate(18);
23650 amit.gupta 577 
			customInsurancePolicy.setIgstAmount(taxableInsurancePrice * 18 / 100);
22936 amit.gupta 578 
			customInsurancePolicy.setCgstRate(9);
23650 amit.gupta 579 
			customInsurancePolicy.setCgstAmount(taxableInsurancePrice * 9 / 100);
22859 ashik.ali 580 
			customInsurancePolicy.setSgstRate(9);
23650 amit.gupta 581 
			customInsurancePolicy.setSgstAmount(taxableInsurancePrice * 9 / 100);
22859 ashik.ali 582 
			customInsurancePolicy.setNetAmount(insurancePolicy.getSaleAmount());
583 
			customInsurancePolicies.add(customInsurancePolicy);
584 
		}
585 
		pdfModel.setInsurancePolicies(customInsurancePolicies);
23001 amit.gupta 586 
		List<String> tncs = new ArrayList<>();
587 
		tncs.add("I agree that goods received are in good working condition");
588 
		tncs.add("Goods once sold cannot be exchanged or taken back");
589 
		tncs.add("Warranty for the goods received by me is the responsibility of the manufacturer only.");
23650 amit.gupta 590 
		if (pdfModel.getInsurancePolicies() != null && pdfModel.getInsurancePolicies().size() > 0) {
591 
			tncs.add("Damage protection provided is the responisibility of Protection Provider only");
592 
		}
23001 amit.gupta 593 
		pdfModel.setTncs(tncs);
23655 amit.gupta 594 
 
595 
		pdfModel.setCustomer(getCustomCustomer(fofoOrder));
22859 ashik.ali 596 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
597 
		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
23650 amit.gupta 598 
 
23596 ashik.ali 599 
		Retailer retailer = retailerRepository.selectById(fofoOrder.getFofoId());
22859 ashik.ali 600 
		PrivateDealUser privateDealUser = null;
23650 amit.gupta 601 
		try {
22859 ashik.ali 602 
			privateDealUser = privateDealUserRepository.selectById(retailer.getId());
23650 amit.gupta 603 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
22859 ashik.ali 604 
			LOGGER.error("Private Deal User not found : ", profitMandiBusinessException);
605 
		}
23650 amit.gupta 606 
 
22859 ashik.ali 607 
		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));
608 
		CustomRetailer customRetailer = new CustomRetailer();
609 
		customRetailer.setBusinessName(retailer.getName());
610 
		customRetailer.setMobileNumber(user.getMobileNumber());
23650 amit.gupta 611 
		// customRetailer.setTinNumber(retailer.getNumber());
612 
		if (privateDealUser == null) {
22859 ashik.ali 613 
			customRetailer.setGstNumber(null);
23650 amit.gupta 614 
		} else {
615 
			if (null != privateDealUser.getCounterId()) {
22859 ashik.ali 616 
				Counter counter = counterRepository.selectById(privateDealUser.getCounterId());
617 
				customRetailer.setGstNumber(counter.getGstin());
23650 amit.gupta 618 
			} else {
22859 ashik.ali 619 
				customRetailer.setGstNumber(null);
620 
			}
621 
		}
23650 amit.gupta 622 
		Address retailerAddress = addressRepository
623 
				.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));
22859 ashik.ali 624 
		customRetailer.setAddress(this.createCustomAddress(retailerAddress));
625 
		pdfModel.setRetailer(customRetailer);
22925 ashik.ali 626 
		List<FofoOrderItem> fofoOrderItems = this.getByOrderId(fofoOrder.getId());
23650 amit.gupta 627 
 
22859 ashik.ali 628 
		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
23650 amit.gupta 629 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
22859 ashik.ali 630 
			CustomOrderItem customFofoOrderItem = new CustomOrderItem();
23650 amit.gupta 631 
			float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate()
632 
					+ fofoOrderItem.getCgstRate();
22859 ashik.ali 633 
			float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
634 
			float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
23650 amit.gupta 635 
 
22859 ashik.ali 636 
			customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));
23650 amit.gupta 637 
			customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "
638 
					+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
23377 ashik.ali 639 
			Set<String> serialNumbers = this.toSerialNumbers(fofoOrderItem.getFofoLineItems());
23650 amit.gupta 640 
			// LOGGER.info("serialNumbers {}", serialNumbers);
641 
			// LOGGER.info("serialNumbers is empty {}", serialNumbers.isEmpty());
642 
			if (!serialNumbers.isEmpty()) {
643 
				customFofoOrderItem.setDescription(
644 
						customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
23377 ashik.ali 645 
			}
22859 ashik.ali 646 
			customFofoOrderItem.setRate(taxableSellingPrice);
647 
			customFofoOrderItem.setDiscount(taxableDiscountPrice);
648 
			customFofoOrderItem.setQuantity(fofoOrderItem.getQuantity());
23650 amit.gupta 649 
			customFofoOrderItem.setNetAmount(
650 
					(fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * fofoOrderItem.getQuantity());
22859 ashik.ali 651 
			float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
652 
			float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
653 
			float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
654 
			customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
655 
			customFofoOrderItem.setIgstAmount(igstAmount);
656 
			customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
657 
			customFofoOrderItem.setCgstAmount(cgstAmount);
658 
			customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
659 
			customFofoOrderItem.setSgstAmount(sgstAmount);
660 
			customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
661 
			customerFofoOrderItems.add(customFofoOrderItem);
662 
		}
663 
		pdfModel.setOrderItems(customerFofoOrderItems);
664 
		return pdfModel;
23650 amit.gupta 665 
 
22859 ashik.ali 666 
	}
23650 amit.gupta 667 
 
23655 amit.gupta 668 
	private CustomCustomer getCustomCustomer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
669 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
670 
		CustomCustomer customCustomer = new CustomCustomer();
671 
		customCustomer.setFirstName(customer.getFirstName());
672 
		customCustomer.setLastName(customer.getLastName());
673 
		customCustomer.setEmailId(customer.getEmailId());
674 
		customCustomer.setMobileNumber(customer.getMobileNumber());
675 
		customCustomer.setGstNumber(fofoOrder.getCustomerGstNumber());
676 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
677 
		customCustomer.setAddress(this.createCustomAddress(customerAddress));
678 
		return customCustomer;
679 
	}
680 
 
23596 ashik.ali 681 
	@Override
682 
	public PdfModel getInvoicePdfModel(int fofoId, int orderId) throws ProfitMandiBusinessException {
683 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, orderId);
684 
		return this.getInvoicePdfModel(fofoOrder);
685 
	}
23650 amit.gupta 686 
 
22859 ashik.ali 687 
	public String getBillingAddress(CustomerAddress customerAddress) {
688 
		StringBuilder address = new StringBuilder();
689 
		if ((customerAddress.getLine1() != null) && (!customerAddress.getLine1().isEmpty())) {
690 
			address.append(customerAddress.getLine1());
691 
			address.append(", ");
692 
		}
693 
 
694 
		if ((customerAddress.getLine2() != null) && (!customerAddress.getLine2().isEmpty())) {
695 
			address.append(customerAddress.getLine2());
696 
			address.append(", ");
697 
		}
698 
 
699 
		if ((customerAddress.getLandmark() != null) && (!customerAddress.getLandmark().isEmpty())) {
700 
			address.append(customerAddress.getLandmark());
701 
			address.append(", ");
702 
		}
703 
 
704 
		if ((customerAddress.getCity() != null) && (!customerAddress.getCity().isEmpty())) {
705 
			address.append(customerAddress.getCity());
706 
			address.append(", ");
707 
		}
708 
 
709 
		if ((customerAddress.getState() != null) && (!customerAddress.getState().isEmpty())) {
710 
			address.append(customerAddress.getState());
711 
		}
712 
 
713 
		if ((customerAddress.getPinCode() != null) && (!customerAddress.getPinCode().isEmpty())) {
714 
			address.append("- ");
715 
			address.append(customerAddress.getPinCode());
716 
		}
717 
 
718 
		return address.toString();
719 
	}
23650 amit.gupta 720 
 
22859 ashik.ali 721 
	@Override
23650 amit.gupta 722 
	public List<CartFofo> cartCheckout(String cartJson) throws ProfitMandiBusinessException {
723 
		try {
22859 ashik.ali 724 
			JSONObject cartObject = new JSONObject(cartJson);
725 
			Iterator<?> keys = cartObject.keys();
23650 amit.gupta 726 
 
22859 ashik.ali 727 
			Set<Integer> itemIds = new HashSet<>();
728 
			List<CartFofo> cartItems = new ArrayList<CartFofo>();
23650 amit.gupta 729 
 
730 
			while (keys.hasNext()) {
731 
				String key = (String) keys.next();
732 
				if (cartObject.get(key) instanceof JSONObject) {
22859 ashik.ali 733 
					LOGGER.info(cartObject.get(key).toString());
734 
				}
735 
				CartFofo cf = new CartFofo();
736 
				cf.setItemId(cartObject.getJSONObject(key).getInt("itemId"));
737 
				cf.setQuantity(cartObject.getJSONObject(key).getInt("quantity"));
23650 amit.gupta 738 
 
739 
				if (cf.getQuantity() <= 0) {
22859 ashik.ali 740 
					continue;
741 
				}
742 
				cartItems.add(cf);
743 
				itemIds.add(cartObject.getJSONObject(key).getInt("itemId"));
744 
			}
23650 amit.gupta 745 
			Map<Integer, Item> itemMap = new HashMap<Integer, Item>();
746 
			if (itemIds.size() > 0) {
22859 ashik.ali 747 
				List<Item> items = itemRepository.selectByIds(itemIds);
23650 amit.gupta 748 
				for (Item i : items) {
22859 ashik.ali 749 
					itemMap.put(i.getId(), i);
750 
				}
23650 amit.gupta 751 
 
22859 ashik.ali 752 
			}
23650 amit.gupta 753 
			for (CartFofo cf : cartItems) {
22859 ashik.ali 754 
				Item i = itemMap.get(cf.getItemId());
23650 amit.gupta 755 
				if (i == null) {
22859 ashik.ali 756 
					continue;
757 
				}
23650 amit.gupta 758 
				cf.setDisplayName(getValidName(i.getBrand()) + " " + getValidName(i.getModelName()) + " "
759 
						+ getValidName(i.getModelNumber()) + " " + getValidName(i.getColor()).replaceAll("\\s+", " "));
22859 ashik.ali 760 
				cf.setItemType(i.getType());
761 
			}
762 
			return cartItems;
23650 amit.gupta 763 
		} catch (Exception e) {
22859 ashik.ali 764 
			LOGGER.error("Unable to Prepare cart to place order...", e);
22925 ashik.ali 765 
			throw new ProfitMandiBusinessException("cartData", cartJson, "FFORDR_1006");
22859 ashik.ali 766 
		}
767 
	}
23650 amit.gupta 768 
 
23202 ashik.ali 769 
	@Override
23650 amit.gupta 770 
	public Map<String, Object> getSaleHistory(int fofoId, SearchType searchType, String searchValue,
23891 amit.gupta 771 
			LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
23202 ashik.ali 772 
		long countItems = 0;
773 
		List<FofoOrder> fofoOrders = new ArrayList<>();
23650 amit.gupta 774 
 
775 
		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
23973 govind 776 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, null,
777 
					null, offset, limit);
778 
			countItems = fofoOrderRepository.selectCountByCustomerMobileNumber(fofoId, searchValue, null,
779 
					null);
23650 amit.gupta 780 
		} else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
23973 govind 781 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, null,
782 
					null, offset, limit);
783 
			countItems = fofoOrderRepository.selectCountByCustomerName(fofoId, searchValue, null, null);
23650 amit.gupta 784 
		} else if (searchType == SearchType.IMEI && !searchValue.isEmpty()) {
23973 govind 785 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, null,
786 
					null, offset, limit);
787 
			countItems = fofoOrderRepository.selectCountBySerialNumber(fofoId, searchValue, null, null);
23650 amit.gupta 788 
		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
23973 govind 789 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, null, null,
23650 amit.gupta 790 
					offset, limit);
23973 govind 791 
			countItems=fofoOrderRepository.selectCountByItemName(fofoId, searchValue, null, null);
23953 amit.gupta 792 
		} else if (searchType == SearchType.INVOICE_NUMBER && !searchValue.isEmpty()) {
793 
			fofoOrders = Arrays.asList(fofoOrderRepository.selectByFofoIdAndInvoiceNumber(fofoId, searchValue));
794 
			countItems = fofoOrders.size();
23973 govind 795 
		}  else if(searchType == SearchType.DATE_RANGE){
23891 amit.gupta 796 
			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDate, endDate, offset, limit);
797 
			countItems = fofoOrderRepository.selectCountByFofoId(fofoId, startDate, endDate);
23202 ashik.ali 798 
		}
799 
		Map<String, Object> map = new HashMap<>();
23650 amit.gupta 800 
 
23202 ashik.ali 801 
		map.put("saleHistories", fofoOrders);
802 
		map.put("start", offset + 1);
803 
		map.put("size", countItems);
804 
		map.put("searchType", searchType);
23351 ashik.ali 805 
		map.put("searchTypes", SearchType.values());
23891 amit.gupta 806 
		map.put("startDate", startDate);
23973 govind 807 
		map.put("searchValue", searchValue);
23891 amit.gupta 808 
		map.put(ProfitMandiConstants.END_TIME, endDate);
23650 amit.gupta 809 
		if (fofoOrders.size() < limit) {
23202 ashik.ali 810 
			map.put("end", offset + fofoOrders.size());
23650 amit.gupta 811 
		} else {
23202 ashik.ali 812 
			map.put("end", offset + limit);
813 
		}
814 
		return map;
815 
	}
816 
 
817 
	@Override
23650 amit.gupta 818 
	public Map<String, Object> getSaleHistoryPaginated(int fofoId, SearchType searchType, String searchValue,
23891 amit.gupta 819 
			LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
23202 ashik.ali 820 
		List<FofoOrder> fofoOrders = new ArrayList<>();
23650 amit.gupta 821 
 
822 
		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
23891 amit.gupta 823 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDate,
824 
					endDate, offset, limit);
23650 amit.gupta 825 
		} else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
23891 amit.gupta 826 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, startDate,
827 
					endDate, offset, limit);
23650 amit.gupta 828 
		} else if (searchType == SearchType.IMEI && !searchValue.isEmpty()) {
23891 amit.gupta 829 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, startDate,
830 
					endDate, offset, limit);
23650 amit.gupta 831 
		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
23891 amit.gupta 832 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, startDate, endDate,
23650 amit.gupta 833 
					offset, limit);
23973 govind 834 
 
835 
		}  else if (searchType == SearchType.DATE_RANGE){
23891 amit.gupta 836 
			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDate, endDate, offset, limit);
23202 ashik.ali 837 
		}
838 
		Map<String, Object> map = new HashMap<>();
839 
		map.put("saleHistories", fofoOrders);
23973 govind 840 
		map.put("searchType", searchType);
841 
		map.put("searchTypes", SearchType.values());
842 
		map.put("startDate", startDate);
843 
		map.put("searchValue", searchValue);
844 
		map.put(ProfitMandiConstants.END_TIME, endDate);
23202 ashik.ali 845 
		return map;
846 
	}
23650 amit.gupta 847 
 
848 
	private String getFofoStoreCode(int fofoId) throws ProfitMandiBusinessException {
23202 ashik.ali 849 
		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
23370 ashik.ali 850 
		return fofoStore.getCode();
23202 ashik.ali 851 
	}
23650 amit.gupta 852 
 
853 
	private CustomerAddress createCustomerAddress(CustomAddress customAddress, int customerId) {
23191 ashik.ali 854 
		CustomerAddress customerAddress = null;
23650 amit.gupta 855 
		try {
856 
			// CustomAddress customAddress = customCustomer.getAddress();
857 
			customerAddress = customerAddressRepository.selectByParams(customAddress.getName(),
858 
					customAddress.getLine1(), customAddress.getLine2(), customAddress.getLandmark(),
859 
					customAddress.getCity(), customAddress.getPinCode(), customAddress.getState(),
860 
					customAddress.getPhoneNumber(), customAddress.getCountry(), customerId);
861 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
23596 ashik.ali 862 
			LOGGER.warn("Customer address not found with [{}]", customAddress);
23191 ashik.ali 863 
			customerAddress = new CustomerAddress();
864 
			this.setCustomerAddress(customerAddress, customAddress);
865 
			customerAddress.setCustomerId(customerId);
866 
		}
867 
		customerAddressRepository.persist(customerAddress);
868 
		return customerAddress;
869 
	}
23650 amit.gupta 870 
 
871 
	private String getValidName(String name) {
872 
		return name != null ? name : "";
22859 ashik.ali 873 
	}
23650 amit.gupta 874 
 
875 
	private Set<String> toSerialNumbers(Set<FofoLineItem> fofoLineItems) {
23377 ashik.ali 876 
		Set<String> serialNumbers = new HashSet<>();
23650 amit.gupta 877 
		for (FofoLineItem fofoLineItem : fofoLineItems) {
878 
			if (fofoLineItem.getSerialNumber() != null && !fofoLineItem.getSerialNumber().isEmpty()) {
23377 ashik.ali 879 
				serialNumbers.add(fofoLineItem.getSerialNumber());
22955 ashik.ali 880 
			}
23377 ashik.ali 881 
		}
882 
		return serialNumbers;
22859 ashik.ali 883 
	}
23650 amit.gupta 884 
 
885 
	private PolicyNumberGenerationSequence createPolicyNumberGenerationSequence() {
22859 ashik.ali 886 
		PolicyNumberGenerationSequence policyNumberGenerationSequence = null;
23650 amit.gupta 887 
		try {
22859 ashik.ali 888 
			policyNumberGenerationSequence = policyNumberGenerationSequenceRepository.select();
889 
			policyNumberGenerationSequence.setSequence(policyNumberGenerationSequence.getSequence() + 1);
890 
			policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
23650 amit.gupta 891 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
22859 ashik.ali 892 
			policyNumberGenerationSequence = new PolicyNumberGenerationSequence();
893 
			policyNumberGenerationSequence.setSequence(1);
894 
			policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
895 
		}
896 
		return policyNumberGenerationSequence;
897 
	}
23650 amit.gupta 898 
 
899 
	private GadgetCopsInsuranceModel createGadgetCopsInsuranceModel(String brand, String modelName, String serialNumber,
900 
			LocalDate customerDateOfBirth, Customer customer, CustomerAddress customerAddress,
901 
			InsurancePolicy insurancePolicy) {
22859 ashik.ali 902 
		GadgetCopsInsuranceModel gadgetCopsInsuranceModel = new GadgetCopsInsuranceModel();
903 
		gadgetCopsInsuranceModel.setBrand(brand);
904 
		gadgetCopsInsuranceModel.setModelName(modelName);
905 
		gadgetCopsInsuranceModel.setSerialNumber(serialNumber);
906 
		gadgetCopsInsuranceModel.setCustomerFirstName(customer.getFirstName());
907 
		gadgetCopsInsuranceModel.setCustomerLastName(customer.getLastName());
908 
		gadgetCopsInsuranceModel.setCustomerDateOfBirth(customerDateOfBirth);
909 
		gadgetCopsInsuranceModel.setCustomerMobileNumber(customer.getMobileNumber());
910 
		gadgetCopsInsuranceModel.setCustomerEmailId(customer.getEmailId());
911 
		gadgetCopsInsuranceModel.setCustomerAddress1(customerAddress.getLine1());
912 
		gadgetCopsInsuranceModel.setCustomerAddress2(customerAddress.getLine2());
913 
		gadgetCopsInsuranceModel.setCustomerCity(customerAddress.getCity());
914 
		gadgetCopsInsuranceModel.setCustomerPinCode(customerAddress.getPinCode());
915 
		gadgetCopsInsuranceModel.setCustomerState(customerAddress.getState());
916 
		gadgetCopsInsuranceModel.setPrice(insurancePolicy.getSellingPrice());
917 
		gadgetCopsInsuranceModel.setInvoiceNumber(insurancePolicy.getInvoiceNumber());
918 
		gadgetCopsInsuranceModel.setPolicyNumber(insurancePolicy.getPolicyNumber());
919 
		return gadgetCopsInsuranceModel;
920 
	}
23650 amit.gupta 921 
 
922 
	private InsurancePolicy createInsurancePolicy(String invoiceNumber, int retailerId, float purchaseAmount,
923 
			float saleAmount, float sellingPrice, String serialNumber, String modelName, String brand,
924 
			int policyNumberGenerationSequence, int insuranceProviderId, Customer customer,
925 
			LocalDate customerDateOfBirth, CustomerAddress customerAddress) {
22859 ashik.ali 926 
		InsurancePolicy insurancePolicy = new InsurancePolicy();
23394 amit.gupta 927 
		insurancePolicy.setInvoiceNumber(invoiceNumber);
22859 ashik.ali 928 
		insurancePolicy.setRetailerId(retailerId);
929 
		insurancePolicy.setPurchaseAmount(purchaseAmount);
930 
		insurancePolicy.setSaleAmount(saleAmount);
931 
		insurancePolicy.setSellingPrice(sellingPrice);
932 
		insurancePolicy.setSerialNumber(serialNumber);
933 
		insurancePolicy.setModelName(modelName);
934 
		insurancePolicy.setBrand(brand);
23650 amit.gupta 935 
		insurancePolicy.setPolicyNumber(StringUtils.generatePolicyNumber(ProfitMandiConstants.POLICY_NUMBER_PREFIX,
936 
				policyNumberGenerationSequence));
22859 ashik.ali 937 
		insurancePolicy.setProviderId(insuranceProviderId);
938 
		insurancePolicy.setCustomerFirstName(customer.getFirstName());
939 
		insurancePolicy.setCustomerLastName(customer.getLastName());
940 
		insurancePolicy.setCustomerMobileNumber(customer.getMobileNumber());
941 
		insurancePolicy.setCustomerEmailId(customer.getEmailId());
942 
		insurancePolicy.setCustomerDateOfBirth(customerDateOfBirth);
943 
		insurancePolicy.setCustomerAddress1(customerAddress.getLine1());
944 
		insurancePolicy.setCustomerAddress2(customerAddress.getLine2());
945 
		insurancePolicy.setCustomerCity(customerAddress.getCity());
946 
		insurancePolicy.setCustomerPinCode(customerAddress.getPinCode());
947 
		insurancePolicy.setCustomerState(customerAddress.getState());
948 
		return insurancePolicy;
949 
	}
23650 amit.gupta 950 
 
951 
	private void validateInsuranceMargin(Map<String, Float> insuranceSerialNumberItemPrice,
952 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap, Map<Integer, PriceModel> itemIdMopPriceMap,
953 
			Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap, Map<String, Float> insuranceSerialNumberSaleAmount)
954 
			throws ProfitMandiBusinessException {
22859 ashik.ali 955 
		Map<Float, Float> invalidInsuranceMarginAmount = new HashMap<>();
23650 amit.gupta 956 
		for (Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()) {
22872 ashik.ali 957 
			int itemId = this.getItemIdFromSerialNumber(itemIdCustomFofoOrderItemMap, entry.getKey());
22859 ashik.ali 958 
			float itemPurchasePrice = itemIdMopPriceMap.get(itemId).getPrice();
959 
			float itemSellingPrice = entry.getValue();
960 
			float itemMargin = itemSellingPrice - itemPurchasePrice;
961 
			float insurancePurchasePrice = insurancePricesMap.get(entry.getValue()).getDealerPrice();
962 
			float insuranceSellingPrice = insuranceSerialNumberSaleAmount.get(entry.getKey());
963 
			float insuranceMargin = insuranceSellingPrice - insurancePurchasePrice;
23650 amit.gupta 964 
			if (insuranceMargin < (itemMargin * 30 / 100)) {
22859 ashik.ali 965 
				invalidInsuranceMarginAmount.put(insuranceMargin, (itemMargin * 30 / 100));
966 
			}
967 
		}
23650 amit.gupta 968 
		if (!invalidInsuranceMarginAmount.isEmpty()) {
969 
			LOGGER.error(
970 
					"insurance marging should be greater than equal to item profit margin insuranceMarginItemIdMargin {}",
971 
					invalidInsuranceMarginAmount);
972 
			throw new ProfitMandiBusinessException("invalidInsuranceMarginAmount", invalidInsuranceMarginAmount,
973 
					"FFORDR_1007");
22859 ashik.ali 974 
		}
975 
	}
23650 amit.gupta 976 
 
977 
	private void validateInsuranceAmount(Map<String, Float> insuranceSerialNumberItemPrice,
978 
			Map<String, Float> insuranceSerialNumberSaleAmount, Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap)
979 
			throws ProfitMandiBusinessException {
22859 ashik.ali 980 
		Map<Float, Float> invalidInsurancePurchaseSaleAmount = new HashMap<>();
981 
		Map<Float, Float> invalidInsuranceSalePurchaseAmount = new HashMap<>();
23650 amit.gupta 982 
		for (Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()) {
983 
			if (insuranceSerialNumberSaleAmount.get(entry.getKey()) < insurancePricesMap.get(entry.getValue())
984 
					.getDealerPrice()) {
985 
				invalidInsurancePurchaseSaleAmount.put(insurancePricesMap.get(entry.getValue()).getDealerPrice(),
986 
						insuranceSerialNumberSaleAmount.get(entry.getKey()));
22859 ashik.ali 987 
			}
23650 amit.gupta 988 
 
989 
			if (insuranceSerialNumberSaleAmount.get(entry.getKey()) > insurancePricesMap.get(entry.getValue())
990 
					.getSellingPrice()) {
991 
				invalidInsuranceSalePurchaseAmount.put(insuranceSerialNumberSaleAmount.get(entry.getKey()),
992 
						insurancePricesMap.get(entry.getValue()).getDealerPrice());
22859 ashik.ali 993 
			}
994 
		}
23650 amit.gupta 995 
 
22859 ashik.ali 996 
		// insurance sale amount can not be lesser than insurance purchase amount
23650 amit.gupta 997 
		if (!invalidInsurancePurchaseSaleAmount.isEmpty()) {
998 
			LOGGER.error(
999 
					"Invalid Insurance prices [{}], insurance sale amount can not be lesser than insurance purchase amount",
1000 
					invalidInsurancePurchaseSaleAmount);
1001 
			throw new ProfitMandiBusinessException("invalidInsurancePurchaseSaleAmount",
1002 
					invalidInsurancePurchaseSaleAmount, "FFORDR_1008");
22859 ashik.ali 1003 
		}
23650 amit.gupta 1004 
 
1005 
		if (!invalidInsuranceSalePurchaseAmount.isEmpty()) {
1006 
			LOGGER.error(
1007 
					"Invalid Insurance prices [{}], insurance sale amount can not be greater than than insurance max amount",
1008 
					invalidInsuranceSalePurchaseAmount);
1009 
			throw new ProfitMandiBusinessException("invalidInsuranceSalePurchaseAmount",
1010 
					invalidInsuranceSalePurchaseAmount, "FFORDR_1009");
22859 ashik.ali 1011 
		}
1012 
	}
23823 amit.gupta 1013 
	private void validateDpPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
1014 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
1015 
		for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoLineItemMap.entrySet()) {
1016 
			int itemId = entry.getKey();
1017 
			CustomFofoOrderItem customFofoOrderItem = entry.getValue();
1018 
			PriceModel priceModel = itemIdMopPriceMap.get(itemId);
1019 
			if(customFofoOrderItem.getSerialNumberDetails().size() > 0) {
23857 amit.gupta 1020 
				if(priceModel.getPrice() > customFofoOrderItem.getSellingPrice()) {
23823 amit.gupta 1021 
					throw new ProfitMandiBusinessException("Selling Price", itemRepository.selectById(itemId).getItemDescription(), "FFORDR_1010");
1022 
				}
1023 
			} else {
23857 amit.gupta 1024 
				if(priceModel.getPurchasePrice() > customFofoOrderItem.getSellingPrice()) {
23823 amit.gupta 1025 
					throw new ProfitMandiBusinessException("Selling Price", itemRepository.selectById(itemId).getItemDescription(), "Selling Price should not be less than DP");
1026 
				}
1027 
			}
1028 
		}
1029 
	}
23650 amit.gupta 1030 
	private void validateMopPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
1031 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
22859 ashik.ali 1032 
		Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
1033 
		Map<Integer, Float> invalidDiscountAmountMap = new HashMap<>();
23650 amit.gupta 1034 
		for (Map.Entry<Integer, PriceModel> entry : itemIdMopPriceMap.entrySet()) {
22872 ashik.ali 1035 
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoLineItemMap.get(entry.getKey());
23650 amit.gupta 1036 
			if (entry.getValue().getPrice() < Float.MAX_VALUE
1037 
					&& customFofoOrderItem.getSellingPrice() < entry.getValue().getPrice()) {
22872 ashik.ali 1038 
				invalidMopItemIdPriceMap.put(entry.getKey(), customFofoOrderItem.getSellingPrice());
22859 ashik.ali 1039 
			}
23650 amit.gupta 1040 
			if (entry.getValue().isMop()
1041 
					&& customFofoOrderItem.getDiscountAmount() > entry.getValue().getMaxDiscountAmount()) {
22872 ashik.ali 1042 
				invalidDiscountAmountMap.put(entry.getKey(), customFofoOrderItem.getDiscountAmount());
1043 
			}
22859 ashik.ali 1044 
		}
23650 amit.gupta 1045 
 
1046 
		if (!invalidMopItemIdPriceMap.isEmpty()) {
1047 
			LOGGER.error("Invalid itemIds selling prices{} should be greater than mop prices {}",
1048 
					invalidMopItemIdPriceMap, itemIdMopPriceMap);
22925 ashik.ali 1049 
			throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidMopItemIdPriceMap, "FFORDR_1010");
22859 ashik.ali 1050 
		}
23650 amit.gupta 1051 
 
23857 amit.gupta 1052 
		if (!invalidDiscountAmountMap.isEmpty()) {
23650 amit.gupta 1053 
			LOGGER.error("Invalid itemIds discount amounts {} should be less than maxDiscount prices {}",
1054 
					invalidDiscountAmountMap, itemIdMopPriceMap);
22925 ashik.ali 1055 
			throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidDiscountAmountMap, "FFORDR_1011");
22859 ashik.ali 1056 
		}
1057 
	}
23650 amit.gupta 1058 
 
1059 
	private LocalDate validateCustomerDateOfBirth(String customerDateOfBirthString)
1060 
			throws ProfitMandiBusinessException {
22859 ashik.ali 1061 
		LocalDate customerDateOfBirth = null;
23650 amit.gupta 1062 
		try {
22859 ashik.ali 1063 
			customerDateOfBirth = StringUtils.toDate(customerDateOfBirthString);
23650 amit.gupta 1064 
		} catch (DateTimeException dateTimeException) {
23596 ashik.ali 1065 
			LOGGER.error("Unable to parse dateOfBirth message {}", dateTimeException.getMessage());
22925 ashik.ali 1066 
			throw new ProfitMandiBusinessException("dateOfBirth", customerDateOfBirthString, "FFORDR_1012");
22859 ashik.ali 1067 
		}
1068 
		return customerDateOfBirth;
1069 
	}
23650 amit.gupta 1070 
 
1071 
	private void updateInventoryItemsAndScanRecord(Set<InventoryItem> inventoryItems, int fofoId,
1072 
			Map<Integer, Integer> inventoryItemQuantityUsed) {
1073 
		for (InventoryItem inventoryItem : inventoryItems) {
22859 ashik.ali 1074 
			inventoryItem.setLastScanType(ScanType.SALE);
1075 
			inventoryItemRepository.persist(inventoryItem);
1076 
			ScanRecord scanRecord = new ScanRecord();
1077 
			scanRecord.setInventoryItemId(inventoryItem.getId());
1078 
			scanRecord.setFofoId(fofoId);
23650 amit.gupta 1079 
			// correct this
22859 ashik.ali 1080 
			scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));
1081 
			scanRecord.setType(ScanType.SALE);
1082 
			scanRecordRepository.persist(scanRecord);
23566 amit.gupta 1083 
			purchaseReturnItemRepository.deleteById(inventoryItem.getId());
23650 amit.gupta 1084 
 
22859 ashik.ali 1085 
		}
1086 
	}
23650 amit.gupta 1087 
 
1088 
	private void createFofoLineItem(int fofoOrderItemId, Set<InventoryItem> inventoryItems,
1089 
			Map<Integer, Integer> inventoryItemIdQuantityUsed) {
1090 
		for (InventoryItem inventoryItem : inventoryItems) {
22859 ashik.ali 1091 
			FofoLineItem fofoLineItem = new FofoLineItem();
1092 
			fofoLineItem.setFofoOrderItemId(fofoOrderItemId);
1093 
			fofoLineItem.setSerialNumber(inventoryItem.getSerialNumber());
1094 
			fofoLineItem.setInventoryItemId(inventoryItem.getId());
1095 
			fofoLineItem.setQuantity(inventoryItemIdQuantityUsed.get(inventoryItem.getId()));
1096 
			fofoLineItemRepository.persist(fofoLineItem);
1097 
		}
1098 
	}
23650 amit.gupta 1099 
 
1100 
	private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId,
1101 
			Map<Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId)
1102 
			throws ProfitMandiBusinessException {
22859 ashik.ali 1103 
		FofoOrderItem fofoOrderItem = new FofoOrderItem();
1104 
		fofoOrderItem.setItemId(customFofoOrderItem.getItemId());
1105 
		fofoOrderItem.setQuantity(customFofoOrderItem.getQuantity());
1106 
		fofoOrderItem.setSellingPrice(customFofoOrderItem.getSellingPrice());
1107 
		fofoOrderItem.setOrderId(fofoOrderId);
1108 
		fofoOrderItem.setDp(customFofoOrderItem.getSellingPrice());
1109 
		fofoOrderItem.setDiscount(customFofoOrderItem.getDiscountAmount());
1110 
		Item item = itemMap.get(customFofoOrderItem.getItemId());
23172 ashik.ali 1111 
		Map<Integer, GstRate> itemIdStateTaxRateMap = null;
1112 
		Map<Integer, Float> itemIdIgstTaxRateMap = null;
23650 amit.gupta 1113 
		if (stateId != null) {
23172 ashik.ali 1114 
			itemIdStateTaxRateMap = Utils.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);
23650 amit.gupta 1115 
		} else {
23172 ashik.ali 1116 
			itemIdIgstTaxRateMap = Utils.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));
1117 
		}
23393 amit.gupta 1118 
		float cost = 0;
23650 amit.gupta 1119 
		for (InventoryItem inventoryItem : inventoryItems) {
1120 
			if (stateId == null) {
23172 ashik.ali 1121 
				fofoOrderItem.setIgstRate(itemIdIgstTaxRateMap.get(inventoryItem.getItemId()));
23650 amit.gupta 1122 
			} else {
23172 ashik.ali 1123 
				fofoOrderItem.setCgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getCgstRate());
1124 
				fofoOrderItem.setSgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getSgstRate());
1125 
			}
23650 amit.gupta 1126 
 
22859 ashik.ali 1127 
			fofoOrderItem.setHsnCode(inventoryItem.getHsnCode());
1128 
			break;
1129 
		}
23650 amit.gupta 1130 
		for (InventoryItem inventoryItem : inventoryItems) {
1131 
			if (inventoryItem.getSerialNumber() != null) {
23393 amit.gupta 1132 
				cost += inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
1133 
			} else {
1134 
				cost += inventoryItem.getUnitPrice();
23382 amit.gupta 1135 
			}
1136 
		}
23650 amit.gupta 1137 
		cost = cost / customFofoOrderItem.getQuantity();
23382 amit.gupta 1138 
		fofoOrderItem.setCost(cost);
22859 ashik.ali 1139 
		fofoOrderItem.setBrand(item.getBrand());
1140 
		fofoOrderItem.setModelName(item.getModelName());
1141 
		fofoOrderItem.setModelNumber(item.getModelNumber());
1142 
		fofoOrderItem.setColor(item.getColor());
1143 
		fofoOrderItemRepository.persist(fofoOrderItem);
1144 
		return fofoOrderItem;
1145 
	}
23650 amit.gupta 1146 
 
1147 
	private void updateCurrentInventorySnapshot(List<CurrentInventorySnapshot> currentInventorySnapshots, int fofoId,
1148 
			int itemId, int quantity) throws ProfitMandiBusinessException {
1149 
		for (CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
1150 
			if (currentInventorySnapshot.getItemId() == itemId && currentInventorySnapshot.getFofoId() == fofoId) {
1151 
				currentInventorySnapshotRepository.updateAvailabilityByItemIdAndFofoId(itemId, fofoId,
1152 
						currentInventorySnapshot.getAvailability() - quantity);
22859 ashik.ali 1153 
			}
1154 
		}
1155 
	}
23650 amit.gupta 1156 
 
1157 
	private void createPaymentOptions(FofoOrder fofoOrder, Set<CustomPaymentOption> customPaymentOptions)
1158 
			throws ProfitMandiBusinessException {
1159 
		for (CustomPaymentOption customPaymentOption : customPaymentOptions) {
1160 
			if (customPaymentOption.getAmount() > 0) {
23546 ashik.ali 1161 
				PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();
23612 amit.gupta 1162 
				paymentOptionTransaction.setReferenceId(fofoOrder.getId());
23546 ashik.ali 1163 
				paymentOptionTransaction.setPaymentOptionId(customPaymentOption.getPaymentOptionId());
1164 
				paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);
1165 
				paymentOptionTransaction.setAmount(customPaymentOption.getAmount());
23612 amit.gupta 1166 
				paymentOptionTransaction.setFofoId(fofoOrder.getFofoId());
23546 ashik.ali 1167 
				paymentOptionTransactionRepository.persist(paymentOptionTransaction);
23371 ashik.ali 1168 
			}
22859 ashik.ali 1169 
		}
1170 
	}
23650 amit.gupta 1171 
 
1172 
	private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId,
1173 
			InvoiceNumberGenerationSequence invoiceNumberGenerationSequence, float totalAmount, int customerAddressId) {
22859 ashik.ali 1174 
		FofoOrder fofoOrder = new FofoOrder();
23369 ashik.ali 1175 
		fofoOrder.setCustomerGstNumber(customerGstNumber);
22859 ashik.ali 1176 
		fofoOrder.setCustomerId(customerId);
1177 
		fofoOrder.setFofoId(fofoId);
23650 amit.gupta 1178 
		fofoOrder.setInvoiceNumber(
1179 
				invoiceNumberGenerationSequence.getPrefix() + "/" + invoiceNumberGenerationSequence.getSequence());
22859 ashik.ali 1180 
		fofoOrder.setTotalAmount(totalAmount);
1181 
		fofoOrder.setCustomerAddressId(customerAddressId);
1182 
		fofoOrderRepository.persist(fofoOrder);
1183 
		return fofoOrder;
1184 
	}
23650 amit.gupta 1185 
 
1186 
	private Customer createAndGetCustomer(CustomCustomer customCustomer) throws ProfitMandiBusinessException {
22859 ashik.ali 1187 
		Customer customer = null;
23650 amit.gupta 1188 
		try {
22859 ashik.ali 1189 
			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
23650 amit.gupta 1190 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
23596 ashik.ali 1191 
			LOGGER.error("Customer not found with mobileNumber [{}]", customCustomer.getMobileNumber());
22859 ashik.ali 1192 
			customer = new Customer();
1193 
		}
23190 ashik.ali 1194 
		customer.setFirstName(customCustomer.getFirstName());
1195 
		customer.setLastName(customCustomer.getLastName());
1196 
		customer.setEmailId(customCustomer.getEmailId());
1197 
		customer.setMobileNumber(customCustomer.getMobileNumber());
1198 
		customerRepository.persist(customer);
22859 ashik.ali 1199 
		return customer;
1200 
	}
23650 amit.gupta 1201 
 
1202 
	private InvoiceNumberGenerationSequence createAndGetInvoiceNumberGenerationSequence(int fofoId,
1203 
			String fofoStoreCode) {
22859 ashik.ali 1204 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
23650 amit.gupta 1205 
		try {
22859 ashik.ali 1206 
			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);
1207 
			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
23650 amit.gupta 1208 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
22859 ashik.ali 1209 
			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
1210 
			invoiceNumberGenerationSequence.setFofoId(fofoId);
23370 ashik.ali 1211 
			invoiceNumberGenerationSequence.setPrefix(fofoStoreCode);
22859 ashik.ali 1212 
			invoiceNumberGenerationSequence.setSequence(1);
1213 
		}
1214 
		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
1215 
		return invoiceNumberGenerationSequence;
1216 
	}
23650 amit.gupta 1217 
 
1218 
	private void validateItemsSerializedNonSerialized(List<Item> items,
1219 
			Map<Integer, CustomFofoOrderItem> customFofoOrderItemMap) throws ProfitMandiBusinessException {
1220 
		List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();
22859 ashik.ali 1221 
		List<Integer> itemIdNonSerializedSerialNumbers = new ArrayList<Integer>();
23650 amit.gupta 1222 
		for (Item i : items) {
22872 ashik.ali 1223 
			CustomFofoOrderItem customFofoOrderItem = customFofoOrderItemMap.get(i.getId());
23650 amit.gupta 1224 
			if (i.getType().equals(ItemType.SERIALIZED)) {
1225 
				if (customFofoOrderItem == null || customFofoOrderItem.getSerialNumberDetails().isEmpty()) {
22872 ashik.ali 1226 
					invalidItemIdSerialNumbers.add(i.getId());
22859 ashik.ali 1227 
				}
23650 amit.gupta 1228 
			} else {
1229 
				Set<String> serialNumbers = this
1230 
						.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());
1231 
				if (customFofoOrderItem == null || !serialNumbers.isEmpty()) {
22872 ashik.ali 1232 
					itemIdNonSerializedSerialNumbers.add(i.getId());
22859 ashik.ali 1233 
				}
1234 
			}
1235 
		}
1236 
 
23650 amit.gupta 1237 
		if (!invalidItemIdSerialNumbers.isEmpty()) {
22859 ashik.ali 1238 
			LOGGER.error("Invalid itemId's serialNumbers for serialized{}", invalidItemIdSerialNumbers);
1239 
			// itemId's are serialized you are saying these are not serialized
23650 amit.gupta 1240 
			throw new ProfitMandiBusinessException("invalidItemIdSerialNumbers", invalidItemIdSerialNumbers,
1241 
					"FFORDR_1013");
22859 ashik.ali 1242 
		}
1243 
 
23650 amit.gupta 1244 
		if (!itemIdNonSerializedSerialNumbers.isEmpty()) {
22859 ashik.ali 1245 
			LOGGER.error("Invalid itemId's serialNumbers for non serialized{}", itemIdNonSerializedSerialNumbers);
1246 
			// itemId's are non serialized you are saying these are serialized
23650 amit.gupta 1247 
			throw new ProfitMandiBusinessException("itemIdNonSerializedSerialNumbers", itemIdNonSerializedSerialNumbers,
1248 
					"FFORDR_1014");
22859 ashik.ali 1249 
		}
1250 
	}
23650 amit.gupta 1251 
 
1252 
	private void validateCurrentInventorySnapshotQuantities(List<CurrentInventorySnapshot> currentInventorySnapshots,
1253 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap) throws ProfitMandiBusinessException {
1254 
		if (itemIdCustomFofoOrderItemMap.keySet().size() != currentInventorySnapshots.size()) {
22859 ashik.ali 1255 
			throw new ProfitMandiBusinessException("quantiiesSize", currentInventorySnapshots.size(), "");
1256 
		}
23650 amit.gupta 1257 
		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); // this is for error
1258 
		LOGGER.info("currentInventorySnapshots " + currentInventorySnapshots);
22872 ashik.ali 1259 
		LOGGER.info("CustomFofoLineItemMap {}", itemIdCustomFofoOrderItemMap);
23650 amit.gupta 1260 
		for (CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
1261 
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoOrderItemMap
1262 
					.get(currentInventorySnapshot.getItemId());
22872 ashik.ali 1263 
			LOGGER.info("customFofoOrderItem {}", customFofoOrderItem);
23650 amit.gupta 1264 
			if (customFofoOrderItem.getQuantity() > currentInventorySnapshot.getAvailability()) {
1265 
				ItemIdQuantityAvailability itemIdQuantityAvailability = new ItemIdQuantityAvailability();
1266 
				itemIdQuantityAvailability.setItemId(customFofoOrderItem.getItemId());
1267 
				Quantity quantity = new Quantity();
1268 
				quantity.setAvailable(currentInventorySnapshot.getAvailability());
1269 
				quantity.setRequested(customFofoOrderItem.getQuantity());
1270 
				itemIdQuantityAvailability.setQuantity(quantity);
1271 
				itemIdQuantityAvailabilities.add(itemIdQuantityAvailability);
1272 
			}
22859 ashik.ali 1273 
		}
1274 
 
23650 amit.gupta 1275 
		if (!itemIdQuantityAvailabilities.isEmpty()) {
22859 ashik.ali 1276 
			// itemIdQuantity request is not valid
23650 amit.gupta 1277 
			LOGGER.error("Requested quantities should not be greater than currently available quantities {}",
1278 
					itemIdQuantityAvailabilities);
1279 
			throw new ProfitMandiBusinessException("itemIdQuantityAvailabilities", itemIdQuantityAvailabilities,
1280 
					"FFORDR_1015");
22859 ashik.ali 1281 
		}
1282 
	}
23650 amit.gupta 1283 
 
1284 
	private int getItemIdFromSerialNumber(Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap,
1285 
			String serialNumber) {
22872 ashik.ali 1286 
		int itemId = 0;
23650 amit.gupta 1287 
		for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoOrderItemMap.entrySet()) {
22872 ashik.ali 1288 
			Set<SerialNumberDetail> serialNumberDetails = entry.getValue().getSerialNumberDetails();
23650 amit.gupta 1289 
			for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
1290 
				if (serialNumberDetail.getSerialNumber().equals(serialNumber)) {
22872 ashik.ali 1291 
					itemId = entry.getKey();
1292 
					break;
1293 
				}
22859 ashik.ali 1294 
			}
1295 
		}
22872 ashik.ali 1296 
		return itemId;
22859 ashik.ali 1297 
	}
23650 amit.gupta 1298 
 
1299 
	private Map<Integer, Item> toItemMap(List<Item> items) {
22955 ashik.ali 1300 
		Function<Item, Integer> itemIdFunction = new Function<Item, Integer>() {
1301 
			@Override
1302 
			public Integer apply(Item item) {
1303 
				return item.getId();
1304 
			}
1305 
		};
1306 
		Function<Item, Item> itemFunction = new Function<Item, Item>() {
1307 
			@Override
1308 
			public Item apply(Item item) {
1309 
				return item;
1310 
			}
1311 
		};
1312 
		return items.stream().collect(Collectors.toMap(itemIdFunction, itemFunction));
22859 ashik.ali 1313 
	}
1314 
 
23650 amit.gupta 1315 
	private void setCustomerAddress(CustomerAddress customerAddress, CustomAddress customAddress) {
22859 ashik.ali 1316 
		customerAddress.setName(customAddress.getName());
1317 
		customerAddress.setLine1(customAddress.getLine1());
1318 
		customerAddress.setLine2(customAddress.getLine2());
1319 
		customerAddress.setLandmark(customAddress.getLandmark());
1320 
		customerAddress.setCity(customAddress.getCity());
1321 
		customerAddress.setPinCode(customAddress.getPinCode());
1322 
		customerAddress.setState(customAddress.getState());
1323 
		customerAddress.setCountry(customAddress.getCountry());
1324 
		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());
1325 
	}
1326 
 
23650 amit.gupta 1327 
	private CustomAddress createCustomAddress(Address address) {
22859 ashik.ali 1328 
		CustomAddress customAddress = new CustomAddress();
1329 
		customAddress.setName(address.getName());
1330 
		customAddress.setLine1(address.getLine1());
1331 
		customAddress.setLine2(address.getLine2());
1332 
		customAddress.setLandmark(address.getLandmark());
1333 
		customAddress.setCity(address.getCity());
1334 
		customAddress.setPinCode(address.getPinCode());
1335 
		customAddress.setState(address.getState());
1336 
		customAddress.setCountry(address.getCountry());
1337 
		customAddress.setPhoneNumber(address.getPhoneNumber());
1338 
		return customAddress;
1339 
	}
1340 
 
23650 amit.gupta 1341 
	private CustomAddress createCustomAddress(CustomerAddress customerAddress) {
22859 ashik.ali 1342 
		CustomAddress customAddress = new CustomAddress();
1343 
		customAddress.setName(customerAddress.getName());
1344 
		customAddress.setLine1(customerAddress.getLine1());
1345 
		customAddress.setLine2(customerAddress.getLine2());
1346 
		customAddress.setLandmark(customerAddress.getLandmark());
1347 
		customAddress.setCity(customerAddress.getCity());
1348 
		customAddress.setPinCode(customerAddress.getPinCode());
1349 
		customAddress.setState(customerAddress.getState());
1350 
		customAddress.setCountry(customerAddress.getCountry());
1351 
		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());
1352 
		return customAddress;
1353 
	}
1354 
 
23650 amit.gupta 1355 
	private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount)
1356 
			throws ProfitMandiBusinessException {
23365 ashik.ali 1357 
		Set<Integer> paymentOptionIds = new HashSet<>();
23650 amit.gupta 1358 
 
22859 ashik.ali 1359 
		float calculatedAmount = 0;
23650 amit.gupta 1360 
		for (CustomPaymentOption customPaymentOption : customPaymentOptions) {
23365 ashik.ali 1361 
			paymentOptionIds.add(customPaymentOption.getPaymentOptionId());
1362 
			calculatedAmount = calculatedAmount + customPaymentOption.getAmount();
22859 ashik.ali 1363 
		}
23650 amit.gupta 1364 
		if (calculatedAmount != totalAmount) {
1365 
			LOGGER.warn("Error occured while validating payment options amount[{}] != TotalAmount [{}]",
1366 
					calculatedAmount, totalAmount);
1367 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_CALCULATED_AMOUNT,
1368 
					calculatedAmount, "FFORDR_1016");
22859 ashik.ali 1369 
		}
23650 amit.gupta 1370 
 
23365 ashik.ali 1371 
		List<Integer> foundPaymentOptionIds = paymentOptionRepository.selectIdsByIds(paymentOptionIds);
23650 amit.gupta 1372 
		if (foundPaymentOptionIds.size() != paymentOptionIds.size()) {
23365 ashik.ali 1373 
			paymentOptionIds.removeAll(foundPaymentOptionIds);
23650 amit.gupta 1374 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_ID, paymentOptionIds,
1375 
					"FFORDR_1017");
23365 ashik.ali 1376 
		}
22859 ashik.ali 1377 
	}
23650 amit.gupta 1378 
 
22925 ashik.ali 1379 
	@Override
1380 
	public List<FofoOrderItem> getByOrderId(int orderId) throws ProfitMandiBusinessException {
1381 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(orderId);
23650 amit.gupta 1382 
		if (!fofoOrderItems.isEmpty()) {
22925 ashik.ali 1383 
			List<FofoOrderItem> newFofoOrderItems = new ArrayList<>();
23650 amit.gupta 1384 
			Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = this
1385 
					.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
22925 ashik.ali 1386 
			Iterator<FofoOrderItem> fofoOrderItemsIterator = fofoOrderItems.iterator();
23650 amit.gupta 1387 
			while (fofoOrderItemsIterator.hasNext()) {
22925 ashik.ali 1388 
				FofoOrderItem fofoOrderItem = fofoOrderItemsIterator.next();
1389 
				fofoOrderItem.setFofoLineItems(fofoOrderItemIdFofoLineItemsMap.get(fofoOrderItem.getId()));
1390 
				newFofoOrderItems.add(fofoOrderItem);
1391 
				fofoOrderItemsIterator.remove();
1392 
			}
1393 
			fofoOrderItems = newFofoOrderItems;
1394 
		}
1395 
		return fofoOrderItems;
1396 
	}
23650 amit.gupta 1397 
 
1398 
	private Set<Integer> toFofoOrderItemIds(List<FofoOrderItem> fofoOrderItems) {
22955 ashik.ali 1399 
		Function<FofoOrderItem, Integer> fofoOrderItemToFofoOrderItemIdFunction = new Function<FofoOrderItem, Integer>() {
1400 
			@Override
1401 
			public Integer apply(FofoOrderItem fofoOrderItem) {
1402 
				return fofoOrderItem.getId();
1403 
			}
1404 
		};
1405 
		return fofoOrderItems.stream().map(fofoOrderItemToFofoOrderItemIdFunction).collect(Collectors.toSet());
22925 ashik.ali 1406 
	}
23650 amit.gupta 1407 
 
1408 
	private Map<Integer, Set<FofoLineItem>> toFofoOrderItemIdFofoLineItems(List<FofoOrderItem> fofoOrderItems) {
22925 ashik.ali 1409 
		Set<Integer> fofoOrderItemIds = this.toFofoOrderItemIds(fofoOrderItems);
1410 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);
1411 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = new HashMap<>();
23650 amit.gupta 1412 
		for (FofoLineItem fofoLineItem : fofoLineItems) {
1413 
			if (!fofoOrderItemIdFofoLineItemsMap.containsKey(fofoLineItem.getFofoOrderItemId())) {
22925 ashik.ali 1414 
				Set<FofoLineItem> fofoLineItems2 = new HashSet<>();
1415 
				fofoLineItems2.add(fofoLineItem);
1416 
				fofoOrderItemIdFofoLineItemsMap.put(fofoLineItem.getFofoOrderItemId(), fofoLineItems2);
23650 amit.gupta 1417 
			} else {
22925 ashik.ali 1418 
				fofoOrderItemIdFofoLineItemsMap.get(fofoLineItem.getFofoOrderItemId()).add(fofoLineItem);
1419 
			}
1420 
		}
1421 
		return fofoOrderItemIdFofoLineItemsMap;
1422 
	}
23650 amit.gupta 1423 
 
23418 ashik.ali 1424 
	@Override
23650 amit.gupta 1425 
	public void updateCustomerDetails(CustomCustomer customCustomer, String invoiceNumber)
1426 
			throws ProfitMandiBusinessException {
23582 ashik.ali 1427 
		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
1428 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
1429 
		customer.setFirstName(customCustomer.getFirstName());
1430 
		customer.setLastName(customCustomer.getLastName());
1431 
		customerRepository.persist(customer);
1432 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
1433 
		this.setCustomerAddress(customerAddress, customCustomer.getAddress());
1434 
		customerAddressRepository.persist(customerAddress);
1435 
	}
23418 ashik.ali 1436 
 
23638 amit.gupta 1437 
	@Override
23655 amit.gupta 1438 
	public CustomerCreditNote badReturn(int fofoId, FoiBadReturnRequest foiBadReturnRequest) throws ProfitMandiBusinessException {
1439 
		FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
23650 amit.gupta 1440 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(foi.getOrderId());
23655 amit.gupta 1441 
		if (fofoOrder.getFofoId() != fofoId) {
23638 amit.gupta 1442 
			throw new ProfitMandiBusinessException("Partner Auth", "", "Invalid Order");
1443 
		}
23655 amit.gupta 1444 
		int billedQty = foi.getQuantity() - customerReturnItemRepository.selectAllByOrderItemId(foi.getId()).size();
1445 
		if(foiBadReturnRequest.getMarkedBadArr().size() > billedQty ) {
1446 
			throw new ProfitMandiBusinessException("Cant bad return more than what is billed", "", "Invalid Quantity");
1447 
		}
23650 amit.gupta 1448 
		List<CustomerReturnItem> customerReturnItems = new ArrayList<>();
23655 amit.gupta 1449 
		for (BadReturnRequest badReturnRequest : foiBadReturnRequest.getMarkedBadArr()) {
23650 amit.gupta 1450 
			CustomerReturnItem customerReturnItem = new CustomerReturnItem();
1451 
			customerReturnItem.setFofoId(fofoId);
23655 amit.gupta 1452 
			customerReturnItem.setFofoOrderItemId(foiBadReturnRequest.getFofoOrderItemId());
1453 
			customerReturnItem.setRemarks(badReturnRequest.getRemarks());
23650 amit.gupta 1454 
			customerReturnItem.setInventoryItemId(badReturnRequest.getInventoryItemId());
1455 
			customerReturnItem.setQuantity(1);
1456 
			customerReturnItem.setType(ReturnType.BAD);
1457 
			//customerReturnItemRepository.persist(customerReturnItem);
1458 
			inventoryService.saleReturnInventoryItem(customerReturnItem);
1459 
			customerReturnItems.add(customerReturnItem);
23638 amit.gupta 1460 
		}
23655 amit.gupta 1461 
		CustomerCreditNote creditNote = generateCreditNote(fofoOrder, customerReturnItems);
1462 
		for (CustomerReturnItem customerReturnItem: customerReturnItems) {
1463 
			purchaseReturnService.returnInventoryItem(fofoId, false, customerReturnItem.getInventoryItemId(), ReturnType.BAD);
1464 
		}
1465 
        return creditNote;
23638 amit.gupta 1466 
	}
1467 
 
23655 amit.gupta 1468 
	private CustomerCreditNote generateCreditNote(FofoOrder fofoOrder, List<CustomerReturnItem> customerReturnItems) throws ProfitMandiBusinessException {
23650 amit.gupta 1469 
 
23638 amit.gupta 1470 
		InvoiceNumberGenerationSequence sequence = invoiceNumberGenerationSequenceRepository
23650 amit.gupta 1471 
				.selectByFofoId(fofoOrder.getFofoId());
1472 
		sequence.setCreditNoteSequence(sequence.getCreditNoteSequence() + 1);
23638 amit.gupta 1473 
		invoiceNumberGenerationSequenceRepository.persist(sequence);
23650 amit.gupta 1474 
 
23655 amit.gupta 1475 
		String creditNoteNumber = sequence.getPrefix() + "/" + sequence.getCreditNoteSequence();
23650 amit.gupta 1476 
		CustomerCreditNote creditNote = new CustomerCreditNote();
1477 
		creditNote.setCreditNoteNumber(creditNoteNumber);
1478 
		creditNote.setFofoId(fofoOrder.getFofoId());
23655 amit.gupta 1479 
		creditNote.setFofoOrderId(fofoOrder.getId());
1480 
		creditNote.setFofoOrderItemId(customerReturnItems.get(0).getFofoOrderItemId());
1481 
		creditNote.setSettlementType(SettlementType.UNSETTLED);
23650 amit.gupta 1482 
		customerCreditNoteRepository.persist(creditNote);
1483 
 
1484 
		for (CustomerReturnItem customerReturnItem : customerReturnItems) {
1485 
			customerReturnItem.setCreditNoteId(creditNote.getId());
1486 
			customerReturnItemRepository.persist(customerReturnItem);
23638 amit.gupta 1487 
		}
23650 amit.gupta 1488 
		//this.returnInventoryItems(inventoryItems, debitNote);
23638 amit.gupta 1489 
 
23655 amit.gupta 1490 
		return creditNote;
23650 amit.gupta 1491 
	}
1492 
 
23655 amit.gupta 1493 
	@Override
1494 
	public CreditNotePdfModel getCreditNotePdfModel(int customerCreditNoteId) throws ProfitMandiBusinessException {
1495 
		CustomerCreditNote creditNote = customerCreditNoteRepository.selectById(customerCreditNoteId);
1496 
		return getCreditNotePdfModel(creditNote);
1497 
	}
1498 
 
1499 
	private CreditNotePdfModel getCreditNotePdfModel(CustomerCreditNote creditNote) throws ProfitMandiBusinessException {
1500 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(creditNote.getFofoOrderId());
1501 
		List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository.selectAllByCreditNoteId(creditNote.getId());
1502 
		CustomCustomer customCustomer = getCustomCustomer(fofoOrder);
1503 
 
1504 
		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
1505 
		CustomRetailer customRetailer = retailerService.getFofoRetailers(Arrays.asList(fofoOrder.getFofoId())).get(fofoOrder.getFofoId());
1506 
 
1507 
		FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(creditNote.getFofoOrderItemId());
1508 
		float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate() + fofoOrderItem.getCgstRate();
1509 
		float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
1510 
		float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
1511 
 
1512 
		CustomOrderItem customFofoOrderItem = new CustomOrderItem();
1513 
		customFofoOrderItem.setAmount(customerReturnItems.size() * (taxableSellingPrice - taxableDiscountPrice));
1514 
		customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "
1515 
				+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
1516 
 
1517 
		if(ItemType.SERIALIZED.equals(itemRepository.selectById(fofoOrderItem.getItemId()).getType())){
1518 
			Set<Integer> inventoryItemIds = customerReturnItems.stream().map(x -> x.getInventoryItemId())
1519 
					.collect(Collectors.toSet());
1520 
			List<String> serialNumbers = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
1521 
					.map(x -> x.getSerialNumber()).collect(Collectors.toList());
1522 
			customFofoOrderItem.setDescription(
1523 
					customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
1524 
		}
1525 
 
1526 
		customFofoOrderItem.setRate(taxableSellingPrice);
1527 
		customFofoOrderItem.setDiscount(taxableDiscountPrice);
1528 
		customFofoOrderItem.setQuantity(customerReturnItems.size());
1529 
		customFofoOrderItem.setNetAmount((fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * customFofoOrderItem.getQuantity());
1530 
 
1531 
		float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
1532 
		float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
1533 
		float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
1534 
		LOGGER.info("fofoOrderItem - {}", fofoOrderItem);
1535 
		customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
1536 
		customFofoOrderItem.setIgstAmount(igstAmount);
1537 
		customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
1538 
		customFofoOrderItem.setCgstAmount(cgstAmount);
1539 
		customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
1540 
		customFofoOrderItem.setSgstAmount(sgstAmount);
1541 
		customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
23721 amit.gupta 1542 
		customFofoOrderItem.setOrderId(1);
23655 amit.gupta 1543 
		customerFofoOrderItems.add(customFofoOrderItem);
1544 
 
23650 amit.gupta 1545 
		PdfModel pdfModel = new PdfModel();
1546 
		pdfModel.setAuther("NSSPL");
23655 amit.gupta 1547 
		pdfModel.setCustomer(customCustomer);
1548 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
1549 
		pdfModel.setInvoiceDate(FormattingUtils.formatDate(fofoOrder.getCreateTimestamp()));
1550 
		pdfModel.setTitle("Credit Note");
1551 
		pdfModel.setRetailer(customRetailer);
1552 
		pdfModel.setTotalAmount(customFofoOrderItem.getNetAmount());
1553 
		pdfModel.setOrderItems(customerFofoOrderItems);
1554 
 
23650 amit.gupta 1555 
		CreditNotePdfModel creditNotePdfModel = new CreditNotePdfModel();
1556 
		creditNotePdfModel.setCreditNoteDate(FormattingUtils.formatDate(creditNote.getCreateTimestamp()));
1557 
		creditNotePdfModel.setCreditNoteNumber(creditNote.getCreditNoteNumber());
1558 
		creditNotePdfModel.setPdfModel(pdfModel);
1559 
		return creditNotePdfModel;
1560 
	}
23638 amit.gupta 1561 
 
22859 ashik.ali 1562 
}