Subversion Repositories SmartDukaan

Rev

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