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

            // 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.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.setOrderItems(customerFofoOrderItems);

        String partnerAddressStateCode = stateRepository.selectByName(pdfModel.getRetailer().getAddress().getState()).getCode();

        String customerAddressStateCode = stateRepository.selectByName(pdfModel.getCustomer().getAddress().getState()).getCode();

        pdfModel.setPartnerAddressStateCode(partnerAddressStateCode);

        pdfModel.setCustomerAddressStateCode(customerAddressStateCode);

        pdfModel.setCancelled(fofoOrder.getCancelledTimestamp() != null);

        List<String> tncs = new ArrayList<>();

        tncs.add("I agree that goods received are in good working condition");

        tncs.add("Goods once sold cannot be exchanged or taken back");

        tncs.add("Warranty for the goods received by me is the responsibility of the manufacturer only.");

        tncs.add("Customer needs to activate the handset at the time of delivery to be eligible for the discount");

        tncs.add(

                "Tempered Glass Replacement will be done only for the Mobile Phone which was purchased from SmartDukaan");

        tncs.add(

                "Customers requesting Tempered Glass Replacement will have to bring the broken tempered glass, either pasted on the phone or along with the phone");

        tncs.add("Service fee of Rs.20 will be chargeable for each Tempered Glass Replacement");

        if (pdfModel.getInsurancePolicies() != null && pdfModel.getInsurancePolicies().size() > 0) {

            tncs.add("Damage protection provided is the responisibility of Protection Provider only");

        }

        pdfModel.setTncs(tncs);

        return pdfModel;

    }

    private CustomCustomer getCustomCustomer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {

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

        CustomCustomer customCustomer = new CustomCustomer();

        customCustomer.setFirstName(customer.getFirstName());

        customCustomer.setLastName(customer.getLastName());

        customCustomer.setEmailId(customer.getEmailId());

        customCustomer.setMobileNumber(customer.getMobileNumber());

        customCustomer.setGstNumber(fofoOrder.getCustomerGstNumber());

        CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

        customCustomer.setAddress(this.createCustomAddress(customerAddress));

        return customCustomer;

    }

    @Override

    public InvoicePdfModel getInvoicePdfModel(int fofoId, int orderId) throws ProfitMandiBusinessException {

        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoId, orderId);

        return this.getInvoicePdfModel(fofoOrder);