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(fofoId, itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);

        } else {

            this.validateMopPrice(fofoId, 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 = null;

        if (customCustomer.getCustomerAddressId() != 0) {

            customerAddress = customer.getCustomerAddress().stream().filter(x -> x.getId() == customCustomer.getCustomerAddressId()).findFirst().get();

        }

        FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId, documentNumber, totalAmount, customCustomer.getCustomerAddressId());

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

        int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);

        Address retailerAddress = addressRepository.selectById(retailerAddressId);

        Integer stateId = null;

        if (customerAddress == null || customerAddress.getState() == null || customerAddress.getState().equals(retailerAddress.getState())) {

            try {

                State state = stateRepository.selectByName(retailerAddress.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 = ProfitMandiConstants.SCRATCH_OFFER_START_DATE;

        LocalDate endDate = ProfitMandiConstants.SCRATCH_OFFER_END_DATE;

        if (smartPhone) {

            if (LocalDateTime.now().isAfter(startDate.atStartOfDay()) && LocalDateTime.now().isBefore(endDate.atTime(Utils.MAX_TIME))) {

                try {

                    this.sendAppDownloadBillingOffer(customer.getMobileNumber());

                } catch (Exception e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                this.createScratchOffer(fofoId, 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(int fofoId, String invoiceNumber, int customerId) {

        //ScratchedGift gift = getScratchedGiftRandom(fofoId, customerId);

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

        List<ScratchOffer> scratchOffers = scratchOfferRepository.selectBycCustomerIdAndDate(customerId, ProfitMandiConstants.SCRATCH_OFFER_START_DATE, ProfitMandiConstants.SCRATCH_OFFER_END_DATE);

        if (scratchOffers.size() == 0) {

            ScratchOffer so2 = new ScratchOffer();

            so2.setInvoiceNumber(invoiceNumber);

            so2.setScratched(false);

            so2.setCreatedTimestamp(LocalDateTime.now());

            so2.setExpiredTimestamp(LocalDateTime.now().plusDays(1));

            so2.setOfferName(ScratchedGift.BLNT);

            so2.setCustomerId(customerId);

            LocalDateTime today830PM = LocalDate.now().atTime(20, 30);

            LocalDateTime today9PM = LocalDate.now().atTime(21, 0);

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

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

            } else {

                so2.setUnlockedAt(today9PM);

            }

            scratchOfferRepository.persist(so2);

        }

    }

    private ScratchedGift getScratchedGiftRandom(int fofoId, int customerId) {

        Map<Integer, ScratchedGift> giftSeries = new HashMap<>();

        giftSeries.put(1, ScratchedGift.MINI_CHOPPER);

        giftSeries.put(2, ScratchedGift.FRUIT_JUICER);

        giftSeries.put(3, ScratchedGift.STEAM_IRON);

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(fofoId, ProfitMandiConstants.SCRATCH_OFFER_START_DATE.atStartOfDay(),

                ProfitMandiConstants.SCRATCH_OFFER_END_DATE.atTime(Utils.MAX_TIME));

        ScratchedGift gift = ScratchedGift.BLNT;

        Random random = new Random();

        int rand = 0;

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

        while (true) {

            rand = random.nextInt(4);

            if (rand != 0) break;

        }

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

        if (fofoOrders.isEmpty()) {

            gift = giftSeries.get(rand);

            LOGGER.info("gift11 {}", gift);

        } else {

            List<String> invoiceNumbers = fofoOrders.stream().filter(x -> x.getCancelledTimestamp() == null).map(x -> x.getInvoiceNumber()).collect(Collectors.toList());

            List<ScratchOffer> scratchOffers = scratchOfferRepository.selectByInvoiceNumbers(invoiceNumbers);

            if (scratchOffers.isEmpty()) {

                gift = giftSeries.get(rand);

            } else {

                List<ScratchOffer> bigGifts = scratchOffers.stream().filter(x -> !x.getOfferName().equals(ScratchedGift.BLNT) && !x.getOfferName().equals(ScratchedGift.EW)).collect(Collectors.toList());

                if (bigGifts.size() <= 10) {

                    List<Integer> scratchCustomerIds = scratchOffers.stream().map(x -> x.getCustomerId()).collect(Collectors.toList());

                    if (scratchCustomerIds.contains(customerId)) {

                        gift = ScratchedGift.BLNT;

                        LOGGER.info("gift2 {}", gift);

                    } else {

                        int miniChopper = (int) bigGifts.stream().filter(x -> x.getOfferName().equals(ScratchedGift.MINI_CHOPPER)).count();

                        int fruitJuicer = (int) bigGifts.stream().filter(x -> x.getOfferName().equals(ScratchedGift.FRUIT_JUICER)).count();

                        int streanIron = (int) bigGifts.stream().filter(x -> x.getOfferName().equals(ScratchedGift.STEAM_IRON)).count();

                        if (rand == 1) {

                            if (miniChopper < 4) {

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

                                gift = giftSeries.get(rand);

                            }

                        }

                        if (rand == 2) {

                            if (fruitJuicer < 3) {

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

                                gift = giftSeries.get(rand);

                            }

                        }

                        if (rand == 3) {

                            if (streanIron < 3) {

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

                                gift = giftSeries.get(rand);

                            }

                        }

                        LOGGER.info("gift4 {}", gift);

                    }

                }

            }

        }

        return gift;

    }

    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());