Subversion Repositories SmartDukaan

Rev

Rev 24121 | Rev 24215 | 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 
 
24142 amit.gupta 490 
			LocalDate customerDateOfBirth = LocalDate.from(createOrderRequest.getCustomerDateOfBirth());
23650 amit.gupta 491 
 
492 
			for (Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()) {
493 
				PolicyNumberGenerationSequence policyNumberGenerationSequence = this
494 
						.createPolicyNumberGenerationSequence();
495 
 
496 
				InsurancePolicy insurancePolicy = this.createInsurancePolicy(fofoOrder.getInvoiceNumber(), fofoId,
22859 ashik.ali 497 
						insurancePricesMap.get(entry.getValue()).getDealerPrice(),
23650 amit.gupta 498 
						insuranceSerialNumberSaleAmount.get(entry.getKey()), entry.getValue(), entry.getKey(),
499 
						serialNumberModelName.get(entry.getKey()), serialNumberBrand.get(entry.getKey()),
500 
						policyNumberGenerationSequence.getSequence(), insuranceProvider.getId(), customer,
501 
						customerDateOfBirth, customerAddress);
502 
 
503 
				GadgetCopsInsuranceModel gadgetCopsInsuranceModel = this.createGadgetCopsInsuranceModel(
504 
						serialNumberBrand.get(entry.getKey()), serialNumberModelName.get(entry.getKey()),
505 
						entry.getKey(), customerDateOfBirth, customer, customerAddress, insurancePolicy);
506 
				String walletDescription = "Sale of " + insurancePolicy.getPolicyNumber() + " for "
507 
						+ fofoOrder.getInvoiceNumber();
508 
				walletService.consumeAmountFromWallet(fofoId, insurancePolicy.getId(),
23395 amit.gupta 509 
						WalletReferenceType.DAMAGE_PROTECTION, walletDescription, insurancePolicy.getPurchaseAmount());
23650 amit.gupta 510 
 
511 
				try {
22859 ashik.ali 512 
					InsuranceUtils.submitToGadgetCops(gadgetCopsInsuranceModel);
513 
					insurancePolicy.setPosted(true);
23650 amit.gupta 514 
				} catch (ProfitMandiBusinessException profitMandiBusinessException) {
515 
					LOGGER.info("Unable to submit insurance policy details to {}", insuranceProvider.getName(),
516 
							profitMandiBusinessException);
22859 ashik.ali 517 
				}
518 
				insurancePolicyRepository.persist(insurancePolicy);
519 
			}
520 
		}
23365 ashik.ali 521 
		schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
23650 amit.gupta 522 
 
22859 ashik.ali 523 
		return fofoOrder.getId();
524 
	}
23650 amit.gupta 525 
 
526 
	private Set<String> serialNumberDetailsToSerialNumbers(Set<SerialNumberDetail> serialNumberDetails) {
23377 ashik.ali 527 
		Set<String> serialNumbers = new HashSet<>();
23650 amit.gupta 528 
		for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
529 
			if (serialNumberDetail.getSerialNumber() != null && !serialNumberDetail.getSerialNumber().isEmpty()) {
23377 ashik.ali 530 
				serialNumbers.add(serialNumberDetail.getSerialNumber());
531 
			}
532 
		}
533 
		return serialNumbers;
534 
	}
23650 amit.gupta 535 
 
22859 ashik.ali 536 
	@Override
23596 ashik.ali 537 
	public PdfModel getInvoicePdfModel(int orderId) throws ProfitMandiBusinessException {
538 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);
539 
		return this.getInvoicePdfModel(fofoOrder);
540 
	}
23650 amit.gupta 541 
 
542 
	private PdfModel getInvoicePdfModel(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
543 
 
544 
		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository
545 
				.selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
546 
 
23552 amit.gupta 547 
		List<CustomPaymentOption> paymentOptions = new ArrayList<>();
548 
 
22859 ashik.ali 549 
		PdfModel pdfModel = new PdfModel();
23650 amit.gupta 550 
 
551 
		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
23552 amit.gupta 552 
			CustomPaymentOption cpi = new CustomPaymentOption();
553 
			cpi.setAmount(paymentOptionTransaction.getAmount());
23650 amit.gupta 554 
			cpi.setPaymentOption(
555 
					paymentOptionRepository.selectById(paymentOptionTransaction.getPaymentOptionId()).getName());
23558 amit.gupta 556 
			paymentOptions.add(cpi);
23552 amit.gupta 557 
		}
558 
		pdfModel.setPaymentOptions(paymentOptions);
22859 ashik.ali 559 
		pdfModel.setAuther("profitmandi");
560 
		pdfModel.setTitle("Retailer Invoice");
561 
		pdfModel.setInvoiceDate(fofoOrder.getFormattedDate());
23650 amit.gupta 562 
 
22859 ashik.ali 563 
		// insurance calculation
23650 amit.gupta 564 
		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository
565 
				.selectByRetailerIdInvoiceNumber(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber());
22859 ashik.ali 566 
		Set<CustomInsurancePolicy> customInsurancePolicies = new HashSet<>();
567 
		final float totalInsuranceTaxRate = 18;
23650 amit.gupta 568 
		for (InsurancePolicy insurancePolicy : insurancePolicies) {
22859 ashik.ali 569 
			float taxableInsurancePrice = insurancePolicy.getSaleAmount() / (1 + totalInsuranceTaxRate / 100);
570 
			CustomInsurancePolicy customInsurancePolicy = new CustomInsurancePolicy();
23650 amit.gupta 571 
			customInsurancePolicy.setDescription("Damage Protection Plan for device IMEI #"
572 
					+ insurancePolicy.getSerialNumber() + "\n Certificate No. " + insurancePolicy.getPolicyNumber());
22859 ashik.ali 573 
			customInsurancePolicy.setHsnCode("998716");
574 
			customInsurancePolicy.setRate(taxableInsurancePrice);
575 
			customInsurancePolicy.setIgstRate(18);
23650 amit.gupta 576 
			customInsurancePolicy.setIgstAmount(taxableInsurancePrice * 18 / 100);
22936 amit.gupta 577 
			customInsurancePolicy.setCgstRate(9);
23650 amit.gupta 578 
			customInsurancePolicy.setCgstAmount(taxableInsurancePrice * 9 / 100);
22859 ashik.ali 579 
			customInsurancePolicy.setSgstRate(9);
23650 amit.gupta 580 
			customInsurancePolicy.setSgstAmount(taxableInsurancePrice * 9 / 100);
22859 ashik.ali 581 
			customInsurancePolicy.setNetAmount(insurancePolicy.getSaleAmount());
582 
			customInsurancePolicies.add(customInsurancePolicy);
583 
		}
584 
		pdfModel.setInsurancePolicies(customInsurancePolicies);
23001 amit.gupta 585 
		List<String> tncs = new ArrayList<>();
586 
		tncs.add("I agree that goods received are in good working condition");
587 
		tncs.add("Goods once sold cannot be exchanged or taken back");
588 
		tncs.add("Warranty for the goods received by me is the responsibility of the manufacturer only.");
23650 amit.gupta 589 
		if (pdfModel.getInsurancePolicies() != null && pdfModel.getInsurancePolicies().size() > 0) {
590 
			tncs.add("Damage protection provided is the responisibility of Protection Provider only");
591 
		}
23001 amit.gupta 592 
		pdfModel.setTncs(tncs);
23655 amit.gupta 593 
 
594 
		pdfModel.setCustomer(getCustomCustomer(fofoOrder));
22859 ashik.ali 595 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
596 
		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
23650 amit.gupta 597 
 
23596 ashik.ali 598 
		Retailer retailer = retailerRepository.selectById(fofoOrder.getFofoId());
22859 ashik.ali 599 
		PrivateDealUser privateDealUser = null;
23650 amit.gupta 600 
		try {
22859 ashik.ali 601 
			privateDealUser = privateDealUserRepository.selectById(retailer.getId());
23650 amit.gupta 602 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
22859 ashik.ali 603 
			LOGGER.error("Private Deal User not found : ", profitMandiBusinessException);
604 
		}
23650 amit.gupta 605 
 
22859 ashik.ali 606 
		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));
607 
		CustomRetailer customRetailer = new CustomRetailer();
608 
		customRetailer.setBusinessName(retailer.getName());
609 
		customRetailer.setMobileNumber(user.getMobileNumber());
23650 amit.gupta 610 
		// customRetailer.setTinNumber(retailer.getNumber());
611 
		if (privateDealUser == null) {
22859 ashik.ali 612 
			customRetailer.setGstNumber(null);
23650 amit.gupta 613 
		} else {
614 
			if (null != privateDealUser.getCounterId()) {
22859 ashik.ali 615 
				Counter counter = counterRepository.selectById(privateDealUser.getCounterId());
616 
				customRetailer.setGstNumber(counter.getGstin());
23650 amit.gupta 617 
			} else {
22859 ashik.ali 618 
				customRetailer.setGstNumber(null);
619 
			}
620 
		}
23650 amit.gupta 621 
		Address retailerAddress = addressRepository
622 
				.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));
22859 ashik.ali 623 
		customRetailer.setAddress(this.createCustomAddress(retailerAddress));
624 
		pdfModel.setRetailer(customRetailer);
22925 ashik.ali 625 
		List<FofoOrderItem> fofoOrderItems = this.getByOrderId(fofoOrder.getId());
23650 amit.gupta 626 
 
22859 ashik.ali 627 
		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
23650 amit.gupta 628 
		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {
22859 ashik.ali 629 
			CustomOrderItem customFofoOrderItem = new CustomOrderItem();
23650 amit.gupta 630 
			float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate()
631 
					+ fofoOrderItem.getCgstRate();
22859 ashik.ali 632 
			float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
633 
			float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
23650 amit.gupta 634 
 
22859 ashik.ali 635 
			customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));
23650 amit.gupta 636 
			customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "
637 
					+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
23377 ashik.ali 638 
			Set<String> serialNumbers = this.toSerialNumbers(fofoOrderItem.getFofoLineItems());
23650 amit.gupta 639 
			// LOGGER.info("serialNumbers {}", serialNumbers);
640 
			// LOGGER.info("serialNumbers is empty {}", serialNumbers.isEmpty());
641 
			if (!serialNumbers.isEmpty()) {
642 
				customFofoOrderItem.setDescription(
643 
						customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
23377 ashik.ali 644 
			}
22859 ashik.ali 645 
			customFofoOrderItem.setRate(taxableSellingPrice);
646 
			customFofoOrderItem.setDiscount(taxableDiscountPrice);
647 
			customFofoOrderItem.setQuantity(fofoOrderItem.getQuantity());
23650 amit.gupta 648 
			customFofoOrderItem.setNetAmount(
649 
					(fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * fofoOrderItem.getQuantity());
22859 ashik.ali 650 
			float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
651 
			float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
652 
			float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
653 
			customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
654 
			customFofoOrderItem.setIgstAmount(igstAmount);
655 
			customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
656 
			customFofoOrderItem.setCgstAmount(cgstAmount);
657 
			customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
658 
			customFofoOrderItem.setSgstAmount(sgstAmount);
659 
			customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
660 
			customerFofoOrderItems.add(customFofoOrderItem);
661 
		}
662 
		pdfModel.setOrderItems(customerFofoOrderItems);
663 
		return pdfModel;
23650 amit.gupta 664 
 
22859 ashik.ali 665 
	}
23650 amit.gupta 666 
 
23655 amit.gupta 667 
	private CustomCustomer getCustomCustomer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {
668 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
669 
		CustomCustomer customCustomer = new CustomCustomer();
670 
		customCustomer.setFirstName(customer.getFirstName());
671 
		customCustomer.setLastName(customer.getLastName());
672 
		customCustomer.setEmailId(customer.getEmailId());
673 
		customCustomer.setMobileNumber(customer.getMobileNumber());
674 
		customCustomer.setGstNumber(fofoOrder.getCustomerGstNumber());
675 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
676 
		customCustomer.setAddress(this.createCustomAddress(customerAddress));
677 
		return customCustomer;
678 
	}
679 
 
23596 ashik.ali 680 
	@Override
681 
	public PdfModel getInvoicePdfModel(int fofoId, int orderId) throws ProfitMandiBusinessException {
682 
		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, orderId);
683 
		return this.getInvoicePdfModel(fofoOrder);
684 
	}
23650 amit.gupta 685 
 
22859 ashik.ali 686 
	public String getBillingAddress(CustomerAddress customerAddress) {
687 
		StringBuilder address = new StringBuilder();
688 
		if ((customerAddress.getLine1() != null) && (!customerAddress.getLine1().isEmpty())) {
689 
			address.append(customerAddress.getLine1());
690 
			address.append(", ");
691 
		}
692 
 
693 
		if ((customerAddress.getLine2() != null) && (!customerAddress.getLine2().isEmpty())) {
694 
			address.append(customerAddress.getLine2());
695 
			address.append(", ");
696 
		}
697 
 
698 
		if ((customerAddress.getLandmark() != null) && (!customerAddress.getLandmark().isEmpty())) {
699 
			address.append(customerAddress.getLandmark());
700 
			address.append(", ");
701 
		}
702 
 
703 
		if ((customerAddress.getCity() != null) && (!customerAddress.getCity().isEmpty())) {
704 
			address.append(customerAddress.getCity());
705 
			address.append(", ");
706 
		}
707 
 
708 
		if ((customerAddress.getState() != null) && (!customerAddress.getState().isEmpty())) {
709 
			address.append(customerAddress.getState());
710 
		}
711 
 
712 
		if ((customerAddress.getPinCode() != null) && (!customerAddress.getPinCode().isEmpty())) {
713 
			address.append("- ");
714 
			address.append(customerAddress.getPinCode());
715 
		}
716 
 
717 
		return address.toString();
718 
	}
23650 amit.gupta 719 
 
22859 ashik.ali 720 
	@Override
23650 amit.gupta 721 
	public List<CartFofo> cartCheckout(String cartJson) throws ProfitMandiBusinessException {
722 
		try {
22859 ashik.ali 723 
			JSONObject cartObject = new JSONObject(cartJson);
724 
			Iterator<?> keys = cartObject.keys();
23650 amit.gupta 725 
 
22859 ashik.ali 726 
			Set<Integer> itemIds = new HashSet<>();
727 
			List<CartFofo> cartItems = new ArrayList<CartFofo>();
23650 amit.gupta 728 
 
729 
			while (keys.hasNext()) {
730 
				String key = (String) keys.next();
731 
				if (cartObject.get(key) instanceof JSONObject) {
22859 ashik.ali 732 
					LOGGER.info(cartObject.get(key).toString());
733 
				}
734 
				CartFofo cf = new CartFofo();
735 
				cf.setItemId(cartObject.getJSONObject(key).getInt("itemId"));
736 
				cf.setQuantity(cartObject.getJSONObject(key).getInt("quantity"));
23650 amit.gupta 737 
 
738 
				if (cf.getQuantity() <= 0) {
22859 ashik.ali 739 
					continue;
740 
				}
741 
				cartItems.add(cf);
742 
				itemIds.add(cartObject.getJSONObject(key).getInt("itemId"));
743 
			}
23650 amit.gupta 744 
			Map<Integer, Item> itemMap = new HashMap<Integer, Item>();
745 
			if (itemIds.size() > 0) {
22859 ashik.ali 746 
				List<Item> items = itemRepository.selectByIds(itemIds);
23650 amit.gupta 747 
				for (Item i : items) {
22859 ashik.ali 748 
					itemMap.put(i.getId(), i);
749 
				}
23650 amit.gupta 750 
 
22859 ashik.ali 751 
			}
23650 amit.gupta 752 
			for (CartFofo cf : cartItems) {
22859 ashik.ali 753 
				Item i = itemMap.get(cf.getItemId());
23650 amit.gupta 754 
				if (i == null) {
22859 ashik.ali 755 
					continue;
756 
				}
23650 amit.gupta 757 
				cf.setDisplayName(getValidName(i.getBrand()) + " " + getValidName(i.getModelName()) + " "
758 
						+ getValidName(i.getModelNumber()) + " " + getValidName(i.getColor()).replaceAll("\\s+", " "));
22859 ashik.ali 759 
				cf.setItemType(i.getType());
760 
			}
761 
			return cartItems;
23650 amit.gupta 762 
		} catch (Exception e) {
22859 ashik.ali 763 
			LOGGER.error("Unable to Prepare cart to place order...", e);
22925 ashik.ali 764 
			throw new ProfitMandiBusinessException("cartData", cartJson, "FFORDR_1006");
22859 ashik.ali 765 
		}
766 
	}
23650 amit.gupta 767 
 
23202 ashik.ali 768 
	@Override
23650 amit.gupta 769 
	public Map<String, Object> getSaleHistory(int fofoId, SearchType searchType, String searchValue,
23891 amit.gupta 770 
			LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
23202 ashik.ali 771 
		long countItems = 0;
772 
		List<FofoOrder> fofoOrders = new ArrayList<>();
23650 amit.gupta 773 
 
774 
		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
23973 govind 775 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, null,
776 
					null, offset, limit);
777 
			countItems = fofoOrderRepository.selectCountByCustomerMobileNumber(fofoId, searchValue, null,
778 
					null);
23650 amit.gupta 779 
		} else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
23973 govind 780 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, null,
781 
					null, offset, limit);
782 
			countItems = fofoOrderRepository.selectCountByCustomerName(fofoId, searchValue, null, null);
23650 amit.gupta 783 
		} else if (searchType == SearchType.IMEI && !searchValue.isEmpty()) {
23973 govind 784 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, null,
785 
					null, offset, limit);
786 
			countItems = fofoOrderRepository.selectCountBySerialNumber(fofoId, searchValue, null, null);
23650 amit.gupta 787 
		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
23973 govind 788 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, null, null,
23650 amit.gupta 789 
					offset, limit);
23973 govind 790 
			countItems=fofoOrderRepository.selectCountByItemName(fofoId, searchValue, null, null);
23953 amit.gupta 791 
		} else if (searchType == SearchType.INVOICE_NUMBER && !searchValue.isEmpty()) {
792 
			fofoOrders = Arrays.asList(fofoOrderRepository.selectByFofoIdAndInvoiceNumber(fofoId, searchValue));
793 
			countItems = fofoOrders.size();
23973 govind 794 
		}  else if(searchType == SearchType.DATE_RANGE){
23891 amit.gupta 795 
			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDate, endDate, offset, limit);
796 
			countItems = fofoOrderRepository.selectCountByFofoId(fofoId, startDate, endDate);
23202 ashik.ali 797 
		}
798 
		Map<String, Object> map = new HashMap<>();
23650 amit.gupta 799 
 
23202 ashik.ali 800 
		map.put("saleHistories", fofoOrders);
801 
		map.put("start", offset + 1);
802 
		map.put("size", countItems);
803 
		map.put("searchType", searchType);
23351 ashik.ali 804 
		map.put("searchTypes", SearchType.values());
23891 amit.gupta 805 
		map.put("startDate", startDate);
23973 govind 806 
		map.put("searchValue", searchValue);
23891 amit.gupta 807 
		map.put(ProfitMandiConstants.END_TIME, endDate);
23650 amit.gupta 808 
		if (fofoOrders.size() < limit) {
23202 ashik.ali 809 
			map.put("end", offset + fofoOrders.size());
23650 amit.gupta 810 
		} else {
23202 ashik.ali 811 
			map.put("end", offset + limit);
812 
		}
813 
		return map;
814 
	}
815 
 
816 
	@Override
23650 amit.gupta 817 
	public Map<String, Object> getSaleHistoryPaginated(int fofoId, SearchType searchType, String searchValue,
23891 amit.gupta 818 
			LocalDateTime startDate, LocalDateTime endDate, int offset, int limit) throws ProfitMandiBusinessException {
23202 ashik.ali 819 
		List<FofoOrder> fofoOrders = new ArrayList<>();
23650 amit.gupta 820 
 
821 
		if (searchType == SearchType.CUSTOMER_MOBILE_NUMBER && !searchValue.isEmpty()) {
23891 amit.gupta 822 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerMobileNumber(fofoId, searchValue, startDate,
823 
					endDate, offset, limit);
23650 amit.gupta 824 
		} else if (searchType == SearchType.CUSTOMER_NAME && !searchValue.isEmpty()) {
23891 amit.gupta 825 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndCustomerName(fofoId, searchValue, startDate,
826 
					endDate, offset, limit);
23650 amit.gupta 827 
		} else if (searchType == SearchType.IMEI && !searchValue.isEmpty()) {
23891 amit.gupta 828 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndSerialNumber(fofoId, searchValue, startDate,
829 
					endDate, offset, limit);
23650 amit.gupta 830 
		} else if (searchType == SearchType.ITEM_NAME && !searchValue.isEmpty()) {
23891 amit.gupta 831 
			fofoOrders = fofoOrderRepository.selectByFofoIdAndItemName(fofoId, searchValue, startDate, endDate,
23650 amit.gupta 832 
					offset, limit);
23973 govind 833 
 
834 
		}  else if (searchType == SearchType.DATE_RANGE){
23891 amit.gupta 835 
			fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDate, endDate, offset, limit);
23202 ashik.ali 836 
		}
837 
		Map<String, Object> map = new HashMap<>();
838 
		map.put("saleHistories", fofoOrders);
23973 govind 839 
		map.put("searchType", searchType);
840 
		map.put("searchTypes", SearchType.values());
841 
		map.put("startDate", startDate);
842 
		map.put("searchValue", searchValue);
843 
		map.put(ProfitMandiConstants.END_TIME, endDate);
23202 ashik.ali 844 
		return map;
845 
	}
23650 amit.gupta 846 
 
847 
	private String getFofoStoreCode(int fofoId) throws ProfitMandiBusinessException {
23202 ashik.ali 848 
		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
23370 ashik.ali 849 
		return fofoStore.getCode();
23202 ashik.ali 850 
	}
23650 amit.gupta 851 
 
852 
	private CustomerAddress createCustomerAddress(CustomAddress customAddress, int customerId) {
23191 ashik.ali 853 
		CustomerAddress customerAddress = null;
23650 amit.gupta 854 
		try {
855 
			// CustomAddress customAddress = customCustomer.getAddress();
856 
			customerAddress = customerAddressRepository.selectByParams(customAddress.getName(),
857 
					customAddress.getLine1(), customAddress.getLine2(), customAddress.getLandmark(),
858 
					customAddress.getCity(), customAddress.getPinCode(), customAddress.getState(),
859 
					customAddress.getPhoneNumber(), customAddress.getCountry(), customerId);
860 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
23596 ashik.ali 861 
			LOGGER.warn("Customer address not found with [{}]", customAddress);
23191 ashik.ali 862 
			customerAddress = new CustomerAddress();
863 
			this.setCustomerAddress(customerAddress, customAddress);
864 
			customerAddress.setCustomerId(customerId);
865 
		}
866 
		customerAddressRepository.persist(customerAddress);
867 
		return customerAddress;
868 
	}
23650 amit.gupta 869 
 
870 
	private String getValidName(String name) {
871 
		return name != null ? name : "";
22859 ashik.ali 872 
	}
23650 amit.gupta 873 
 
874 
	private Set<String> toSerialNumbers(Set<FofoLineItem> fofoLineItems) {
23377 ashik.ali 875 
		Set<String> serialNumbers = new HashSet<>();
23650 amit.gupta 876 
		for (FofoLineItem fofoLineItem : fofoLineItems) {
877 
			if (fofoLineItem.getSerialNumber() != null && !fofoLineItem.getSerialNumber().isEmpty()) {
23377 ashik.ali 878 
				serialNumbers.add(fofoLineItem.getSerialNumber());
22955 ashik.ali 879 
			}
23377 ashik.ali 880 
		}
881 
		return serialNumbers;
22859 ashik.ali 882 
	}
23650 amit.gupta 883 
 
884 
	private PolicyNumberGenerationSequence createPolicyNumberGenerationSequence() {
22859 ashik.ali 885 
		PolicyNumberGenerationSequence policyNumberGenerationSequence = null;
23650 amit.gupta 886 
		try {
22859 ashik.ali 887 
			policyNumberGenerationSequence = policyNumberGenerationSequenceRepository.select();
888 
			policyNumberGenerationSequence.setSequence(policyNumberGenerationSequence.getSequence() + 1);
889 
			policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
23650 amit.gupta 890 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
22859 ashik.ali 891 
			policyNumberGenerationSequence = new PolicyNumberGenerationSequence();
892 
			policyNumberGenerationSequence.setSequence(1);
893 
			policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
894 
		}
895 
		return policyNumberGenerationSequence;
896 
	}
23650 amit.gupta 897 
 
898 
	private GadgetCopsInsuranceModel createGadgetCopsInsuranceModel(String brand, String modelName, String serialNumber,
899 
			LocalDate customerDateOfBirth, Customer customer, CustomerAddress customerAddress,
900 
			InsurancePolicy insurancePolicy) {
22859 ashik.ali 901 
		GadgetCopsInsuranceModel gadgetCopsInsuranceModel = new GadgetCopsInsuranceModel();
902 
		gadgetCopsInsuranceModel.setBrand(brand);
903 
		gadgetCopsInsuranceModel.setModelName(modelName);
904 
		gadgetCopsInsuranceModel.setSerialNumber(serialNumber);
905 
		gadgetCopsInsuranceModel.setCustomerFirstName(customer.getFirstName());
906 
		gadgetCopsInsuranceModel.setCustomerLastName(customer.getLastName());
907 
		gadgetCopsInsuranceModel.setCustomerDateOfBirth(customerDateOfBirth);
908 
		gadgetCopsInsuranceModel.setCustomerMobileNumber(customer.getMobileNumber());
909 
		gadgetCopsInsuranceModel.setCustomerEmailId(customer.getEmailId());
910 
		gadgetCopsInsuranceModel.setCustomerAddress1(customerAddress.getLine1());
911 
		gadgetCopsInsuranceModel.setCustomerAddress2(customerAddress.getLine2());
912 
		gadgetCopsInsuranceModel.setCustomerCity(customerAddress.getCity());
913 
		gadgetCopsInsuranceModel.setCustomerPinCode(customerAddress.getPinCode());
914 
		gadgetCopsInsuranceModel.setCustomerState(customerAddress.getState());
915 
		gadgetCopsInsuranceModel.setPrice(insurancePolicy.getSellingPrice());
916 
		gadgetCopsInsuranceModel.setInvoiceNumber(insurancePolicy.getInvoiceNumber());
917 
		gadgetCopsInsuranceModel.setPolicyNumber(insurancePolicy.getPolicyNumber());
918 
		return gadgetCopsInsuranceModel;
919 
	}
23650 amit.gupta 920 
 
921 
	private InsurancePolicy createInsurancePolicy(String invoiceNumber, int retailerId, float purchaseAmount,
922 
			float saleAmount, float sellingPrice, String serialNumber, String modelName, String brand,
923 
			int policyNumberGenerationSequence, int insuranceProviderId, Customer customer,
924 
			LocalDate customerDateOfBirth, CustomerAddress customerAddress) {
22859 ashik.ali 925 
		InsurancePolicy insurancePolicy = new InsurancePolicy();
23394 amit.gupta 926 
		insurancePolicy.setInvoiceNumber(invoiceNumber);
22859 ashik.ali 927 
		insurancePolicy.setRetailerId(retailerId);
928 
		insurancePolicy.setPurchaseAmount(purchaseAmount);
929 
		insurancePolicy.setSaleAmount(saleAmount);
930 
		insurancePolicy.setSellingPrice(sellingPrice);
931 
		insurancePolicy.setSerialNumber(serialNumber);
932 
		insurancePolicy.setModelName(modelName);
933 
		insurancePolicy.setBrand(brand);
23650 amit.gupta 934 
		insurancePolicy.setPolicyNumber(StringUtils.generatePolicyNumber(ProfitMandiConstants.POLICY_NUMBER_PREFIX,
935 
				policyNumberGenerationSequence));
22859 ashik.ali 936 
		insurancePolicy.setProviderId(insuranceProviderId);
937 
		insurancePolicy.setCustomerFirstName(customer.getFirstName());
938 
		insurancePolicy.setCustomerLastName(customer.getLastName());
939 
		insurancePolicy.setCustomerMobileNumber(customer.getMobileNumber());
940 
		insurancePolicy.setCustomerEmailId(customer.getEmailId());
941 
		insurancePolicy.setCustomerDateOfBirth(customerDateOfBirth);
942 
		insurancePolicy.setCustomerAddress1(customerAddress.getLine1());
943 
		insurancePolicy.setCustomerAddress2(customerAddress.getLine2());
944 
		insurancePolicy.setCustomerCity(customerAddress.getCity());
945 
		insurancePolicy.setCustomerPinCode(customerAddress.getPinCode());
946 
		insurancePolicy.setCustomerState(customerAddress.getState());
947 
		return insurancePolicy;
948 
	}
23650 amit.gupta 949 
 
950 
	private void validateInsuranceMargin(Map<String, Float> insuranceSerialNumberItemPrice,
951 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap, Map<Integer, PriceModel> itemIdMopPriceMap,
952 
			Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap, Map<String, Float> insuranceSerialNumberSaleAmount)
953 
			throws ProfitMandiBusinessException {
22859 ashik.ali 954 
		Map<Float, Float> invalidInsuranceMarginAmount = new HashMap<>();
23650 amit.gupta 955 
		for (Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()) {
22872 ashik.ali 956 
			int itemId = this.getItemIdFromSerialNumber(itemIdCustomFofoOrderItemMap, entry.getKey());
22859 ashik.ali 957 
			float itemPurchasePrice = itemIdMopPriceMap.get(itemId).getPrice();
958 
			float itemSellingPrice = entry.getValue();
959 
			float itemMargin = itemSellingPrice - itemPurchasePrice;
960 
			float insurancePurchasePrice = insurancePricesMap.get(entry.getValue()).getDealerPrice();
961 
			float insuranceSellingPrice = insuranceSerialNumberSaleAmount.get(entry.getKey());
962 
			float insuranceMargin = insuranceSellingPrice - insurancePurchasePrice;
23650 amit.gupta 963 
			if (insuranceMargin < (itemMargin * 30 / 100)) {
22859 ashik.ali 964 
				invalidInsuranceMarginAmount.put(insuranceMargin, (itemMargin * 30 / 100));
965 
			}
966 
		}
23650 amit.gupta 967 
		if (!invalidInsuranceMarginAmount.isEmpty()) {
968 
			LOGGER.error(
969 
					"insurance marging should be greater than equal to item profit margin insuranceMarginItemIdMargin {}",
970 
					invalidInsuranceMarginAmount);
971 
			throw new ProfitMandiBusinessException("invalidInsuranceMarginAmount", invalidInsuranceMarginAmount,
972 
					"FFORDR_1007");
22859 ashik.ali 973 
		}
974 
	}
23650 amit.gupta 975 
 
976 
	private void validateInsuranceAmount(Map<String, Float> insuranceSerialNumberItemPrice,
977 
			Map<String, Float> insuranceSerialNumberSaleAmount, Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap)
978 
			throws ProfitMandiBusinessException {
22859 ashik.ali 979 
		Map<Float, Float> invalidInsurancePurchaseSaleAmount = new HashMap<>();
980 
		Map<Float, Float> invalidInsuranceSalePurchaseAmount = new HashMap<>();
23650 amit.gupta 981 
		for (Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()) {
982 
			if (insuranceSerialNumberSaleAmount.get(entry.getKey()) < insurancePricesMap.get(entry.getValue())
983 
					.getDealerPrice()) {
984 
				invalidInsurancePurchaseSaleAmount.put(insurancePricesMap.get(entry.getValue()).getDealerPrice(),
985 
						insuranceSerialNumberSaleAmount.get(entry.getKey()));
22859 ashik.ali 986 
			}
23650 amit.gupta 987 
 
988 
			if (insuranceSerialNumberSaleAmount.get(entry.getKey()) > insurancePricesMap.get(entry.getValue())
989 
					.getSellingPrice()) {
990 
				invalidInsuranceSalePurchaseAmount.put(insuranceSerialNumberSaleAmount.get(entry.getKey()),
991 
						insurancePricesMap.get(entry.getValue()).getDealerPrice());
22859 ashik.ali 992 
			}
993 
		}
23650 amit.gupta 994 
 
22859 ashik.ali 995 
		// insurance sale amount can not be lesser than insurance purchase amount
23650 amit.gupta 996 
		if (!invalidInsurancePurchaseSaleAmount.isEmpty()) {
997 
			LOGGER.error(
998 
					"Invalid Insurance prices [{}], insurance sale amount can not be lesser than insurance purchase amount",
999 
					invalidInsurancePurchaseSaleAmount);
1000 
			throw new ProfitMandiBusinessException("invalidInsurancePurchaseSaleAmount",
1001 
					invalidInsurancePurchaseSaleAmount, "FFORDR_1008");
22859 ashik.ali 1002 
		}
23650 amit.gupta 1003 
 
1004 
		if (!invalidInsuranceSalePurchaseAmount.isEmpty()) {
1005 
			LOGGER.error(
1006 
					"Invalid Insurance prices [{}], insurance sale amount can not be greater than than insurance max amount",
1007 
					invalidInsuranceSalePurchaseAmount);
1008 
			throw new ProfitMandiBusinessException("invalidInsuranceSalePurchaseAmount",
1009 
					invalidInsuranceSalePurchaseAmount, "FFORDR_1009");
22859 ashik.ali 1010 
		}
1011 
	}
23823 amit.gupta 1012 
	private void validateDpPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
1013 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
1014 
		for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoLineItemMap.entrySet()) {
1015 
			int itemId = entry.getKey();
1016 
			CustomFofoOrderItem customFofoOrderItem = entry.getValue();
1017 
			PriceModel priceModel = itemIdMopPriceMap.get(itemId);
1018 
			if(customFofoOrderItem.getSerialNumberDetails().size() > 0) {
23857 amit.gupta 1019 
				if(priceModel.getPrice() > customFofoOrderItem.getSellingPrice()) {
23823 amit.gupta 1020 
					throw new ProfitMandiBusinessException("Selling Price", itemRepository.selectById(itemId).getItemDescription(), "FFORDR_1010");
1021 
				}
1022 
			} else {
23857 amit.gupta 1023 
				if(priceModel.getPurchasePrice() > customFofoOrderItem.getSellingPrice()) {
23823 amit.gupta 1024 
					throw new ProfitMandiBusinessException("Selling Price", itemRepository.selectById(itemId).getItemDescription(), "Selling Price should not be less than DP");
1025 
				}
1026 
			}
1027 
		}
1028 
	}
23650 amit.gupta 1029 
	private void validateMopPrice(Map<Integer, PriceModel> itemIdMopPriceMap,
1030 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoLineItemMap) throws ProfitMandiBusinessException {
22859 ashik.ali 1031 
		Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
1032 
		Map<Integer, Float> invalidDiscountAmountMap = new HashMap<>();
23650 amit.gupta 1033 
		for (Map.Entry<Integer, PriceModel> entry : itemIdMopPriceMap.entrySet()) {
22872 ashik.ali 1034 
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoLineItemMap.get(entry.getKey());
23650 amit.gupta 1035 
			if (entry.getValue().getPrice() < Float.MAX_VALUE
1036 
					&& customFofoOrderItem.getSellingPrice() < entry.getValue().getPrice()) {
22872 ashik.ali 1037 
				invalidMopItemIdPriceMap.put(entry.getKey(), customFofoOrderItem.getSellingPrice());
22859 ashik.ali 1038 
			}
23650 amit.gupta 1039 
			if (entry.getValue().isMop()
1040 
					&& customFofoOrderItem.getDiscountAmount() > entry.getValue().getMaxDiscountAmount()) {
22872 ashik.ali 1041 
				invalidDiscountAmountMap.put(entry.getKey(), customFofoOrderItem.getDiscountAmount());
1042 
			}
22859 ashik.ali 1043 
		}
23650 amit.gupta 1044 
 
1045 
		if (!invalidMopItemIdPriceMap.isEmpty()) {
1046 
			LOGGER.error("Invalid itemIds selling prices{} should be greater than mop prices {}",
1047 
					invalidMopItemIdPriceMap, itemIdMopPriceMap);
22925 ashik.ali 1048 
			throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidMopItemIdPriceMap, "FFORDR_1010");
22859 ashik.ali 1049 
		}
23650 amit.gupta 1050 
 
23857 amit.gupta 1051 
		if (!invalidDiscountAmountMap.isEmpty()) {
23650 amit.gupta 1052 
			LOGGER.error("Invalid itemIds discount amounts {} should be less than maxDiscount prices {}",
1053 
					invalidDiscountAmountMap, itemIdMopPriceMap);
22925 ashik.ali 1054 
			throw new ProfitMandiBusinessException("invalidMopItemIdPrice", invalidDiscountAmountMap, "FFORDR_1011");
22859 ashik.ali 1055 
		}
1056 
	}
23650 amit.gupta 1057 
 
1058 
	private void updateInventoryItemsAndScanRecord(Set<InventoryItem> inventoryItems, int fofoId,
1059 
			Map<Integer, Integer> inventoryItemQuantityUsed) {
1060 
		for (InventoryItem inventoryItem : inventoryItems) {
22859 ashik.ali 1061 
			inventoryItem.setLastScanType(ScanType.SALE);
1062 
			inventoryItemRepository.persist(inventoryItem);
1063 
			ScanRecord scanRecord = new ScanRecord();
1064 
			scanRecord.setInventoryItemId(inventoryItem.getId());
1065 
			scanRecord.setFofoId(fofoId);
23650 amit.gupta 1066 
			// correct this
22859 ashik.ali 1067 
			scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));
1068 
			scanRecord.setType(ScanType.SALE);
1069 
			scanRecordRepository.persist(scanRecord);
23566 amit.gupta 1070 
			purchaseReturnItemRepository.deleteById(inventoryItem.getId());
23650 amit.gupta 1071 
 
22859 ashik.ali 1072 
		}
1073 
	}
23650 amit.gupta 1074 
 
1075 
	private void createFofoLineItem(int fofoOrderItemId, Set<InventoryItem> inventoryItems,
1076 
			Map<Integer, Integer> inventoryItemIdQuantityUsed) {
1077 
		for (InventoryItem inventoryItem : inventoryItems) {
22859 ashik.ali 1078 
			FofoLineItem fofoLineItem = new FofoLineItem();
1079 
			fofoLineItem.setFofoOrderItemId(fofoOrderItemId);
1080 
			fofoLineItem.setSerialNumber(inventoryItem.getSerialNumber());
1081 
			fofoLineItem.setInventoryItemId(inventoryItem.getId());
1082 
			fofoLineItem.setQuantity(inventoryItemIdQuantityUsed.get(inventoryItem.getId()));
1083 
			fofoLineItemRepository.persist(fofoLineItem);
1084 
		}
1085 
	}
23650 amit.gupta 1086 
 
1087 
	private FofoOrderItem createAndGetFofoOrderItem(CustomFofoOrderItem customFofoOrderItem, int fofoOrderId,
1088 
			Map<Integer, Item> itemMap, Set<InventoryItem> inventoryItems, Integer stateId)
1089 
			throws ProfitMandiBusinessException {
22859 ashik.ali 1090 
		FofoOrderItem fofoOrderItem = new FofoOrderItem();
1091 
		fofoOrderItem.setItemId(customFofoOrderItem.getItemId());
1092 
		fofoOrderItem.setQuantity(customFofoOrderItem.getQuantity());
1093 
		fofoOrderItem.setSellingPrice(customFofoOrderItem.getSellingPrice());
1094 
		fofoOrderItem.setOrderId(fofoOrderId);
1095 
		fofoOrderItem.setDp(customFofoOrderItem.getSellingPrice());
1096 
		fofoOrderItem.setDiscount(customFofoOrderItem.getDiscountAmount());
1097 
		Item item = itemMap.get(customFofoOrderItem.getItemId());
23172 ashik.ali 1098 
		Map<Integer, GstRate> itemIdStateTaxRateMap = null;
1099 
		Map<Integer, Float> itemIdIgstTaxRateMap = null;
23650 amit.gupta 1100 
		if (stateId != null) {
23172 ashik.ali 1101 
			itemIdStateTaxRateMap = Utils.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);
23650 amit.gupta 1102 
		} else {
23172 ashik.ali 1103 
			itemIdIgstTaxRateMap = Utils.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));
1104 
		}
23393 amit.gupta 1105 
		float cost = 0;
23650 amit.gupta 1106 
		for (InventoryItem inventoryItem : inventoryItems) {
1107 
			if (stateId == null) {
23172 ashik.ali 1108 
				fofoOrderItem.setIgstRate(itemIdIgstTaxRateMap.get(inventoryItem.getItemId()));
23650 amit.gupta 1109 
			} else {
23172 ashik.ali 1110 
				fofoOrderItem.setCgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getCgstRate());
1111 
				fofoOrderItem.setSgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getSgstRate());
1112 
			}
23650 amit.gupta 1113 
 
22859 ashik.ali 1114 
			fofoOrderItem.setHsnCode(inventoryItem.getHsnCode());
1115 
			break;
1116 
		}
23650 amit.gupta 1117 
		for (InventoryItem inventoryItem : inventoryItems) {
1118 
			if (inventoryItem.getSerialNumber() != null) {
23393 amit.gupta 1119 
				cost += inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();
1120 
			} else {
1121 
				cost += inventoryItem.getUnitPrice();
23382 amit.gupta 1122 
			}
1123 
		}
23650 amit.gupta 1124 
		cost = cost / customFofoOrderItem.getQuantity();
23382 amit.gupta 1125 
		fofoOrderItem.setCost(cost);
22859 ashik.ali 1126 
		fofoOrderItem.setBrand(item.getBrand());
1127 
		fofoOrderItem.setModelName(item.getModelName());
1128 
		fofoOrderItem.setModelNumber(item.getModelNumber());
1129 
		fofoOrderItem.setColor(item.getColor());
1130 
		fofoOrderItemRepository.persist(fofoOrderItem);
1131 
		return fofoOrderItem;
1132 
	}
23650 amit.gupta 1133 
 
1134 
	private void updateCurrentInventorySnapshot(List<CurrentInventorySnapshot> currentInventorySnapshots, int fofoId,
1135 
			int itemId, int quantity) throws ProfitMandiBusinessException {
1136 
		for (CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
1137 
			if (currentInventorySnapshot.getItemId() == itemId && currentInventorySnapshot.getFofoId() == fofoId) {
1138 
				currentInventorySnapshotRepository.updateAvailabilityByItemIdAndFofoId(itemId, fofoId,
1139 
						currentInventorySnapshot.getAvailability() - quantity);
22859 ashik.ali 1140 
			}
1141 
		}
1142 
	}
23650 amit.gupta 1143 
 
1144 
	private void createPaymentOptions(FofoOrder fofoOrder, Set<CustomPaymentOption> customPaymentOptions)
1145 
			throws ProfitMandiBusinessException {
1146 
		for (CustomPaymentOption customPaymentOption : customPaymentOptions) {
1147 
			if (customPaymentOption.getAmount() > 0) {
23546 ashik.ali 1148 
				PaymentOptionTransaction paymentOptionTransaction = new PaymentOptionTransaction();
23612 amit.gupta 1149 
				paymentOptionTransaction.setReferenceId(fofoOrder.getId());
23546 ashik.ali 1150 
				paymentOptionTransaction.setPaymentOptionId(customPaymentOption.getPaymentOptionId());
1151 
				paymentOptionTransaction.setReferenceType(PaymentOptionReferenceType.ORDER);
1152 
				paymentOptionTransaction.setAmount(customPaymentOption.getAmount());
23612 amit.gupta 1153 
				paymentOptionTransaction.setFofoId(fofoOrder.getFofoId());
23546 ashik.ali 1154 
				paymentOptionTransactionRepository.persist(paymentOptionTransaction);
23371 ashik.ali 1155 
			}
22859 ashik.ali 1156 
		}
1157 
	}
23650 amit.gupta 1158 
 
1159 
	private FofoOrder createAndGetFofoOrder(int customerId, String customerGstNumber, int fofoId,
1160 
			InvoiceNumberGenerationSequence invoiceNumberGenerationSequence, float totalAmount, int customerAddressId) {
22859 ashik.ali 1161 
		FofoOrder fofoOrder = new FofoOrder();
23369 ashik.ali 1162 
		fofoOrder.setCustomerGstNumber(customerGstNumber);
22859 ashik.ali 1163 
		fofoOrder.setCustomerId(customerId);
1164 
		fofoOrder.setFofoId(fofoId);
23650 amit.gupta 1165 
		fofoOrder.setInvoiceNumber(
1166 
				invoiceNumberGenerationSequence.getPrefix() + "/" + invoiceNumberGenerationSequence.getSequence());
22859 ashik.ali 1167 
		fofoOrder.setTotalAmount(totalAmount);
1168 
		fofoOrder.setCustomerAddressId(customerAddressId);
1169 
		fofoOrderRepository.persist(fofoOrder);
1170 
		return fofoOrder;
1171 
	}
23650 amit.gupta 1172 
 
1173 
	private Customer createAndGetCustomer(CustomCustomer customCustomer) throws ProfitMandiBusinessException {
22859 ashik.ali 1174 
		Customer customer = null;
23650 amit.gupta 1175 
		try {
22859 ashik.ali 1176 
			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
23650 amit.gupta 1177 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
23596 ashik.ali 1178 
			LOGGER.error("Customer not found with mobileNumber [{}]", customCustomer.getMobileNumber());
22859 ashik.ali 1179 
			customer = new Customer();
1180 
		}
23190 ashik.ali 1181 
		customer.setFirstName(customCustomer.getFirstName());
1182 
		customer.setLastName(customCustomer.getLastName());
1183 
		customer.setEmailId(customCustomer.getEmailId());
1184 
		customer.setMobileNumber(customCustomer.getMobileNumber());
1185 
		customerRepository.persist(customer);
22859 ashik.ali 1186 
		return customer;
1187 
	}
23650 amit.gupta 1188 
 
1189 
	private InvoiceNumberGenerationSequence createAndGetInvoiceNumberGenerationSequence(int fofoId,
1190 
			String fofoStoreCode) {
22859 ashik.ali 1191 
		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
23650 amit.gupta 1192 
		try {
22859 ashik.ali 1193 
			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);
1194 
			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
23650 amit.gupta 1195 
		} catch (ProfitMandiBusinessException profitMandiBusinessException) {
22859 ashik.ali 1196 
			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
1197 
			invoiceNumberGenerationSequence.setFofoId(fofoId);
23370 ashik.ali 1198 
			invoiceNumberGenerationSequence.setPrefix(fofoStoreCode);
22859 ashik.ali 1199 
			invoiceNumberGenerationSequence.setSequence(1);
1200 
		}
1201 
		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
1202 
		return invoiceNumberGenerationSequence;
1203 
	}
23650 amit.gupta 1204 
 
1205 
	private void validateItemsSerializedNonSerialized(List<Item> items,
1206 
			Map<Integer, CustomFofoOrderItem> customFofoOrderItemMap) throws ProfitMandiBusinessException {
1207 
		List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();
22859 ashik.ali 1208 
		List<Integer> itemIdNonSerializedSerialNumbers = new ArrayList<Integer>();
23650 amit.gupta 1209 
		for (Item i : items) {
22872 ashik.ali 1210 
			CustomFofoOrderItem customFofoOrderItem = customFofoOrderItemMap.get(i.getId());
23650 amit.gupta 1211 
			if (i.getType().equals(ItemType.SERIALIZED)) {
1212 
				if (customFofoOrderItem == null || customFofoOrderItem.getSerialNumberDetails().isEmpty()) {
22872 ashik.ali 1213 
					invalidItemIdSerialNumbers.add(i.getId());
22859 ashik.ali 1214 
				}
23650 amit.gupta 1215 
			} else {
1216 
				Set<String> serialNumbers = this
1217 
						.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());
1218 
				if (customFofoOrderItem == null || !serialNumbers.isEmpty()) {
22872 ashik.ali 1219 
					itemIdNonSerializedSerialNumbers.add(i.getId());
22859 ashik.ali 1220 
				}
1221 
			}
1222 
		}
1223 
 
23650 amit.gupta 1224 
		if (!invalidItemIdSerialNumbers.isEmpty()) {
22859 ashik.ali 1225 
			LOGGER.error("Invalid itemId's serialNumbers for serialized{}", invalidItemIdSerialNumbers);
1226 
			// itemId's are serialized you are saying these are not serialized
23650 amit.gupta 1227 
			throw new ProfitMandiBusinessException("invalidItemIdSerialNumbers", invalidItemIdSerialNumbers,
1228 
					"FFORDR_1013");
22859 ashik.ali 1229 
		}
1230 
 
23650 amit.gupta 1231 
		if (!itemIdNonSerializedSerialNumbers.isEmpty()) {
22859 ashik.ali 1232 
			LOGGER.error("Invalid itemId's serialNumbers for non serialized{}", itemIdNonSerializedSerialNumbers);
1233 
			// itemId's are non serialized you are saying these are serialized
23650 amit.gupta 1234 
			throw new ProfitMandiBusinessException("itemIdNonSerializedSerialNumbers", itemIdNonSerializedSerialNumbers,
1235 
					"FFORDR_1014");
22859 ashik.ali 1236 
		}
1237 
	}
23650 amit.gupta 1238 
 
1239 
	private void validateCurrentInventorySnapshotQuantities(List<CurrentInventorySnapshot> currentInventorySnapshots,
1240 
			Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap) throws ProfitMandiBusinessException {
1241 
		if (itemIdCustomFofoOrderItemMap.keySet().size() != currentInventorySnapshots.size()) {
22859 ashik.ali 1242 
			throw new ProfitMandiBusinessException("quantiiesSize", currentInventorySnapshots.size(), "");
1243 
		}
23650 amit.gupta 1244 
		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); // this is for error
1245 
		LOGGER.info("currentInventorySnapshots " + currentInventorySnapshots);
22872 ashik.ali 1246 
		LOGGER.info("CustomFofoLineItemMap {}", itemIdCustomFofoOrderItemMap);
23650 amit.gupta 1247 
		for (CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots) {
1248 
			CustomFofoOrderItem customFofoOrderItem = itemIdCustomFofoOrderItemMap
1249 
					.get(currentInventorySnapshot.getItemId());
22872 ashik.ali 1250 
			LOGGER.info("customFofoOrderItem {}", customFofoOrderItem);
23650 amit.gupta 1251 
			if (customFofoOrderItem.getQuantity() > currentInventorySnapshot.getAvailability()) {
1252 
				ItemIdQuantityAvailability itemIdQuantityAvailability = new ItemIdQuantityAvailability();
1253 
				itemIdQuantityAvailability.setItemId(customFofoOrderItem.getItemId());
1254 
				Quantity quantity = new Quantity();
1255 
				quantity.setAvailable(currentInventorySnapshot.getAvailability());
1256 
				quantity.setRequested(customFofoOrderItem.getQuantity());
1257 
				itemIdQuantityAvailability.setQuantity(quantity);
1258 
				itemIdQuantityAvailabilities.add(itemIdQuantityAvailability);
1259 
			}
22859 ashik.ali 1260 
		}
1261 
 
23650 amit.gupta 1262 
		if (!itemIdQuantityAvailabilities.isEmpty()) {
22859 ashik.ali 1263 
			// itemIdQuantity request is not valid
23650 amit.gupta 1264 
			LOGGER.error("Requested quantities should not be greater than currently available quantities {}",
1265 
					itemIdQuantityAvailabilities);
1266 
			throw new ProfitMandiBusinessException("itemIdQuantityAvailabilities", itemIdQuantityAvailabilities,
1267 
					"FFORDR_1015");
22859 ashik.ali 1268 
		}
1269 
	}
23650 amit.gupta 1270 
 
1271 
	private int getItemIdFromSerialNumber(Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap,
1272 
			String serialNumber) {
22872 ashik.ali 1273 
		int itemId = 0;
23650 amit.gupta 1274 
		for (Map.Entry<Integer, CustomFofoOrderItem> entry : itemIdCustomFofoOrderItemMap.entrySet()) {
22872 ashik.ali 1275 
			Set<SerialNumberDetail> serialNumberDetails = entry.getValue().getSerialNumberDetails();
23650 amit.gupta 1276 
			for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {
1277 
				if (serialNumberDetail.getSerialNumber().equals(serialNumber)) {
22872 ashik.ali 1278 
					itemId = entry.getKey();
1279 
					break;
1280 
				}
22859 ashik.ali 1281 
			}
1282 
		}
22872 ashik.ali 1283 
		return itemId;
22859 ashik.ali 1284 
	}
23650 amit.gupta 1285 
 
1286 
	private Map<Integer, Item> toItemMap(List<Item> items) {
22955 ashik.ali 1287 
		Function<Item, Integer> itemIdFunction = new Function<Item, Integer>() {
1288 
			@Override
1289 
			public Integer apply(Item item) {
1290 
				return item.getId();
1291 
			}
1292 
		};
1293 
		Function<Item, Item> itemFunction = new Function<Item, Item>() {
1294 
			@Override
1295 
			public Item apply(Item item) {
1296 
				return item;
1297 
			}
1298 
		};
1299 
		return items.stream().collect(Collectors.toMap(itemIdFunction, itemFunction));
22859 ashik.ali 1300 
	}
1301 
 
23650 amit.gupta 1302 
	private void setCustomerAddress(CustomerAddress customerAddress, CustomAddress customAddress) {
22859 ashik.ali 1303 
		customerAddress.setName(customAddress.getName());
1304 
		customerAddress.setLine1(customAddress.getLine1());
1305 
		customerAddress.setLine2(customAddress.getLine2());
1306 
		customerAddress.setLandmark(customAddress.getLandmark());
1307 
		customerAddress.setCity(customAddress.getCity());
1308 
		customerAddress.setPinCode(customAddress.getPinCode());
1309 
		customerAddress.setState(customAddress.getState());
1310 
		customerAddress.setCountry(customAddress.getCountry());
1311 
		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());
1312 
	}
1313 
 
23650 amit.gupta 1314 
	private CustomAddress createCustomAddress(Address address) {
22859 ashik.ali 1315 
		CustomAddress customAddress = new CustomAddress();
1316 
		customAddress.setName(address.getName());
1317 
		customAddress.setLine1(address.getLine1());
1318 
		customAddress.setLine2(address.getLine2());
1319 
		customAddress.setLandmark(address.getLandmark());
1320 
		customAddress.setCity(address.getCity());
1321 
		customAddress.setPinCode(address.getPinCode());
1322 
		customAddress.setState(address.getState());
1323 
		customAddress.setCountry(address.getCountry());
1324 
		customAddress.setPhoneNumber(address.getPhoneNumber());
1325 
		return customAddress;
1326 
	}
1327 
 
23650 amit.gupta 1328 
	private CustomAddress createCustomAddress(CustomerAddress customerAddress) {
22859 ashik.ali 1329 
		CustomAddress customAddress = new CustomAddress();
1330 
		customAddress.setName(customerAddress.getName());
1331 
		customAddress.setLine1(customerAddress.getLine1());
1332 
		customAddress.setLine2(customerAddress.getLine2());
1333 
		customAddress.setLandmark(customerAddress.getLandmark());
1334 
		customAddress.setCity(customerAddress.getCity());
1335 
		customAddress.setPinCode(customerAddress.getPinCode());
1336 
		customAddress.setState(customerAddress.getState());
1337 
		customAddress.setCountry(customerAddress.getCountry());
1338 
		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());
1339 
		return customAddress;
1340 
	}
1341 
 
23650 amit.gupta 1342 
	private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount)
1343 
			throws ProfitMandiBusinessException {
23365 ashik.ali 1344 
		Set<Integer> paymentOptionIds = new HashSet<>();
23650 amit.gupta 1345 
 
22859 ashik.ali 1346 
		float calculatedAmount = 0;
23650 amit.gupta 1347 
		for (CustomPaymentOption customPaymentOption : customPaymentOptions) {
23365 ashik.ali 1348 
			paymentOptionIds.add(customPaymentOption.getPaymentOptionId());
1349 
			calculatedAmount = calculatedAmount + customPaymentOption.getAmount();
22859 ashik.ali 1350 
		}
23650 amit.gupta 1351 
		if (calculatedAmount != totalAmount) {
1352 
			LOGGER.warn("Error occured while validating payment options amount[{}] != TotalAmount [{}]",
1353 
					calculatedAmount, totalAmount);
1354 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_CALCULATED_AMOUNT,
1355 
					calculatedAmount, "FFORDR_1016");
22859 ashik.ali 1356 
		}
23650 amit.gupta 1357 
 
23365 ashik.ali 1358 
		List<Integer> foundPaymentOptionIds = paymentOptionRepository.selectIdsByIds(paymentOptionIds);
23650 amit.gupta 1359 
		if (foundPaymentOptionIds.size() != paymentOptionIds.size()) {
23365 ashik.ali 1360 
			paymentOptionIds.removeAll(foundPaymentOptionIds);
23650 amit.gupta 1361 
			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_ID, paymentOptionIds,
1362 
					"FFORDR_1017");
23365 ashik.ali 1363 
		}
22859 ashik.ali 1364 
	}
23650 amit.gupta 1365 
 
22925 ashik.ali 1366 
	@Override
1367 
	public List<FofoOrderItem> getByOrderId(int orderId) throws ProfitMandiBusinessException {
1368 
		List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(orderId);
23650 amit.gupta 1369 
		if (!fofoOrderItems.isEmpty()) {
22925 ashik.ali 1370 
			List<FofoOrderItem> newFofoOrderItems = new ArrayList<>();
23650 amit.gupta 1371 
			Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = this
1372 
					.toFofoOrderItemIdFofoLineItems(fofoOrderItems);
22925 ashik.ali 1373 
			Iterator<FofoOrderItem> fofoOrderItemsIterator = fofoOrderItems.iterator();
23650 amit.gupta 1374 
			while (fofoOrderItemsIterator.hasNext()) {
22925 ashik.ali 1375 
				FofoOrderItem fofoOrderItem = fofoOrderItemsIterator.next();
1376 
				fofoOrderItem.setFofoLineItems(fofoOrderItemIdFofoLineItemsMap.get(fofoOrderItem.getId()));
1377 
				newFofoOrderItems.add(fofoOrderItem);
1378 
				fofoOrderItemsIterator.remove();
1379 
			}
1380 
			fofoOrderItems = newFofoOrderItems;
1381 
		}
1382 
		return fofoOrderItems;
1383 
	}
23650 amit.gupta 1384 
 
1385 
	private Set<Integer> toFofoOrderItemIds(List<FofoOrderItem> fofoOrderItems) {
22955 ashik.ali 1386 
		Function<FofoOrderItem, Integer> fofoOrderItemToFofoOrderItemIdFunction = new Function<FofoOrderItem, Integer>() {
1387 
			@Override
1388 
			public Integer apply(FofoOrderItem fofoOrderItem) {
1389 
				return fofoOrderItem.getId();
1390 
			}
1391 
		};
1392 
		return fofoOrderItems.stream().map(fofoOrderItemToFofoOrderItemIdFunction).collect(Collectors.toSet());
22925 ashik.ali 1393 
	}
23650 amit.gupta 1394 
 
1395 
	private Map<Integer, Set<FofoLineItem>> toFofoOrderItemIdFofoLineItems(List<FofoOrderItem> fofoOrderItems) {
22925 ashik.ali 1396 
		Set<Integer> fofoOrderItemIds = this.toFofoOrderItemIds(fofoOrderItems);
1397 
		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByFofoOrderItemIds(fofoOrderItemIds);
1398 
		Map<Integer, Set<FofoLineItem>> fofoOrderItemIdFofoLineItemsMap = new HashMap<>();
23650 amit.gupta 1399 
		for (FofoLineItem fofoLineItem : fofoLineItems) {
1400 
			if (!fofoOrderItemIdFofoLineItemsMap.containsKey(fofoLineItem.getFofoOrderItemId())) {
22925 ashik.ali 1401 
				Set<FofoLineItem> fofoLineItems2 = new HashSet<>();
1402 
				fofoLineItems2.add(fofoLineItem);
1403 
				fofoOrderItemIdFofoLineItemsMap.put(fofoLineItem.getFofoOrderItemId(), fofoLineItems2);
23650 amit.gupta 1404 
			} else {
22925 ashik.ali 1405 
				fofoOrderItemIdFofoLineItemsMap.get(fofoLineItem.getFofoOrderItemId()).add(fofoLineItem);
1406 
			}
1407 
		}
1408 
		return fofoOrderItemIdFofoLineItemsMap;
1409 
	}
23650 amit.gupta 1410 
 
23418 ashik.ali 1411 
	@Override
23650 amit.gupta 1412 
	public void updateCustomerDetails(CustomCustomer customCustomer, String invoiceNumber)
1413 
			throws ProfitMandiBusinessException {
23582 ashik.ali 1414 
		FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
1415 
		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
1416 
		customer.setFirstName(customCustomer.getFirstName());
1417 
		customer.setLastName(customCustomer.getLastName());
24121 govind 1418 
		customer.setMobileNumber(customCustomer.getMobileNumber());
1419 
		customer.setEmailId(customCustomer.getEmailId());
23582 ashik.ali 1420 
		customerRepository.persist(customer);
1421 
		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
1422 
		this.setCustomerAddress(customerAddress, customCustomer.getAddress());
1423 
		customerAddressRepository.persist(customerAddress);
24121 govind 1424 
		fofoOrder.setCustomerGstNumber(customCustomer.getGstNumber());
23582 ashik.ali 1425 
	}
23418 ashik.ali 1426 
 
23638 amit.gupta 1427 
	@Override
23655 amit.gupta 1428 
	public CustomerCreditNote badReturn(int fofoId, FoiBadReturnRequest foiBadReturnRequest) throws ProfitMandiBusinessException {
1429 
		FofoOrderItem foi = fofoOrderItemRepository.selectById(foiBadReturnRequest.getFofoOrderItemId());
23650 amit.gupta 1430 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(foi.getOrderId());
23655 amit.gupta 1431 
		if (fofoOrder.getFofoId() != fofoId) {
23638 amit.gupta 1432 
			throw new ProfitMandiBusinessException("Partner Auth", "", "Invalid Order");
1433 
		}
23655 amit.gupta 1434 
		int billedQty = foi.getQuantity() - customerReturnItemRepository.selectAllByOrderItemId(foi.getId()).size();
1435 
		if(foiBadReturnRequest.getMarkedBadArr().size() > billedQty ) {
1436 
			throw new ProfitMandiBusinessException("Cant bad return more than what is billed", "", "Invalid Quantity");
1437 
		}
23650 amit.gupta 1438 
		List<CustomerReturnItem> customerReturnItems = new ArrayList<>();
23655 amit.gupta 1439 
		for (BadReturnRequest badReturnRequest : foiBadReturnRequest.getMarkedBadArr()) {
23650 amit.gupta 1440 
			CustomerReturnItem customerReturnItem = new CustomerReturnItem();
1441 
			customerReturnItem.setFofoId(fofoId);
23655 amit.gupta 1442 
			customerReturnItem.setFofoOrderItemId(foiBadReturnRequest.getFofoOrderItemId());
1443 
			customerReturnItem.setRemarks(badReturnRequest.getRemarks());
23650 amit.gupta 1444 
			customerReturnItem.setInventoryItemId(badReturnRequest.getInventoryItemId());
1445 
			customerReturnItem.setQuantity(1);
1446 
			customerReturnItem.setType(ReturnType.BAD);
1447 
			//customerReturnItemRepository.persist(customerReturnItem);
1448 
			inventoryService.saleReturnInventoryItem(customerReturnItem);
1449 
			customerReturnItems.add(customerReturnItem);
23638 amit.gupta 1450 
		}
23655 amit.gupta 1451 
		CustomerCreditNote creditNote = generateCreditNote(fofoOrder, customerReturnItems);
1452 
		for (CustomerReturnItem customerReturnItem: customerReturnItems) {
1453 
			purchaseReturnService.returnInventoryItem(fofoId, false, customerReturnItem.getInventoryItemId(), ReturnType.BAD);
1454 
		}
1455 
        return creditNote;
23638 amit.gupta 1456 
	}
1457 
 
23655 amit.gupta 1458 
	private CustomerCreditNote generateCreditNote(FofoOrder fofoOrder, List<CustomerReturnItem> customerReturnItems) throws ProfitMandiBusinessException {
23650 amit.gupta 1459 
 
23638 amit.gupta 1460 
		InvoiceNumberGenerationSequence sequence = invoiceNumberGenerationSequenceRepository
23650 amit.gupta 1461 
				.selectByFofoId(fofoOrder.getFofoId());
1462 
		sequence.setCreditNoteSequence(sequence.getCreditNoteSequence() + 1);
23638 amit.gupta 1463 
		invoiceNumberGenerationSequenceRepository.persist(sequence);
23650 amit.gupta 1464 
 
23655 amit.gupta 1465 
		String creditNoteNumber = sequence.getPrefix() + "/" + sequence.getCreditNoteSequence();
23650 amit.gupta 1466 
		CustomerCreditNote creditNote = new CustomerCreditNote();
1467 
		creditNote.setCreditNoteNumber(creditNoteNumber);
1468 
		creditNote.setFofoId(fofoOrder.getFofoId());
23655 amit.gupta 1469 
		creditNote.setFofoOrderId(fofoOrder.getId());
1470 
		creditNote.setFofoOrderItemId(customerReturnItems.get(0).getFofoOrderItemId());
1471 
		creditNote.setSettlementType(SettlementType.UNSETTLED);
23650 amit.gupta 1472 
		customerCreditNoteRepository.persist(creditNote);
1473 
 
1474 
		for (CustomerReturnItem customerReturnItem : customerReturnItems) {
1475 
			customerReturnItem.setCreditNoteId(creditNote.getId());
1476 
			customerReturnItemRepository.persist(customerReturnItem);
23638 amit.gupta 1477 
		}
23650 amit.gupta 1478 
		//this.returnInventoryItems(inventoryItems, debitNote);
23638 amit.gupta 1479 
 
23655 amit.gupta 1480 
		return creditNote;
23650 amit.gupta 1481 
	}
1482 
 
23655 amit.gupta 1483 
	@Override
1484 
	public CreditNotePdfModel getCreditNotePdfModel(int customerCreditNoteId) throws ProfitMandiBusinessException {
1485 
		CustomerCreditNote creditNote = customerCreditNoteRepository.selectById(customerCreditNoteId);
1486 
		return getCreditNotePdfModel(creditNote);
1487 
	}
1488 
 
1489 
	private CreditNotePdfModel getCreditNotePdfModel(CustomerCreditNote creditNote) throws ProfitMandiBusinessException {
1490 
		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(creditNote.getFofoOrderId());
1491 
		List<CustomerReturnItem> customerReturnItems = customerReturnItemRepository.selectAllByCreditNoteId(creditNote.getId());
1492 
		CustomCustomer customCustomer = getCustomCustomer(fofoOrder);
1493 
 
1494 
		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();
1495 
		CustomRetailer customRetailer = retailerService.getFofoRetailers(Arrays.asList(fofoOrder.getFofoId())).get(fofoOrder.getFofoId());
1496 
 
1497 
		FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectById(creditNote.getFofoOrderItemId());
1498 
		float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate() + fofoOrderItem.getCgstRate();
1499 
		float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);
1500 
		float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);
1501 
 
1502 
		CustomOrderItem customFofoOrderItem = new CustomOrderItem();
1503 
		customFofoOrderItem.setAmount(customerReturnItems.size() * (taxableSellingPrice - taxableDiscountPrice));
1504 
		customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "
1505 
				+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());
1506 
 
1507 
		if(ItemType.SERIALIZED.equals(itemRepository.selectById(fofoOrderItem.getItemId()).getType())){
1508 
			Set<Integer> inventoryItemIds = customerReturnItems.stream().map(x -> x.getInventoryItemId())
1509 
					.collect(Collectors.toSet());
1510 
			List<String> serialNumbers = inventoryItemRepository.selectByIds(inventoryItemIds).stream()
1511 
					.map(x -> x.getSerialNumber()).collect(Collectors.toList());
1512 
			customFofoOrderItem.setDescription(
1513 
					customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));
1514 
		}
1515 
 
1516 
		customFofoOrderItem.setRate(taxableSellingPrice);
1517 
		customFofoOrderItem.setDiscount(taxableDiscountPrice);
1518 
		customFofoOrderItem.setQuantity(customerReturnItems.size());
1519 
		customFofoOrderItem.setNetAmount((fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * customFofoOrderItem.getQuantity());
1520 
 
1521 
		float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;
1522 
		float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;
1523 
		float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;
1524 
		LOGGER.info("fofoOrderItem - {}", fofoOrderItem);
1525 
		customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());
1526 
		customFofoOrderItem.setIgstAmount(igstAmount);
1527 
		customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());
1528 
		customFofoOrderItem.setCgstAmount(cgstAmount);
1529 
		customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());
1530 
		customFofoOrderItem.setSgstAmount(sgstAmount);
1531 
		customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());
23721 amit.gupta 1532 
		customFofoOrderItem.setOrderId(1);
23655 amit.gupta 1533 
		customerFofoOrderItems.add(customFofoOrderItem);
1534 
 
23650 amit.gupta 1535 
		PdfModel pdfModel = new PdfModel();
1536 
		pdfModel.setAuther("NSSPL");
23655 amit.gupta 1537 
		pdfModel.setCustomer(customCustomer);
1538 
		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
1539 
		pdfModel.setInvoiceDate(FormattingUtils.formatDate(fofoOrder.getCreateTimestamp()));
1540 
		pdfModel.setTitle("Credit Note");
1541 
		pdfModel.setRetailer(customRetailer);
1542 
		pdfModel.setTotalAmount(customFofoOrderItem.getNetAmount());
1543 
		pdfModel.setOrderItems(customerFofoOrderItems);
1544 
 
23650 amit.gupta 1545 
		CreditNotePdfModel creditNotePdfModel = new CreditNotePdfModel();
1546 
		creditNotePdfModel.setCreditNoteDate(FormattingUtils.formatDate(creditNote.getCreateTimestamp()));
1547 
		creditNotePdfModel.setCreditNoteNumber(creditNote.getCreditNoteNumber());
1548 
		creditNotePdfModel.setPdfModel(pdfModel);
1549 
		return creditNotePdfModel;
1550 
	}
23638 amit.gupta 1551 
 
22859 ashik.ali 1552 
}