Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.order;

import com.spice.profitmandi.common.enumuration.ItemType;

import com.spice.profitmandi.common.enumuration.SearchType;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.*;

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.common.util.StringUtils;

import com.spice.profitmandi.common.util.Utils;

import com.spice.profitmandi.common.web.client.RestClient;

import com.spice.profitmandi.dao.entity.catalog.Item;

import com.spice.profitmandi.dao.entity.catalog.TagListing;

import com.spice.profitmandi.dao.entity.dtr.*;

import com.spice.profitmandi.dao.entity.fofo.*;

import com.spice.profitmandi.dao.entity.inventory.State;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.user.Address;

import com.spice.profitmandi.dao.entity.user.Counter;

import com.spice.profitmandi.dao.entity.user.PrivateDealUser;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;

import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;

import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;

import com.spice.profitmandi.dao.enumuration.fofo.ReturnType;

import com.spice.profitmandi.dao.enumuration.fofo.ScanType;

import com.spice.profitmandi.dao.enumuration.fofo.SettlementType;

import com.spice.profitmandi.dao.enumuration.inventory.ScratchedGift;

import com.spice.profitmandi.dao.enumuration.transaction.OrderStatus;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.catalog.StateGstRateRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

import com.spice.profitmandi.dao.repository.dtr.*;

import com.spice.profitmandi.dao.repository.fofo.*;

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.dao.repository.user.CounterRepository;

import com.spice.profitmandi.dao.repository.user.PrivateDealUserRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;

import com.spice.profitmandi.service.integrations.zest.InsuranceService;

import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;

import com.spice.profitmandi.service.inventory.InventoryService;

import com.spice.profitmandi.service.inventory.PurchaseReturnService;

import com.spice.profitmandi.service.inventory.SaholicInventoryService;

import com.spice.profitmandi.service.offers.ItemCriteria;

import com.spice.profitmandi.service.pricing.PricingService;

import com.spice.profitmandi.service.scheme.SchemeService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.service.wallet.WalletService;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.json.JSONObject;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Component;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.util.AbstractMap.SimpleEntry;

import java.util.*;

import java.util.function.Function;

import java.util.stream.Collectors;

@Component

public class OrderServiceImpl implements OrderService {

	private static final Logger LOGGER = LogManager.getLogger(OrderServiceImpl.class);

	private static Map<String, Integer> serialNumberOrderIdMap = new HashMap<>();

	static {

		serialNumberOrderIdMap.put("862897055749275", 67228);

	}

	@Autowired

	@Qualifier("fofoInventoryItemRepository")

	private InventoryItemRepository inventoryItemRepository;

	@Autowired

	private StateGstRateRepository stateGstRateRepository;

	@Autowired

	private SaholicInventoryService saholicInventoryService;

	@Autowired

	private LiveDemoBillingRespository liveDemoBillingRespository;

	@Autowired

	private InsuranceService insuranceService;

	@Autowired

	private WalletService walletService;

	@Autowired

	@Qualifier("fofoCurrentInventorySnapshotRepository")

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	private InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;

	@Autowired

	private PurchaseReturnService purchaseReturnService;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private CustomerRepository customerRepository;

	@Autowired

	private PurchaseReturnItemRepository purchaseReturnItemRepository;

	@Autowired

	private AddressRepository addressRepository;

	@Autowired

	private FofoLineItemRepository fofoLineItemRepository;

	@Autowired

	private WarehouseInventoryItemRepository warehouseInventoryItemRepository;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

	private PaymentOptionRepository paymentOptionRepository;

	@Autowired

	private CustomerReturnItemRepository customerReturnItemRepository;

	@Autowired

	@Qualifier("fofoScanRecordRepository")

	private ScanRecordRepository scanRecordRepository;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

	private CustomerAddressRepository customerAddressRepository;

	@Autowired

	@Qualifier("catalogItemRepository")

	private ItemRepository itemRepository;

	@Autowired

	private InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

	private InsurancePolicyRepository insurancePolicyRepository;

	@Autowired

	private StateRepository stateRepository;

	@Autowired

	private PolicyNumberGenerationSequenceRepository policyNumberGenerationSequenceRepository;

	@Autowired

	private PricingService pricingService;

	@Autowired

	private PrivateDealUserRepository privateDealUserRepository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private CounterRepository counterRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

	@Autowired

	private SchemeService schemeService;

	private static final List<Integer> orderIdsConsumed = new ArrayList<>();

	@Autowired

	@Qualifier("fofoInventoryService")

	private InventoryService inventoryService;

	@Autowired

	private CustomerCreditNoteRepository customerCreditNoteRepository;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	private HygieneDataRepository hygieneDataRepository;

	@Autowired

	private SessionFactory sessionFactory;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	private PendingOrderRepository pendingOrderRepository;

	@Autowired

	private PendingOrderItemRepository pendingOrderItemRepository;

	@Autowired

	private ScratchOfferRepository scratchOfferRepository;

	@Autowired

	RestClient restClient;

	@Value("${prod}")

	private boolean prodEnv;

	private static final String SMS_GATEWAY = "http://api.pinnacle.in/index.php/sms/send";

	private static final String SENDER = "SMTDKN";

	public static final String APP_DOWNLOAD_BILLING_TEMPLATE_ID = "1507163542403945677";

	public static final String APP_DOWNLOAD_BILLING_OFFER = "Dear Customer, Thank you for purchasing from SmartDukaan pls click %s to download our app to see you invoice and special offers. SmartDukaan";

	@Override

	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId, boolean accessoriesDeals)

			throws ProfitMandiBusinessException {

		LOGGER.info("fofoId -- {} Order Request -- {}", fofoId, createOrderRequest);

		CustomCustomer customCustomer = createOrderRequest.getCustomer();

		Customer customer = customerRepository.selectById(customCustomer.getCustomerId());

		if (!StringUtils.isValidGstNumber(customCustomer.getGstNumber())) {

			LOGGER.error("invalid customer gstNumber {} ", customCustomer.getGstNumber());

			throw new ProfitMandiBusinessException(ProfitMandiConstants.CUSTOMER_GST_NUMBER,

					customCustomer.getGstNumber(), "VE_1072");

		}

		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); // this is for error

		Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap = new HashMap<>();

		Map<Integer, Float> lineItemPrice = new HashMap<>(); // this is for pricing error

		float totalAmount = 0;

		boolean noGST = false;

		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

			// itemIds.add(customFofoOrderItem.getItemId());

			Set<String> serialNumbers = this

					.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());

			if (!serialNumbers.isEmpty() && customFofoOrderItem.getQuantity() != serialNumbers.size()) {

				itemIdQuantity.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());

			}

			if (!(customFofoOrderItem.getSellingPrice() > 0)) {

				lineItemPrice.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getSellingPrice());

			} else {

				totalAmount = totalAmount + customFofoOrderItem.getSellingPrice() * customFofoOrderItem.getQuantity();

				for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {

					if (serialNumberDetail.getAmount() > 0) {

						totalAmount = totalAmount + serialNumberDetail.getAmount();

					}

				}

			}

			itemIdCustomFofoOrderItemMap.put(customFofoOrderItem.getItemId(), customFofoOrderItem);

		}

		if (!itemIdQuantity.isEmpty()) {

			// if item quantity does not match with given serialnumbers size

			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);

			throw new ProfitMandiBusinessException("itemIdQuantity", itemIdQuantity, "FFORDR_1001");

			// return "error";

		}

		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);

		if (!lineItemPrice.isEmpty()) {

			// given fofo line item price must be greater than zero

			LOGGER.error("requested itemId's selling price must greater than 0");

			throw new ProfitMandiBusinessException(ProfitMandiConstants.PRICE, lineItemPrice, "FFORDR_1002");

		}

		List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository

				.selectByFofoItemIds(fofoId, itemIdCustomFofoOrderItemMap.keySet());

		this.validateCurrentInventorySnapshotQuantities(currentInventorySnapshots, itemIdCustomFofoOrderItemMap);

		List<Item> items = itemRepository.selectByIds(itemIdCustomFofoOrderItemMap.keySet());

		if (items.size() != itemIdCustomFofoOrderItemMap.keySet().size()) {

			LOGGER.error("Requested ItemIds not found in catalog");

			// invalid itemIds

			throw new ProfitMandiBusinessException("invalidItemIds", itemIdCustomFofoOrderItemMap.keySet(),

					"FFORDR_1003");

		}

		Map<Integer, Item> itemMap = this.toItemMap(items);

		Set<Integer> nonSerializedItemIds = new HashSet<>();

		Set<String> serialNumbers = new HashSet<>();

		List<InsuranceModel> insuredModels = new ArrayList<>();

		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

			Item item = itemMap.get(customFofoOrderItem.getItemId());

			noGST = item.getHsnCode().equals("NOGST");

			if (item.getType().equals(ItemType.SERIALIZED)) {

				for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {

					serialNumbers.add(serialNumberDetail.getSerialNumber());

					if (serialNumberDetail.getAmount() > 0) {

						if (customer.getEmailId() == null || customer.getEmailId().equals("")) {

							throw new ProfitMandiBusinessException("Email Id is required for insurance",

									"Email Id is required for insurance", "Email Id is required for insurance");

						}

						InsuranceModel im = new InsuranceModel();

						im.setBrand(item.getBrand());

						im.setColor(item.getColor());

						im.setModelName(item.getModelName() + item.getModelNumber());

						im.setInsuranceAmount(serialNumberDetail.getAmount());

						im.setDeviceSellingPrice(customFofoOrderItem.getSellingPrice());

						im.setInsuranceId(serialNumberDetail.getInsurance());

						im.setSerialNumber(serialNumberDetail.getSerialNumber());

						im.setMemory(serialNumberDetail.getMemory());

						im.setRam(serialNumberDetail.getRam());

						im.setMfgDate(serialNumberDetail.getMfgDate());

						insuredModels.add(im);

						// Check for free insurance code

						try {

							Map<String, List<MobileInsurancePlan>> mobileInsurancePlanMap = insuranceService

									.getAllPlans(item.getId(), im.getDeviceSellingPrice());

							MobileInsurancePlan mobileInsurancePlan = mobileInsurancePlanMap.entrySet().stream()

									.flatMap(x -> x.getValue().stream())

									.filter(x -> x.getProductId().equals(serialNumberDetail.getInsurance())).findFirst()

									.get();

							LOGGER.info("OneAssist Plan - {}", mobileInsurancePlanMap);

							LOGGER.info("SerialNumber Detqail InsuranceId - {}", serialNumberDetail.getInsurance());

							LOGGER.info("product description - {}", mobileInsurancePlan);

							if (mobileInsurancePlan.getPlanName().equals("OneAssist Damage Protection Plan")) {

								MobileInsurancePlan freePlan = mobileInsurancePlanMap

										.get("Prolong Extendended Warranty(SmartDukaan Special Price)").get(0);

								InsuranceModel imFree = new InsuranceModel();

								imFree.setBrand(item.getBrand());

								imFree.setColor(item.getColor());

								imFree.setModelName(item.getModelName() + item.getModelNumber());

								imFree.setInsuranceAmount(0);

								imFree.setDeviceSellingPrice(customFofoOrderItem.getSellingPrice());

								imFree.setInsuranceId(freePlan.getProductId());

								imFree.setSerialNumber(serialNumberDetail.getSerialNumber());

								imFree.setMemory(serialNumberDetail.getMemory());

								imFree.setRam(serialNumberDetail.getRam());

								imFree.setMfgDate(serialNumberDetail.getMfgDate());

								insuredModels.add(imFree);

							}

						} catch (Exception e) {

							LOGGER.error("Exception - {}", e);

							throw new ProfitMandiBusinessException("problem fetching plans", "problem fetching plans",

									"problem fetching plans");

						}

					}

				}

			} else {

				nonSerializedItemIds.add(customFofoOrderItem.getItemId());

			}

		}

		Map<Integer, Set<InventoryItem>> serializedInventoryItemMap = new HashMap<>();

		Map<Integer, Set<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<>();

		// Map<String, Float> serialNumberItemPrice = new HashMap<>();

		if (!serialNumbers.isEmpty()) {

			List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId,

					serialNumbers, false);

			LOGGER.info("serializedInventoryItems {}", serializedInventoryItems);

			for (InventoryItem inventoryItem : serializedInventoryItems) {

				if (inventoryItem.getGoodQuantity() == 1) {

					if (serializedInventoryItemMap.containsKey(inventoryItem.getItemId())) {

						serializedInventoryItemMap.get(inventoryItem.getItemId()).add(inventoryItem);

					} else {

						Set<InventoryItem> itemIdInventoryItems = new HashSet<>();

						itemIdInventoryItems.add(inventoryItem);

						serializedInventoryItemMap.put(inventoryItem.getItemId(), itemIdInventoryItems);

					}

				}

			}

		}

		if (!nonSerializedItemIds.isEmpty()) {

			List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoId,

					nonSerializedItemIds);

			LOGGER.info("nonSerializedInventoryItems {}", nonSerializedInventoryItems);

			for (InventoryItem it : nonSerializedInventoryItems) {

				if (it.getGoodQuantity() > 0) {

					if (nonSerializedInventoryItemMap.containsKey(it.getItemId())) {

						nonSerializedInventoryItemMap.get(it.getItemId()).add(it);

					} else {

						Set<InventoryItem> tmp = new HashSet<>();

						tmp.add(it);

						nonSerializedInventoryItemMap.put(it.getItemId(), tmp);

					}

				}

			}

		}

		this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);

		Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();

		Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity

		// used for scan records insertion

		LOGGER.info("itemMap keys {}", itemMap.keySet());

		// Lets reduce quantity and decide what inventory items to use.

		for (Item item : items) {

			if (item.getType().equals(ItemType.SERIALIZED)) {

				// TODO:handle null

				if (serializedInventoryItemMap.get(item.getId()) == null

						|| itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails()

								.size() != serializedInventoryItemMap.get(item.getId()).size()) {

					List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId())

							.getSerialNumberDetails().stream().map(x -> x.getSerialNumber())

							.collect(Collectors.toList());

					throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");

				}

				List<String> serialNumberList = liveDemoBillingRespository.selectAllSerialNumber();

				Set<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(item.getId());

				for (InventoryItem inventoryItem : inventoryItemsSerializedserialized) {

					inventoryItem.setGoodQuantity(0);

					inventoryItemIdQuantityUsed.put(inventoryItem.getId(), 1);

					if (serialNumberList.contains(inventoryItem.getSerialNumber())) {

						LiveDemoSerialNumber liveDemoSerialNumber = liveDemoBillingRespository

								.selectBySerialNumber(inventoryItem.getSerialNumber());

						liveDemoBillingRespository.delete(liveDemoSerialNumber);

					}

				}

				inventoryItemsToBill.put(item.getId(), inventoryItemsSerializedserialized);

			} else {

				Set<InventoryItem> inventoryItemsNonSerialized = nonSerializedInventoryItemMap.get(item.getId());

				int quantityToBill = itemIdCustomFofoOrderItemMap.get(item.getId()).getQuantity();

				int totalLeft = quantityToBill;

				Set<InventoryItem> inventoryItemsNonSerializedUsed = new HashSet<>();

				if (inventoryItemsNonSerialized != null) {

					for (InventoryItem inventoryItem : inventoryItemsNonSerialized) {

						if (totalLeft > 0) {

							int toUse = Math.min(totalLeft, inventoryItem.getGoodQuantity());

							inventoryItemIdQuantityUsed.put(inventoryItem.getId(), toUse);

							inventoryItem.setGoodQuantity(inventoryItem.getGoodQuantity() - toUse);

							totalLeft = totalLeft - toUse;

							inventoryItemsNonSerializedUsed.add(inventoryItem);

						}

					}

				}

				if (totalLeft > 0) {

					// not enough quanity for non-serialized

					LOGGER.error("not enough quanity for non-serialized");

					throw new ProfitMandiBusinessException("notEnoughQuantityForNonSerialized", totalLeft,

							"FFORDR_1005");

				}

				inventoryItemsToBill.put(item.getId(), inventoryItemsNonSerializedUsed);

			}

		}

		Map<Integer, PriceModel> itemIdMopPriceMap = pricingService

				.getPurchasePriceMopPriceNotFound(itemIdCustomFofoOrderItemMap.keySet(), fofoId);

		LOGGER.info("itemIdMopMap {}", itemIdMopPriceMap);

		if (accessoriesDeals) {

			this.validateDpPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);

		} else {

			this.validateMopPrice(itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);

		}

		String fofoStoreCode = this.getFofoStoreCode(fofoId);

		String documentNumber = null;

		if (noGST) {

			documentNumber = this.getSecurityDepositNumber(fofoId, fofoStoreCode);

		} else {

			documentNumber = this.getInvoiceNumber(fofoId, fofoStoreCode);

		}

		CustomerAddress customerAddress = customer.getCustomerAddress().stream()

				.filter(x -> x.getId() == customCustomer.getCustomerAddressId()).findFirst().get();

		FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId,

				documentNumber, totalAmount, customerAddress.getId());

		this.createPaymentOptions(fofoOrder, createOrderRequest.getPaymentOptions());

		int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);

		Address retailerAddress = addressRepository.selectById(retailerAddressId);

		Integer stateId = null;

		if (customerAddress.getState().equals(retailerAddress.getState())) {

			try {

				State state = stateRepository.selectByName(customerAddress.getState());

				stateId = Long.valueOf(state.getId()).intValue();

			} catch (Exception e) {

				LOGGER.error("Unable to get state rates");

			}

		}

		for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

			FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(),

					itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), stateId);

			Set<InventoryItem> inventoryItems = inventoryItemsToBill.get(customFofoOrderItem.getItemId());

			this.createFofoLineItem(fofoOrderItem.getId(), inventoryItems, inventoryItemIdQuantityUsed);

			this.updateCurrentInventorySnapshot(currentInventorySnapshots, fofoId, customFofoOrderItem.getItemId(),

					customFofoOrderItem.getQuantity());

			this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed,

					fofoOrder.getId());

		}

		List<FofoOrderItem> fofoItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

		boolean smartPhone = false;

		for (FofoOrderItem fofoItem : fofoItems) {

			Item orderItem = itemRepository.selectById(fofoItem.getItemId());

			if (orderItem.isSmartPhone()) {

				smartPhone = true;

			}

		}

		if (smartPhone) {

			this.createAndGetHygieneData(fofoOrder.getId(), fofoOrder.getFofoId());

		}

		// insurance calculation is insurance flag is enabled

		//

		if (insuredModels.size() > 0) {

			LOGGER.info("Processing insurane for serialNumbers");

			LOGGER.info("InsuranceModels {}", insuredModels);

			LocalDate customerDateOfBirth = LocalDate.from(createOrderRequest.getCustomer().getDateOfBirth());

			fofoOrder.setDateOfBirth(customerDateOfBirth);

			for (InsuranceModel insuranceModel : insuredModels) {

				LOGGER.info("Creating insurance for {}", insuranceModel.getInsuranceId());

				insuranceService.createInsurance(fofoOrder, insuranceModel);

			}

		}

		schemeService.processSchemeOut(fofoOrder.getId(), fofoId);

		if (createOrderRequest.getPoId() != 0) {

			PendingOrder po = pendingOrderRepository.selectById(createOrderRequest.getPoId());

			po.setBilledAmount(po.getBilledAmount() + totalAmount);

			PendingOrderItem poi = pendingOrderItemRepository.selectById(createOrderRequest.getPoItemId());

			poi.setStatus(OrderStatus.BILLED);

			poi.setBilledTimestamp(LocalDateTime.now());

		}

		LocalDate startDate = LocalDate.of(2023, 01, 13);

		LocalDate endDate = LocalDate.of(2023, 01, 27);

		if (smartPhone) {

			if (LocalDateTime.now().isAfter(startDate.atStartOfDay())

					&& LocalDateTime.now().isBefore(endDate.atStartOfDay())) {

				try {

					this.sendAppDownloadBillingOffer(customer.getMobileNumber());

				} catch (Exception e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

				this.createScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());

			}

		}

		return fofoOrder.getId();

	}

	public void sendAppDownloadBillingOffer(String mobileNumber) throws Exception {

		// In case of Cant receive SMS?

		// String mailMessage = java.text.MessageFormat.format(text, otp.getOtp());

		String sdurl = "http://surl.li/anhfn";

		try {

			if (prodEnv) {

				this.sendSms(APP_DOWNLOAD_BILLING_TEMPLATE_ID, String.format(APP_DOWNLOAD_BILLING_OFFER, sdurl),

						mobileNumber);

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

	}

	public void sendSms(String dltTemplateId, String message, String mobileNumber) throws Exception {

		Map<String, String> map = new HashMap<>();

		map.put("sender", SENDER);

		map.put("messagetype", "TXT");

		map.put("apikey", "b866f7-c6c483-682ff5-054420-ad9e2c");

		map.put("numbers", "91" + mobileNumber);

		LOGGER.info("Message {}", message);

		// OTP Message Template

		map.put("message", message);

		map.put("dlttempid", dltTemplateId);

		String response = restClient.post(SMS_GATEWAY, map, new HashMap<>());

		LOGGER.info(response);

	}

	private void createScratchOffer(String invoiceNumber, int customerId) {

		/*

		 * ScratchOffer so = new ScratchOffer(); so.setInvoiceNumber(invoiceNumber);

		 * so.setOfferName(ScratchedGift.EW); so.setScratched(false);

		 * so.setCreatedTimestamp(LocalDateTime.now());

		 * so.setExpiredTimestamp(so.getCreatedTimestamp().plusDays(1));

		 * so.setUnlockedAt(LocalDateTime.now()); so.setCustomerId(customerId);

		 * scratchOfferRepository.persist(so);

		 */

		LocalDateTime endDate = LocalDateTime.of(LocalDate.now().getYear(), LocalDate.now().getMonth(), 27, 21, 00);

		ScratchOffer so2 = new ScratchOffer();

		so2.setInvoiceNumber(invoiceNumber);

		so2.setScratched(false);

		so2.setCreatedTimestamp(LocalDateTime.now());

		so2.setExpiredTimestamp(endDate.plusDays(1).toLocalDate().atTime(LocalTime.MAX));

		so2.setOfferName(ScratchedGift.BLNT);

		so2.setCustomerId(customerId);

		LocalDate date = LocalDate.now();

		LocalDateTime seven = LocalDateTime.of(date.getYear(), date.getMonth(), date.getDayOfMonth(), 19, 0);

		LocalDateTime nine = LocalDateTime.of(date.getYear(), date.getMonth(), date.getDayOfMonth(), 21, 0);

		if (LocalDateTime.now().isAfter(seven)) {

			so2.setUnlockedAt(nine.plusDays(1));

		} else {

			so2.setUnlockedAt(nine);

		}

		scratchOfferRepository.persist(so2);

	}

	private HygieneData createAndGetHygieneData(int id, int fofoId) {

		HygieneData hygieneData = new HygieneData();

		hygieneData.setOrderId(id);

		hygieneData.setFofoId(fofoId);

		hygieneData.setCreatedTimestamp(LocalDateTime.now());

		hygieneDataRepository.persist(hygieneData);

		return hygieneData;

	}

	@Override

	public String getInvoiceNumber(int fofoId, String fofoStoreCode) {

		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;

		try {

			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);

			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();

			invoiceNumberGenerationSequence.setFofoId(fofoId);

			invoiceNumberGenerationSequence.setPrefix(fofoStoreCode);

			invoiceNumberGenerationSequence.setSequence(1);

		}

		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);

		return invoiceNumberGenerationSequence.getPrefix() + "/" + invoiceNumberGenerationSequence.getSequence();

	}

	private String getSecurityDepositNumber(int fofoId, String fofoStoreCode) {

		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;

		try {

			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoId);

			invoiceNumberGenerationSequence

					.setChallanNumberSequence(invoiceNumberGenerationSequence.getChallanNumberSequence() + 1);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();

			invoiceNumberGenerationSequence.setFofoId(fofoId);

			invoiceNumberGenerationSequence.setPrefix(fofoStoreCode);

			invoiceNumberGenerationSequence.setChallanNumberSequence(1);

		}

		invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);

		return invoiceNumberGenerationSequence.getPrefix() + "/SEC"

				+ invoiceNumberGenerationSequence.getChallanNumberSequence();

	}

	private Set<String> serialNumberDetailsToSerialNumbers(Set<SerialNumberDetail> serialNumberDetails) {

		Set<String> serialNumbers = new HashSet<>();

		for (SerialNumberDetail serialNumberDetail : serialNumberDetails) {

			if (serialNumberDetail.getSerialNumber() != null && !serialNumberDetail.getSerialNumber().isEmpty()) {

				serialNumbers.add(serialNumberDetail.getSerialNumber());

			}

		}

		return serialNumbers;

	}

	@Override

	public InvoicePdfModel getInvoicePdfModel(int orderId) throws ProfitMandiBusinessException {

		FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(orderId);

		return this.getInvoicePdfModel(fofoOrder);

	}

	@Override

	@Cacheable(value = "order.dummymodel", cacheManager = "oneDayCacheManager")

	public InvoicePdfModel getDummyPdfModel(String serialNumber) throws ProfitMandiBusinessException {

		List<WarehouseInventoryItem> warehouseInventoryItems = warehouseInventoryItemRepository

				.selectWarehouseInventoryItemBySerailNumbers(Arrays.asList(serialNumber));

		if (warehouseInventoryItems.size() > 0) {

			WarehouseInventoryItem warehouseInventoryItem = warehouseInventoryItems.get(0);

			int currentQuantity = warehouseInventoryItems.get(0).getCurrentQuantity();

			if (currentQuantity > 0) {

				throw new ProfitMandiBusinessException("Serial Number", serialNumber,

						"Serial Number exist in our warehouse");

			} else {

				try {

					InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumber(serialNumber);

					if (inventoryItem.getGoodQuantity() > 0) {

						throw new ProfitMandiBusinessException("Serial Number", serialNumber,

								"Serial Number is not yet billed by the partner");

					} else {

						List<ScanRecord> scanRecords = scanRecordRepository

								.selectByInventoryItemId(inventoryItem.getId());

						Optional<ScanRecord> scanRecord = scanRecords.stream().filter(x -> x.getOrderId() != 0)

								.findFirst();

						if (scanRecord.isPresent()) {

							FofoOrder fofoOrder = fofoOrderRepository.selectByOrderId(scanRecord.get().getOrderId());

							orderIdsConsumed.add(fofoOrder.getId());

							return this.getInvoicePdfModel(fofoOrder);

						} else {

							throw new ProfitMandiBusinessException("Serial Number", serialNumber,

									"Serial Number returned by partner, but in transit");

						}

					}

				} catch (Exception e) {

					int itemId = warehouseInventoryItem.getItemId();

					if (serialNumberOrderIdMap.containsKey(serialNumber)) {

						FofoOrder fofoOrder = fofoOrderRepository

								.selectByOrderId(serialNumberOrderIdMap.get(serialNumber));

						InvoicePdfModel pdfModel = this.getInvoicePdfModel(fofoOrder.getId());

						this.modifyDummyModel(fofoOrder, pdfModel, itemId, serialNumber);

						return pdfModel;

					}

					// Map this serialNumber for dummy billing

					LocalDateTime grnDate = warehouseInventoryItem.getCreated();

					Random random = new Random();

					int randomDays = random.ints(2, 15).findFirst().getAsInt();

					LocalDateTime saleDate = grnDate.plusDays(randomDays);

					if (saleDate.isAfter(LocalDate.now().atStartOfDay())) {

						saleDate = LocalDateTime.now().minusDays(2);

					}

					Random offsetRandom = new Random();

					int offset = offsetRandom.ints(2, 100).findFirst().getAsInt();

					FofoOrder fofoOrder = fofoOrderRepository.selectFirstOrderAfterDate(saleDate, offset);

					while (orderIdsConsumed.contains(fofoOrder.getId())) {

						Random offsetRandom2 = new Random();

						int offset2 = offsetRandom2.ints(2, 100).findFirst().getAsInt();

						FofoOrder fofoOrder2 = fofoOrderRepository.selectFirstOrderAfterDate(saleDate, offset2);

						if (fofoOrder2 != null) {

							fofoOrder = fofoOrder2;

						}

					}

					InvoicePdfModel pdfModel = this.getInvoicePdfModel(fofoOrder.getId());

					orderIdsConsumed.add(fofoOrder.getId());

					this.modifyDummyModel(fofoOrder, pdfModel, itemId, serialNumber);

					return pdfModel;

				}

			}

		} else {

			throw new ProfitMandiBusinessException("Serial Number", serialNumber,

					"Serial Number does not exist in our warehouse");

		}

	}

	void modifyDummyModel(FofoOrder fofoOrder, InvoicePdfModel pdfModel, int itemId, String serialNumber)

			throws ProfitMandiBusinessException {

		int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoOrder.getFofoId());

		Address retailerAddress = addressRepository.selectById(retailerAddressId);

		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

		CustomerAddress customerAddress = customer.getCustomerAddress().stream()

				.filter(x -> x.getId() == fofoOrder.getCustomerAddressId()).findFirst().get();

		Integer stateId = null;

		if (customerAddress.getState().equals(retailerAddress.getState())) {

			try {

				// stateId =

				// Long.valueOf(Utils.getStateInfo(customerAddress.getState()).getId()).intValue();

				stateId = Long.valueOf(stateRepository.selectByName(customerAddress.getState()).getId()).intValue();

			} catch (Exception e) {

				LOGGER.error("Unable to get state rates");

			}

		}

		CustomOrderItem cli = pdfModel.getOrderItems().stream().findFirst().get();

		List<FofoOrderItem> fofoOrderItems = Arrays

				.asList(this.getDummyFofoOrderItem(itemId, fofoOrder.getId(), serialNumber, stateId));

		pdfModel.setPaymentOptions(pdfModel.getPaymentOptions().stream().limit(1).collect(Collectors.toList()));

		CustomPaymentOption paymentOption = pdfModel.getPaymentOptions().get(0);

		paymentOption.setAmount(fofoOrderItems.get(0).getMop());

		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();

		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

			CustomOrderItem customFofoOrderItem = new CustomOrderItem();

			float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate()

					+ fofoOrderItem.getCgstRate();

			float taxableSellingPrice = fofoOrderItem.getSellingPrice() / (1 + totalTaxRate / 100);

			float taxableDiscountPrice = fofoOrderItem.getDiscount() / (1 + totalTaxRate / 100);

			customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));

			customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "

					+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());

			Set<String> serialNumbers = this.toSerialNumbers(fofoOrderItem.getFofoLineItems());

			// LOGGER.info("serialNumbers {}", serialNumbers);

			// LOGGER.info("serialNumbers is empty {}", serialNumbers.isEmpty());

			if (!serialNumbers.isEmpty()) {

				customFofoOrderItem.setDescription(

						customFofoOrderItem.getDescription() + "\n IMEIS - " + String.join(", ", serialNumbers));

			}

			customFofoOrderItem.setRate(taxableSellingPrice);

			customFofoOrderItem.setDiscount(taxableDiscountPrice);

			customFofoOrderItem.setQuantity(fofoOrderItem.getQuantity());

			customFofoOrderItem.setNetAmount(

					(fofoOrderItem.getSellingPrice() - fofoOrderItem.getDiscount()) * fofoOrderItem.getQuantity());

			float igstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getIgstRate()) / 100;

			float cgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getCgstRate()) / 100;

			float sgstAmount = (customFofoOrderItem.getAmount() * fofoOrderItem.getSgstRate()) / 100;

			customFofoOrderItem.setIgstRate(fofoOrderItem.getIgstRate());

			customFofoOrderItem.setIgstAmount(igstAmount);

			customFofoOrderItem.setCgstRate(fofoOrderItem.getCgstRate());

			customFofoOrderItem.setCgstAmount(cgstAmount);

			customFofoOrderItem.setSgstRate(fofoOrderItem.getSgstRate());

			customFofoOrderItem.setSgstAmount(sgstAmount);

			customFofoOrderItem.setHsnCode(fofoOrderItem.getHsnCode());

			customerFofoOrderItems.add(customFofoOrderItem);

		}

		pdfModel.setTotalAmount(paymentOption.getAmount());

		pdfModel.setOrderItems(customerFofoOrderItems);

	}

	private InvoicePdfModel getInvoicePdfModel(FofoOrder fofoOrder) throws ProfitMandiBusinessException {

		List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository

				.selectByReferenceIdAndTypes(fofoOrder.getId(),

						Arrays.asList(PaymentOptionReferenceType.ORDER, PaymentOptionReferenceType.INSURANCE));

		List<CustomPaymentOption> paymentOptions = new ArrayList<>();

		InvoicePdfModel pdfModel = new InvoicePdfModel();

		for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {

			CustomPaymentOption cpi = new CustomPaymentOption();

			cpi.setAmount(paymentOptionTransaction.getAmount());

			cpi.setPaymentOption(

					paymentOptionRepository.selectById(paymentOptionTransaction.getPaymentOptionId()).getName());

			paymentOptions.add(cpi);

		}

		List<FofoOrderItem> fofoOrderItems = this.getByOrderId(fofoOrder.getId());

		pdfModel.setTitle("Retailer Invoice");

		Optional<FofoOrderItem> fofoOrderItemOptional = fofoOrderItems.stream().findAny();

		if (fofoOrderItemOptional.isPresent() && fofoOrderItemOptional.get().equals("NOGST")) {

			pdfModel.setTitle("Security Deposit Receipt");

		}

		pdfModel.setPaymentOptions(paymentOptions);

		pdfModel.setAuther("SmartDukaan");

		pdfModel.setInvoiceDate(FormattingUtils.formatDate(fofoOrder.getCreateTimestamp()));

		// insurance calculation

		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

				.selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

		Set<CustomInsurancePolicy> customInsurancePolicies = new HashSet<>();

		final float totalInsuranceTaxRate = 18;

		for (InsurancePolicy insurancePolicy : insurancePolicies) {

			float taxableInsurancePrice = insurancePolicy.getSaleAmount() / (1 + totalInsuranceTaxRate / 100);

			CustomInsurancePolicy customInsurancePolicy = new CustomInsurancePolicy();

			customInsurancePolicy.setDescription(insurancePolicy.getPolicyPlan() + " for Device #"

					+ insurancePolicy.getSerialNumber() + "\n Plan Reference - " + insurancePolicy.getPolicyNumber());

			customInsurancePolicy.setHsnCode("998716");

			customInsurancePolicy.setRate(taxableInsurancePrice);

			customInsurancePolicy.setIgstRate(18);

			customInsurancePolicy.setIgstAmount(taxableInsurancePrice * 18 / 100);

			customInsurancePolicy.setCgstRate(9);

			customInsurancePolicy.setCgstAmount(taxableInsurancePrice * 9 / 100);

			customInsurancePolicy.setSgstRate(9);

			customInsurancePolicy.setSgstAmount(taxableInsurancePrice * 9 / 100);

			customInsurancePolicy.setNetAmount(insurancePolicy.getSaleAmount());

			customInsurancePolicies.add(customInsurancePolicy);

		}

		pdfModel.setInsurancePolicies(customInsurancePolicies);

		pdfModel.setCustomer(getCustomCustomer(fofoOrder));

		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());

		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());

		Retailer retailer = retailerRepository.selectById(fofoOrder.getFofoId());

		PrivateDealUser privateDealUser = null;

		try {

			privateDealUser = privateDealUserRepository.selectById(retailer.getId());

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			LOGGER.error("Private Deal User not found : ", profitMandiBusinessException);

		}

		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));

		CustomRetailer customRetailer = new CustomRetailer();

		customRetailer.setBusinessName(retailer.getName());

		customRetailer.setMobileNumber(user.getMobileNumber());

		// customRetailer.setTinNumber(retailer.getNumber());

		if (privateDealUser == null) {

			customRetailer.setGstNumber(null);

		} else {

			if (null != privateDealUser.getCounterId()) {

				Counter counter = counterRepository.selectById(privateDealUser.getCounterId());

				customRetailer.setGstNumber(counter.getGstin());

			} else {

				customRetailer.setGstNumber(null);

			}

		}

		Address retailerAddress = addressRepository

				.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));

		customRetailer.setAddress(this.createCustomAddress(retailerAddress));

		pdfModel.setRetailer(customRetailer);

		Set<CustomOrderItem> customerFofoOrderItems = new HashSet<>();

		for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

			float discount = fofoOrderItem.getDiscount();

			CustomOrderItem customFofoOrderItem = new CustomOrderItem();

			float totalTaxRate = fofoOrderItem.getIgstRate() + fofoOrderItem.getSgstRate()

					+ fofoOrderItem.getCgstRate();

			float taxableSellingPrice = (fofoOrderItem.getSellingPrice() + discount) / (1 + totalTaxRate / 100);

			float taxableDiscountPrice = discount / (1 + totalTaxRate / 100);

			customFofoOrderItem.setAmount(fofoOrderItem.getQuantity() * (taxableSellingPrice - taxableDiscountPrice));

			customFofoOrderItem.setDescription(fofoOrderItem.getBrand() + " " + fofoOrderItem.getModelName() + " "

					+ fofoOrderItem.getModelNumber() + "-" + fofoOrderItem.getColor());

			Set<String> serialNumbers = this.toSerialNumbers(fofoOrderItem.getFofoLineItems());

			// LOGGER.info("serialNumbers {}", serialNumbers);