Subversion Repositories SmartDukaan

Rev

Rev 31230 | Rev 31461 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package com.smartdukaan.cron.migrations;

import com.google.gson.Gson;
import com.smartdukaan.cron.scheduled.OppoImeiActivationService;
import com.smartdukaan.cron.scheduled.SamsungIMEIActivationService;
import com.smartdukaan.cron.scheduled.ScheduledTasks;
import com.smartdukaan.cron.scheduled.amazon.shop.AmazonPurchaseService;
import com.spice.profitmandi.common.enumuration.ItemType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.common.model.ImeiDropSummaryModel;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.services.mandii.*;
import com.spice.profitmandi.common.util.FileUtil;
import com.spice.profitmandi.common.util.FormattingUtils;
import com.spice.profitmandi.common.util.Utils;
import com.spice.profitmandi.dao.cart.CartService;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.catalog.Offer;
import com.spice.profitmandi.dao.entity.catalog.Scheme;
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.SaholicInventorySnapshot;
import com.spice.profitmandi.dao.entity.inventory.SaholicReservationSnapshot;
import com.spice.profitmandi.dao.entity.inventory.VendorItemPricing;
import com.spice.profitmandi.dao.entity.inventory.Warehouse;
import com.spice.profitmandi.dao.entity.transaction.*;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.entity.user.User;
import com.spice.profitmandi.dao.entity.warehouse.BrandRegionMapping;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;
import com.spice.profitmandi.dao.entity.warehouse.WarehouseScan;
import com.spice.profitmandi.dao.enumuration.catalog.AmountType;
import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;
import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;
import com.spice.profitmandi.dao.enumuration.fofo.Gateway;
import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
import com.spice.profitmandi.dao.enumuration.transaction.PriceDropImeiStatus;
import com.spice.profitmandi.dao.model.*;
import com.spice.profitmandi.dao.repository.GenericRepository;
import com.spice.profitmandi.dao.repository.catalog.*;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.dtr.*;
import com.spice.profitmandi.dao.repository.fofo.*;
import com.spice.profitmandi.dao.repository.inventory.SaholicInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.inventory.SaholicReservationSnapshotRepository;
import com.spice.profitmandi.dao.repository.inventory.VendorItemPricingRepository;
import com.spice.profitmandi.dao.repository.inventory.WarehouseRepository;
import com.spice.profitmandi.dao.repository.transaction.*;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
import com.spice.profitmandi.dao.repository.user.CartRepository;
import com.spice.profitmandi.dao.repository.user.FofoKycRepository;
import com.spice.profitmandi.dao.repository.user.UserRepository;
import com.spice.profitmandi.dao.repository.warehouse.BrandRegionMappingRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;
import com.spice.profitmandi.service.integrations.bharti.BAGService;
import com.spice.profitmandi.service.integrations.bharti.model.Sample;
import com.spice.profitmandi.service.integrations.gstpro.GstProAuthService;
import com.spice.profitmandi.service.integrations.gstpro.GstProService;
import com.spice.profitmandi.service.integrations.oneassist.OneAssistService;
import com.spice.profitmandi.service.integrations.zest.InsuranceService;
import com.spice.profitmandi.service.inventory.InventoryService;
import com.spice.profitmandi.service.inventory.PurchaseService;
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
import com.spice.profitmandi.service.offers.ItemCriteria;
import com.spice.profitmandi.service.offers.OfferService;
import com.spice.profitmandi.service.offers.PartnerCriteria;
import com.spice.profitmandi.service.order.OrderService;
import com.spice.profitmandi.service.pricing.PriceDropService;
import com.spice.profitmandi.service.scheme.SchemeService;
import com.spice.profitmandi.service.transaction.TransactionService;
import com.spice.profitmandi.service.transaction.invoicing.InvoiceService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.service.wallet.CommonPaymentService;
import com.spice.profitmandi.service.wallet.WalletService;
import com.spice.profitmandi.service.warehouse.WarehouseInventoryService;
import in.shop2020.model.v1.order.OrderStatus;
import in.shop2020.model.v1.order.WalletReferenceType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import org.apache.commons.csv.CSVRecord;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.lang.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONObject;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Component
@Transactional(rollbackFor = Throwable.class)
public class RunOnceTasks {

        private static final Logger LOGGER = LogManager.getLogger(RunOnceTasks.class);
        @Autowired
        private LineItemRepository lineItemRepository;

        @Autowired
        private LeadRepository leadRepository;

        @Autowired
        InsuranceService insuranceService;

        @Autowired
        private VendorItemPricingRepository vendorItemPricingRepository;

        @Autowired
        private WarehouseRepository warehouseRepository;

        @Autowired
        private PurchaseReturnItemRepository purchaseReturnItemRepository;

        @Autowired
        private SaholicInventorySnapshotRepository saholicInventorySnapshotRepository;

        @Autowired
        private CsService csService;

        @Autowired
        private ManualPaymentRequestRepository manualPaymentRequestRepository;

        @Autowired
        private OfferRepository offerRepository;

        @Autowired
        private Mongo mongoClient;

        @Autowired
        private Gson gson;

        @Autowired
        private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

        @Autowired
        private OppoImeiActivationService oppoImeiActivationService;

        @Autowired
        private SamsungIMEIActivationService samsungIMEIActivationService;

        @Autowired
        private PrebookingOrderRepository prebookingOrderRepository;

        @Autowired
        private PartnerTargetRepository partnerTargetRepository;

        @Autowired
        private SellerWarehouseRepository sellerWarehouseRepository;

        @Autowired
        private FofoOrderItemRepository fofoOrderItemRepository;

        @Autowired
        private FofoLineItemRepository fofoLineItemRepository;

        @Autowired
        private FofoOrderRepository fofoOrderRepository;

        @Autowired
        private UserWalletRepository userWalletRepository;

        @Autowired
        private UserWalletHistoryRepository userWalletHistoryRepository;

        @Autowired
        private UserRepository userRepository;

        @Autowired
        private WalletService walletService;

        @Autowired
        private ItemRepository itemRepository;

        @Autowired
        private InventoryService inventoryService;

        @Autowired
        private TransactionService transactionService;

        @Autowired
        private PurchaseService purchaseService;

        // Service for Tertiary/Partner Orders
        @Autowired
        private OrderService orderService;

        @Autowired
        private SchemeRepository schemeRepository;

        @Autowired
        private AddressRepository addressRepository;

        @Autowired
        private ScheduledTasks scheduledTasks;

        @Autowired
        private SchemeItemRepository schemeItemRepository;

        @Autowired
        private ReturnOrderRepository returnOrderRepository;

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private LineItemImeisRepository lineItemImeisRepository;

        @Autowired
        private InventoryItemRepository inventoryItemRepository;

        @Autowired
        private TagListingRepository tagListingRepository;

        @Autowired
        private InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;

        @Autowired
        private RetailerService retailerService;

        @Autowired
        private SchemeInOutRepository schemeInOutRepository;

        @Autowired
        private DebitNoteRepository debitNoteRepository;

        @Autowired
        private OfferService offerService;

        @Autowired
        private GenericRepository genericRepository;

        @Autowired
        private PurchaseRepository purchaseRepository;

        @Autowired
        private PriceDropService priceDropService;

        @Autowired
        private JavaMailSender googleMailSender;

        @Autowired
        private SchemeService schemeService;

        @Autowired
        private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

        @Autowired
        private OrderRepository orderRepository;

        @Autowired
        private ScanRecordRepository scanRecordRepository;

        @Autowired
        private JavaMailSender mailSender;

        private static final String ACCOUNT_ID = "aZ6flHhrgPIEl18buHdPBdueEN4";
        private static final String SECRET_KEY = "a7rsX5B4UNNfTTx1-IJ19qdH48BT4YvBKlQJg3n3_KKNe7WWych55g";

        @Autowired
        private WarehouseInventoryItemRepository warehouseInventoryItemRepository;

        public void populateGrnTimestamp() {
                List<Purchase> allPurchases = purchaseRepository.selectAll();
                for (Purchase p : allPurchases) {
                        String invoiceNumber = p.getPurchaseReference();
                        if (p.getCompleteTimestamp() == null) {
                                LOGGER.info("GRN for invoice {} is delivered but partially Completed.", p.getPurchaseReference());
                        } else {
                                List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(invoiceNumber, p.getFofoId());
                                for (Order order : orders) {
                                        if (order.getPartnerGrnTimestamp() == null) {
                                                order.setPartnerGrnTimestamp(p.getCompleteTimestamp());
                                        }
                                }
                        }
                }

        }

        public void fetchImeiActivation(int ym) throws Exception {
                LocalDate startDate = null;
                LocalDate endDate = null;
                if (ym == 0) {
                        startDate = LocalDate.now().minusDays(30);
                        endDate = LocalDate.now();
                } else {
                        startDate = LocalDate.now().minusMonths(ym);
                        endDate = startDate.plusMonths(1);
                }
                samsungIMEIActivationService.getActivationsBetweenNew(startDate, endDate);
        }

        public void cancelOrder(List<String> invoiceNumbers) throws Exception {
                orderService.cancelOrder(invoiceNumbers);
        }

        @Autowired
        HdfcPaymentRepository hdfcPaymentRepository;

        public void addPayment() throws Exception {
                List<Integer> paymentIds = Arrays.asList(3777);
                for (int hdfcPaymentId : paymentIds) {
                        HdfcPayment hdfcPayment = hdfcPaymentRepository.selectById(hdfcPaymentId);
                        String virtualAccount = hdfcPayment.getVirtualAccount();
                        String retailerIdString = virtualAccount.substring(6);
                        int retailerId = Integer.parseInt(retailerIdString);
                        String description = String.format("Advance payment received through %s, Utr# %s",
                                        hdfcPayment.getTransferMode(), hdfcPayment.getUtr());
                        walletService.addAmountToWallet(retailerId, hdfcPayment.getId(), WalletReferenceType.AUTOMATED_ADVANCE,
                                        description, (float) hdfcPayment.getAmount(), hdfcPayment.getCreditTimestamp());
                }
        }

        // Bug in original migrate purchase
        public void migratePurchase() throws Exception {
                List<Purchase> purchases = purchaseRepository.selectPurchaseAllPurchasesLessThanZero();
                for (Purchase purchase : purchases) {
                        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchase.getId());
                        for (InventoryItem ii : inventoryItems) {
                                List<ScanRecord> scans = scanRecordRepository.selectByInventoryItemId(ii.getId());
                                if (scans.size() == 1 && scans.get(0).getQuantity() == 0) {
                                        scanRecordRepository.delete(scans.get(0));
                                        purchase.setNonSerializedQuantity(purchase.getNonSerializedQuantity() - ii.getInitialQuantity());
                                        inventoryItemRepository.delete(ii);
                                }

                        }

                }
        }

        public void migratePurchaseFix() throws Exception {
                List<Purchase> purchases = purchaseRepository.selectPurchaseAllPurchasesLessThanZero();
                System.out.printf("Total Purchases count is %s", purchases.size());
                for (Purchase purchase : purchases) {
                        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchase.getId());
                        Map<Integer, List<InventoryItem>> itemIdInventoryMap = inventoryItems.stream()
                                        .collect(Collectors.groupingBy(InventoryItem::getItemId));
                        List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(purchase.getPurchaseReference(),
                                        purchase.getFofoId());
                        Map<Integer, Integer> ourSaleItemQtyMap = orders.stream().collect(Collectors.groupingBy(
                                        x -> x.getLineItem().getItemId(), Collectors.summingInt(x -> x.getLineItem().getQuantity())));
                        Map<Integer, Integer> theirPurchaseItemQtyMap = inventoryItems.stream().collect(Collectors
                                        .groupingBy(InventoryItem::getItemId, Collectors.summingInt(InventoryItem::getInitialQuantity)));
                        for (Map.Entry<Integer, Integer> itemQtyEntry : theirPurchaseItemQtyMap.entrySet()) {
                                if (!ourSaleItemQtyMap.containsKey(itemQtyEntry.getKey())) {
                                        LOGGER.info("Cannot find in Invoice {} item {}", purchase.getPurchaseReference(),
                                                        itemQtyEntry.getKey());
                                        continue;
                                }
                                int ourSale = ourSaleItemQtyMap.get(itemQtyEntry.getKey());
                                int quantityToReduce = itemQtyEntry.getValue() - ourSale;
                                List<InventoryItem> itemIis = itemIdInventoryMap.get(itemQtyEntry.getKey());
                                if (itemIdInventoryMap != null) {
                                        for (InventoryItem ii : itemIis) {
                                                if (ii.getSerialNumber() == null && ii.getGoodQuantity() == ii.getInitialQuantity()
                                                                && quantityToReduce >= ii.getInitialQuantity()) {
                                                        LOGGER.info("Changed in inventoryItems {}, {}, {}, {}, {}, {}",
                                                                        purchase.getPurchaseReference(), ii.getId(), ii.getItemId(),
                                                                        ii.getInitialQuantity(), ii.getGoodQuantity(), quantityToReduce);
                                                        List<ScanRecord> scanRecords = scanRecordRepository.selectByInventoryItemId(ii.getId());
                                                        for (ScanRecord scanRecord : scanRecords) {
                                                                CurrentInventorySnapshot cis = currentInventorySnapshotRepository
                                                                                .selectByItemIdAndFofoId(itemQtyEntry.getKey(), purchase.getFofoId());
                                                                scanRecord.setQuantity(0);
                                                                ii.setGoodQuantity(0);
                                                                quantityToReduce = quantityToReduce - ii.getInitialQuantity();
                                                                cis.setAvailability(cis.getAvailability() - ii.getInitialQuantity());
                                                                purchase.setUnfullfilledNonSerializedQuantity(
                                                                                purchase.getUnfullfilledNonSerializedQuantity() + quantityToReduce);
                                                                LOGGER.info("Rectified {}, {}, {}, {}, {}, {}", purchase.getPurchaseReference(),
                                                                                ii.getId(), ii.getItemId(), ii.getInitialQuantity(), ii.getGoodQuantity(),
                                                                                quantityToReduce);
                                                        }
                                                }
                                        }
                                }
                        }
                }
                // throw new Exception();
        }

        public void migrateChallansToInvoices() throws Exception {
                Map<String, List<Order>> invoiceOrdersMap = orderRepository.selectAllChallans().stream()
                                .filter(x -> !x.getLineItem().getHsnCode().equals("NOGST"))
                                .collect(Collectors.groupingBy(Order::getInvoiceNumber, Collectors.toList()));

                List<List<?>> rows = new ArrayList<>();
                for (String invoice : invoiceOrdersMap.keySet()) {
                        Order oneOrder = invoiceOrdersMap.get(invoice).get(0);
                        int totalOrders = invoiceOrdersMap.get(invoice).size();
                        LineItem lineItem = oneOrder.getLineItem();
                        oneOrder.setBillingTimestamp(LocalDateTime.now());
                        oneOrder.setInvoiceNumber(getInvoiceNumber(oneOrder));
                        rows.add(Arrays.asList(oneOrder.getId(), invoice, oneOrder.getInvoiceNumber(), lineItem.getQuantity()));
                        LOGGER.info(invoice + "\t" + oneOrder.getInvoiceNumber() + oneOrder.getId() + "\t",
                                        "\t" + totalOrders + "\t" + lineItem.getQuantity());
                        Purchase p = null;
                        try {
                                p = purchaseRepository.selectByPurchaseReferenceAndFofoId(invoice, oneOrder.getRetailerId());
                        } catch (Exception e) {
                                LOGGER.info("Could not find purchase for invoice {}", invoice);
                        }
                        if (p != null) {
                                List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(p.getId());
                                for (InventoryItem inventoryItem : inventoryItems) {
                                        LOGGER.info(inventoryItem.getItemId() + " " + inventoryItem.getGoodQuantity() + " "
                                                        + inventoryItem.getHsnCode() + " " + inventoryItem.getSerialNumber() + " "
                                                        + p.getPurchaseReference());
                                }
                        }

                }
                changePartnerInvoices();
                ByteArrayOutputStream baos = FileUtil
                                .getCSVByteStream(Arrays.asList("Order id", "Challan", "Invoice", "Quantity"), rows);

                Utils.sendMailWithAttachment(googleMailSender,
                                new String[]{"amit.gupta@shop2020.in", "sunny.yadav@smartdukaan.com"}, null,
                                "Challans Converted to Invoice", "PFA", "Challans-To-Invoice.csv",
                                new ByteArrayResource(baos.toByteArray()));
                throw new Exception();
        }

        private String getInvoiceNumber(Order oneOrder) {
                String prefix = oneOrder.getInvoiceNumber().split("-")[1].replaceAll("\\d*", "");
                System.out.println("Prefix is " + prefix);
                SellerWarehouse sellerWarehouse = sellerWarehouseRepository.selectByPrefix(prefix);
                int newSequence = sellerWarehouse.getInvoiceSequence() + 1;
                sellerWarehouse.setInvoiceSequence(newSequence);
                return prefix + newSequence;
        }

        private void changePartnerInvoices() throws Exception {
                List<FofoOrder> fofoOrders = fofoOrderRepository.selectByInvoiceNumberLike("%SEC%");
                for (FofoOrder fofoOrder : fofoOrders) {
                        FofoOrderItem fofoOrderItem = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId()).get(0);
                        if (fofoOrderItem.getBrand().equals("Vivo")) {
                                String challanString = fofoOrder.getInvoiceNumber();
                                String storeCode = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoOrder.getFofoId())
                                                .getPrefix();
                                String invoiceNumber = orderService.getInvoiceNumber(fofoOrder.getFofoId(), storeCode);
                                fofoOrder.setInvoiceNumber(invoiceNumber);
                                fofoOrder.setCreateTimestamp(LocalDateTime.now());
                                LOGGER.info(challanString + "\t" + invoiceNumber + "\t" + fofoOrderItem.getQuantity());
                        }

                }
        }

        private Scheme getScheme() {
                Scheme s = new Scheme();
                s.setName("List Price Margin");
                s.setDescription("List Price Margin");
                s.setActiveTimestamp(null);
                s.setStartDateTime(LocalDate.of(2019, 6, 1).atStartOfDay());
                s.setEndDateTime(LocalDate.of(2019, 7, 1).atStartOfDay());
                s.setAmountType(AmountType.PERCENTAGE);
                s.setCreateTimestamp(LocalDateTime.now());
                s.setExpireTimestamp(null);
                s.setCreatedBy(175120474);
                return s;
        }

        public void findMismatchesInIndent() throws Exception {
                List<Order> allInProcessOrders = orderRepository.selectAllOrder(OrderStatus.SUBMITTED_FOR_PROCESSING);

                Map<String, Integer> lineItemWhQtyMap = allInProcessOrders.stream()
                                .collect(Collectors.groupingBy(y -> y.getLineItem().getItemId() + "-" + y.getFulfilmentWarehouseId(),
                                                Collectors.summingInt(y -> y.getLineItem().getQuantity())));

                lineItemWhQtyMap.forEach((key, value) -> {

                        int itemId = Integer.parseInt(key.split("-")[0]);
                        int warehouseId = Integer.parseInt(key.split("-")[1]);
                        System.out.printf("%d\t%d\t%d\n", itemId, warehouseId, value);
                        SaholicInventorySnapshot cis = saholicInventorySnapshotRepository.selectByWarehouseIdandItemId(warehouseId,
                                        itemId);
                        if (cis == null) {
                                cis = new SaholicInventorySnapshot();
                                cis.setItemId(itemId);
                                cis.setWarehouseId(warehouseId);
                                cis.setAvailability(0);
                                saholicInventorySnapshotRepository.persist(cis);
                        }
                        cis.setReserved(value);
                });
        }

        public void fixSchemePayouts() throws Exception {
                LOGGER.info("In fix scheme Payouts");
                LocalDateTime startDate = LocalDate.of(2019, 9, 1).atStartOfDay();
                List<SchemeInOut> sios = schemeInOutRepository.selectAllByCreateDate(startDate, LocalDateTime.now());

                for (SchemeInOut sio : sios) {
                        if (sio.getSchemeId() != 347) {
                                LOGGER.info("Skipping {}", sio.getSchemeId());
                                continue;
                        }
                        genericRepository.delete(sio);
                        InventoryItem ii = inventoryItemRepository.selectById(sio.getInventoryItemId());
                        UserWallet userWallet = userWalletRepository.selectByRetailerId(ii.getFofoId());
                        Scheme scheme = schemeRepository.selectById(sio.getSchemeId());
                        if (scheme.getType().equals(SchemeType.IN)) {
                                List<UserWalletHistory> historyList = userWalletHistoryRepository
                                                .selectAllByreferenceIdandreferenceType(ii.getPurchaseId(), WalletReferenceType.SCHEME_IN);
                                for (UserWalletHistory uwh : historyList) {
                                        if (uwh.getTimestamp().isAfter(startDate)) {
                                                genericRepository.delete(uwh);
                                                userWallet.setAmount(userWallet.getAmount() - uwh.getAmount());
                                        }
                                }
                        } else {
                                List<ScanRecord> scanRecords = scanRecordRepository.selectByInventoryItemId(ii.getId());
                                int orderId = scanRecords.get(0).getOrderId();
                                List<UserWalletHistory> historyList = userWalletHistoryRepository
                                                .selectAllByreferenceIdandreferenceType(orderId, WalletReferenceType.SCHEME_OUT);
                                for (UserWalletHistory uwh : historyList) {
                                        if (uwh.getTimestamp().isAfter(startDate)) {
                                                userWallet.setAmount(userWallet.getAmount() - uwh.getAmount());
                                                genericRepository.delete(uwh);
                                        }
                                }
                                List<UserWalletHistory> historyListBroken = userWalletHistoryRepository
                                                .selectAllByreferenceIdandreferenceType(ii.getPurchaseId(), WalletReferenceType.SCHEME_OUT);
                                for (UserWalletHistory uwh : historyListBroken) {
                                        if (uwh.getTimestamp().isAfter(startDate)) {
                                                genericRepository.delete(uwh);
                                                userWallet.setAmount(userWallet.getAmount() - uwh.getAmount());
                                        }
                                }
                        }

                        // System.out.println("Total Amount Rolled Back is " + totalRollbackAmount);
                }
                scheduledTasks.processScheme(startDate, startDate.plusDays(10), true);
        }

        public void fixWallet() throws Exception {
                List<FofoStore> fofoStores = fofoStoreRepository.selectAll();
                System.out.println("id\tcode\tactive\tname\tcity\tstate\twallet amount\tsum\twallet amount-sum");
                for (FofoStore fofoStore : fofoStores) {
                        UserWallet uw = userWalletRepository.selectByRetailerId(fofoStore.getId());
                        User user = userRepository.selectById(fofoStore.getId());
                        if (user == null) {
                                LOGGER.info("store does not exist", fofoStore.getCode());
                                continue;
                        }
                        Address address = null;
                        try {
                                address = addressRepository.selectById(user.getAddressId());
                        } catch (Exception e) {
                                LOGGER.info("Could not find address for Store", fofoStore.getCode());
                                address = new Address();
                        }
                        double sum = userWalletHistoryRepository.selectSumByWallet(uw.getId());
                        int calculated = (int) sum;
                        System.out.printf("%d\t%s\t%b\t%s\t%s\t%s\t%d\t%d\t%d%n", fofoStore.getId(), fofoStore.getCode(),
                                        fofoStore.isActive(), address.getName(), address.getCity(), address.getState(), uw.getAmount(),
                                        calculated, uw.getAmount() - calculated);
                }
        }

        public void changeWarehouse() throws Exception {
                transactionService.moveWarehouses();
        }

        public void mailDashboardScreenshots() throws Exception {
                System.setProperty("webdriver.chrome.driver", "/usr/bin/chromedriver");

                ChromeOptions options = new ChromeOptions();
                options.addArguments("--headless");
                options.addArguments("--no-sandbox");
                options.addArguments("start-maximized");
                options.addArguments("disable-infobars");
                options.addArguments("--disable-extensions");

                WebDriver driver = new ChromeDriver(options);
                driver.manage().window().setSize(new Dimension(1600, 900));
                driver.manage().window().maximize();
                // Deleting all the cookies
                driver.manage().deleteAllCookies();
                // Specifiying pageLoadTimeout and Implicit wait
                driver.manage().timeouts().pageLoadTimeout(40, TimeUnit.SECONDS);
                driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);

                Map<String, Set<Integer>> authUserPartnerIdMapping = csService.getAuthUserPartnerIdMapping();
                Set<Integer> allPartners = new HashSet<>();
                Map<Integer, File> partnerSnapshotMap = new HashMap<>();
                authUserPartnerIdMapping.values().stream().forEach(x -> allPartners.addAll(x));
                for (int fofoId : allPartners) {
                        driver.get("https://partners.smartdukaan.com/12dashboard34?fofoId=" + fofoId);
                        File file = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
                        partnerSnapshotMap.put(fofoId, file);

                }
                for (Map.Entry<String, Set<Integer>> entry : authUserPartnerIdMapping.entrySet()) {
                        String email = entry.getKey();
                        LOGGER.info("Sending mail start to {}", email);
                        Set<Integer> partnerIds = entry.getValue();
                        StringBuffer body = new StringBuffer();
                        Map<Integer, File> emailSnapshotMap = new HashMap<>();
                        for (int fofoId : partnerIds) {
                                body.append(String.format("<br/><img src=\"cid:%d\"/>", fofoId));
                                emailSnapshotMap.put(fofoId, partnerSnapshotMap.get(fofoId));
                        }
                        Utils.sendEmbeddedHtmlMail(mailSender, new String[]{email}, new String[]{},
                                        String.format("Franchise Screenshots - %s", FormattingUtils.formatDate(LocalDateTime.now())),
                                        body.toString(), emailSnapshotMap);
                        LOGGER.info("Sent mail to {}", email);
                }
                driver.quit();
        }

        // Rollout prebooking orders amount in case the order is grned.
        public void pbfix() throws ProfitMandiBusinessException {
                List<PrebookingOrder> prebookingOrders = prebookingOrderRepository.selectAll();
                Map<Integer, Boolean> prebookingCleared = new HashMap<>();
                prebookingOrders = prebookingOrders.stream().collect(Collectors.toList());
                Map<Integer, List<PrebookingOrder>> catalogPrebookingMap = new HashMap<>();
                for (PrebookingOrder prebookingOrder : prebookingOrders) {
                        if (!catalogPrebookingMap.containsKey(prebookingOrder.getCatalogId())) {
                                catalogPrebookingMap.put(prebookingOrder.getCatalogId(), new ArrayList<>());
                        }
                        catalogPrebookingMap.get(prebookingOrder.getCatalogId()).add(prebookingOrder);
                        int prebookingId = prebookingOrder.getId();
                        List<UserWalletHistory> history = walletService.getAllByReference(prebookingOrder.getFofoId(), prebookingId,
                                        WalletReferenceType.PREBOOKING_ORDER);
                        long totalAmount = history.stream().collect(Collectors.summingLong(x -> x.getAmount()));
                        // Refund is pending
                        if (history.size() > 0) {
                                if (totalAmount < 0) {
                                        prebookingCleared.put(prebookingId, false);
                                        LOGGER.info("Amount pending for prebooking id " + prebookingId + " amount is " + -totalAmount
                                                        + " catalog id - {}", prebookingOrder.getCatalogId());
                                } else {
                                        prebookingCleared.put(prebookingId, true);
                                }
                        } else {
                                prebookingCleared.put(prebookingId, true);
                                LOGGER.info("No entry in wallet for prebooking Id " + prebookingId);
                        }
                }
                for (Map.Entry<Integer, List<PrebookingOrder>> entrySet : catalogPrebookingMap.entrySet()) {
                        LOGGER.info("Catalog id {}, Size {}", entrySet.getKey(), entrySet.getValue().size());
                        Set<Integer> itemIds = itemRepository.selectAllByCatalogItemId(entrySet.getKey()).stream()
                                        .map(x -> x.getId()).collect(Collectors.toSet());
                        List<PrebookingOrder> prebookings = entrySet.getValue();
                        Map<Integer, List<PrebookingOrder>> fofoMap = prebookings.stream()
                                        .collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.toList()));
                        for (Map.Entry<Integer, List<PrebookingOrder>> fofoMapEntry : fofoMap.entrySet()) {
                                int fofoId = fofoMapEntry.getKey();
                                int totalGrnCount = inventoryItemRepository.selectByFofoIdItemIds(fofoId, itemIds).size();
                                List<PrebookingOrder> partnerBookings = fofoMapEntry.getValue();
                                for (PrebookingOrder partnerBooking : partnerBookings) {
                                        if (prebookingCleared.get(partnerBooking.getId())) {
                                                totalGrnCount--;
                                                if (totalGrnCount < 0) {
                                                        totalGrnCount = 0;
                                                        LOGGER.info("FofoId {}, No Grn But Refunded prebooking id {}", fofoId,
                                                                        partnerBooking.getId());
                                                        break;
                                                }
                                        }
                                }

                                long toBeRefunded = partnerBookings.stream().filter(x -> !prebookingCleared.get(x.getId()))
                                                .limit(totalGrnCount).count();
                                LOGGER.info("FofoId {}, Remaining Grn {}, toBeRefunded Prebooking {}", fofoId, totalGrnCount,
                                                toBeRefunded);
                                partnerBookings.stream().filter(x -> !prebookingCleared.get(x.getId()))
                                                .filter(x -> x.getCreateTimestamp().getYear() == 2022).limit(totalGrnCount).forEach(x -> {
                                                        try {
                                                                purchaseService.sendPrebookingNotifyMessage(x);
                                                        } catch (Exception e) {
                                                                LOGGER.info("could not notify");
                                                        }
                                                });

                        }
                }
        }

        public void fixGrn() throws Exception {
                List<Purchase> incompletePurchases = purchaseRepository.selectIncompletePurchase();
                for (Purchase incompletePurchase : incompletePurchases) {
                        List<Order> orders = orderRepository.selectByAirwayBillOrInvoiceNumber(
                                        incompletePurchase.getPurchaseReference(), incompletePurchase.getFofoId());
                        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(incompletePurchase.getId());
                        Map<Integer, Integer> grnedItems = inventoryItems.stream().collect(
                                        Collectors.groupingBy(x -> x.getItemId(), Collectors.summingInt(x -> x.getInitialQuantity())));
                        Map<Integer, Integer> billedItems = orders.stream().collect(Collectors.groupingBy(
                                        x -> x.getLineItem().getItemId(), Collectors.summingInt(x -> x.getLineItem().getQuantity())));
                        for (Integer billedItemId : billedItems.keySet()) {
                                if (grnedItems.containsKey(billedItemId)) {
                                        if (grnedItems.get(billedItemId) > billedItems.get(billedItemId)) {
                                                LOGGER.info("Billed Qty {} ---- Grned {}, ItemId {}, Invoice Number {}({}), Grn Date {}",
                                                                billedItems.get(billedItemId), grnedItems.get(billedItemId), billedItemId,
                                                                incompletePurchase.getPurchaseReference(), incompletePurchase.getId(),
                                                                incompletePurchase.getCreateTimestamp());
                                                Item item = itemRepository.selectById(billedItemId);
                                                if (item.getType().equals(ItemType.SERIALIZED)) {

                                                } else {
                                                        for (InventoryItem inventoryItem : inventoryItems) {
                                                                if (inventoryItem.getItemId() == billedItemId && inventoryItem.getGoodQuantity() == 0) {
                                                                        List<ScanRecord> scanRecords = scanRecordRepository
                                                                                        .selectByInventoryItemId(inventoryItem.getId());
                                                                        if (scanRecords.size() == 1 && scanRecords.get(0).getQuantity() == 0) {
                                                                                LOGGER.info("Safe to remove InventoryItem Id {}", inventoryItem.getId());
                                                                                scanRecordRepository.delete(scanRecords.get(0));
                                                                                inventoryItemRepository.delete(inventoryItem);
                                                                                incompletePurchase.setUnfullfilledNonSerializedQuantity(
                                                                                                incompletePurchase.getUnfullfilledNonSerializedQuantity()
                                                                                                                + inventoryItem.getInitialQuantity());
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                }

        }

        public void fixDupGrns() throws Exception {
                List<Integer> duplicatePurchaseIds = Arrays.asList(14984);
                for (int duplicatePurchaseId : duplicatePurchaseIds) {
                        Purchase purchase = purchaseRepository.selectById(duplicatePurchaseId);
                        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(duplicatePurchaseId);
                        if (inventoryItems.size() == 0) {
                                LOGGER.info("Could not find InventoryItems for {}", duplicatePurchaseId);
                                continue;
                        }
                        schemeService.rollbackSchemes(inventoryItems.stream().map(x -> x.getId()).collect(Collectors.toList()),
                                        duplicatePurchaseId,
                                        "Rolled back duplicate grn for Purchase Invoice " + purchase.getPurchaseReference());
                        for (InventoryItem inventoryItem : inventoryItems) {
                                inventoryItemRepository.delete(inventoryItem);
                                List<ScanRecord> scanRecords = scanRecordRepository.selectByInventoryItemId(inventoryItem.getId());
                                for (ScanRecord scanRecord : scanRecords) {
                                        scanRecordRepository.delete(scanRecord);
                                }
                                List<SchemeInOut> sios = schemeInOutRepository
                                                .selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItem.getId())));
                                for (SchemeInOut sio : sios) {
                                        LOGGER.info("SIO - {}", sio);
                                        schemeInOutRepository.delete(sio);
                                }

                        }
                }
                // throw new Exception();
        }

        public void mongom() {
                List<TagListing> tls = tagListingRepository.selectAll(false);
                Set<Integer> itemIds = tls.stream().map(x -> x.getItemId()).collect(Collectors.toSet());
                Set<Integer> catalogIds = itemRepository.selectByIds(itemIds).stream().map(x -> x.getCatalogItemId())
                                .collect(Collectors.toSet());
                for (int catalogId : catalogIds) {
                        try {
                                ContentPojo cp = mongoClient.getEntityById(catalogId);
                                try {
                                        cp.setIconImageUrl(cp.getIconImageUrl().replace("saholic", "smartdukaan"));
                                } catch (Exception e) {

                                }

                                try {
                                        cp.setThumbnailImageUrl(cp.getThumbnailImageUrl().replace("saholic", "smartdukaan"));
                                } catch (Exception e) {

                                }

                                cp.setDefaultImageUrl(cp.getDefaultImageUrl().replace("saholic", "smartdukaan"));
                                List<MediaPojo> mPojos = cp.getImages();
                                if (mPojos != null) {
                                        mPojos.stream().forEach(mPojo -> {
                                                mPojo.setUrl(mPojo.getUrl().replace("saholic", "smartdukaan"));
                                        });
                                }
                                mongoClient.persistEntity(cp);
                        } catch (Exception e) {
                                continue;
                        }
                }
        }

        public void cancelDn(String debitNoteNumber) throws Exception {
                DebitNote debitNote = debitNoteRepository.selectDebitNoteByNumber(debitNoteNumber);

                List<PurchaseReturnItem> purchaseReturnItems = purchaseReturnItemRepository
                                .selectAllByDebitNoteId(debitNote.getId());
                // Select all inventory Item
                Set<Integer> inventoryItemIds = purchaseReturnItems.stream().map(x -> x.getInventoryItemId())
                                .collect(Collectors.toSet());
                List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);
                for (InventoryItem inventoryItem : inventoryItems) {
                        if (!StringUtils.isEmpty(inventoryItem.getSerialNumber())) {
                                inventoryItem.setGoodQuantity(1);
                                inventoryItem.setLastScanType(ScanType.PURCHASE);
                                ScanRecord sr = scanRecordRepository.selectByInventoryItemId(inventoryItem.getId()).stream()
                                                .filter(x -> x.getType().equals(ScanType.PURCHASE_RET)).findFirst().get();
                                scanRecordRepository.delete(sr);
                                CurrentInventorySnapshot cis = currentInventorySnapshotRepository
                                                .selectByItemAndFofoId(inventoryItem.getItemId(), inventoryItem.getFofoId());
                                if (cis == null) {
                                        cis = new CurrentInventorySnapshot();
                                        cis.setFofoId(inventoryItem.getFofoId());
                                        cis.setItemId(inventoryItem.getId());
                                        currentInventorySnapshotRepository.persist(cis);
                                }
                                cis.setAvailability(cis.getAvailability() + 1);
                                schemeService.processSchemeIn(inventoryItem.getPurchaseId(), inventoryItem.getFofoId());
                        }
                }
                purchaseReturnItems.stream().forEach(x -> purchaseReturnItemRepository.delete(x));
        }

        public void processPd(int priceDropId) throws ProfitMandiBusinessException {
                priceDropService.processPriceDrop(priceDropId, false);
        }

        public void fixScheme() throws Exception {
                LOGGER.info("Partner Types found\tPartnerType To Remove\tAmout to Rollback");
                final Map<Integer, Scheme> schemesMap = schemeRepository.selectAll().stream()
                                .collect(Collectors.toMap(x -> x.getId(), x -> x));
                List<SchemeInOut> sios = schemeInOutRepository.selectAllByCreateDate(LocalDate.of(2019, 9, 1).atTime(0, 0),
                                LocalDateTime.now());
                Map<SioTuple, Map<PartnerType, List<SchemeInOut>>> schemeTupleMap = sios.stream()
                                .filter(x -> x.getRolledBackTimestamp() == null)
                                .filter(x -> schemesMap.get(x.getSchemeId()).getPartnerType() != PartnerType.ALL)
                                .collect(Collectors.groupingBy(
                                                x -> new SioTuple(x.getInventoryItemId(), schemesMap.get(x.getSchemeId()).getType()),
                                                Collectors.groupingBy(x -> schemesMap.get(x.getSchemeId()).getPartnerType(),
                                                                Collectors.mapping(x -> x, Collectors.toList()))));

                schemeTupleMap.entrySet().stream().filter(x -> x.getValue().size() > 1).forEach(x -> {
                        Map<PartnerType, List<SchemeInOut>> partnerTypeSchemeMap = x.getValue();
                        PartnerType partnerTypeToRemove = partnerTypeSchemeMap.keySet().stream()
                                        .min(Comparator.comparing(y -> PartnerType.PartnerTypeRankMap.get(y))).get();
                        LOGGER.info("{}\t{}\t{}\t{}\t{}\t{}", partnerTypeSchemeMap.keySet(), partnerTypeToRemove,
                                        partnerTypeSchemeMap.get(partnerTypeToRemove).stream()
                                                        .collect(Collectors.summingDouble(SchemeInOut::getAmount)),
                                        FormattingUtils.formatDate(partnerTypeSchemeMap.get(partnerTypeToRemove).stream()
                                                        .map(y -> y.getCreateTimestamp()).findFirst().get()));

                });
        }

        @Autowired
        GstProAuthService gstProAuthService;

        @Autowired
        GstProService gstProService;

        @Autowired
        InvoiceService invoiceService;

        public void updateIrnsToInvoices() {
                try {
                        invoiceService.updateIrnsToInvoices();
                } catch (Throwable t) {
                        t.printStackTrace();
                }
        }

        @Autowired
        AmazonPurchaseService amazonPurchaseService;

        @Autowired
        OfferTargetSlabRepository offerTargetSlabRepository;

        public void amazonPurchase() throws Exception {
                amazonPurchaseService.purchaseAmazon("B085M5R82K", 10, 3999);
        }

        @Autowired
        ItemCriteriaRepository itemCriteriaRepository;

        public void createOfferCriteria() throws Exception {
                Offer offer = offerRepository.selectById(1099);
                CreateOfferRequest createOfferRequest = offerService.getCreateOfferRequest(offer);
                createOfferRequest.setStartDate(LocalDate.of(2022, 7, 5).atStartOfDay());
                createOfferRequest.setEndDate(LocalDate.of(2022, 7, 31).atTime(LocalTime.MAX));
                createOfferRequest.setCreatedOn(LocalDateTime.now());
                offerService.addOfferService(createOfferRequest);
        }

        public void createOfferCriteria1() throws Exception {
                Map<Integer, List<Integer>> map = new HashMap<>();
                map.put(31960, Arrays.asList(57, 69));
                map.put(32844, Arrays.asList(57, 69));
                map.put(31964, Arrays.asList(65, 78));
                map.put(33493, Arrays.asList(70, 84));
                map.put(32847, Arrays.asList(65, 78));
                map.put(32623, Arrays.asList(72, 86));
                map.put(31972, Arrays.asList(74, 88));
                map.put(33495, Arrays.asList(78, 93));
                map.put(32699, Arrays.asList(78, 93));
                map.put(31967, Arrays.asList(78, 93));
                map.put(33424, Arrays.asList(86, 103));
                map.put(33441, Arrays.asList(94, 113));
                map.put(33491, Arrays.asList(102, 123));
                map.put(32664, Arrays.asList(94, 112));
                map.put(33430, Arrays.asList(159, 181));
                map.put(33381, Arrays.asList(172, 195));
                map.put(33484, Arrays.asList(184, 209));
                map.put(32698, Arrays.asList(171, 194));
                map.put(32665, Arrays.asList(171, 194));
                map.put(33428, Arrays.asList(146, 166));
                map.put(33499, Arrays.asList(196, 223));
                map.put(33427, Arrays.asList(184, 208));
                map.put(33385, Arrays.asList(203, 230));
                map.put(33373, Arrays.asList(196, 222));
                map.put(33429, Arrays.asList(171, 193));
                map.put(33387, Arrays.asList(215, 244));
                map.put(33432, Arrays.asList(208, 236));
                map.put(32546, Arrays.asList(196, 222));
                map.put(33389, Arrays.asList(227, 257));
                map.put(33498, Arrays.asList(233, 264));
                map.put(33496, Arrays.asList(202, 229));
                map.put(32088, Arrays.asList(233, 264));
                map.put(33377, Arrays.asList(233, 264));
                map.put(33395, Arrays.asList(327, 392));
                map.put(33393, Arrays.asList(344, 413));
                map.put(32277, Arrays.asList(360, 432));
                map.put(33397, Arrays.asList(377, 452));
                map.put(32305, Arrays.asList(393, 472));
                map.put(33492, Arrays.asList(409, 491));
                map.put(33399, Arrays.asList(409, 491));
                map.put(33405, Arrays.asList(442, 531));
                map.put(33403, Arrays.asList(442, 531));
                map.put(32854, Arrays.asList(442, 531));
                map.put(32155, Arrays.asList(458, 550));
                map.put(32151, Arrays.asList(458, 550));
                map.put(33407, Arrays.asList(475, 570));
                map.put(32855, Arrays.asList(475, 570));
                map.put(33409, Arrays.asList(655, 786));
                map.put(33411, Arrays.asList(688, 825));
                map.put(32687, Arrays.asList(688, 825));
                map.put(33413, Arrays.asList(720, 865));
                map.put(33415, Arrays.asList(1032, 1238));
                map.put(33417, Arrays.asList(1097, 1316));

                Offer offer = offerRepository.selectById(1099);
                List<TargetSlab> targetSlabs = offerTargetSlabRepository.getByOfferId(offer.getId());
                ItemCriteria itemCriteria = targetSlabs.get(0).getItemCriteriaPayouts().get(0).getItemCriteria();

                Map<List<Integer>, List<Integer>> payoutModelsMap = map.entrySet().stream().map(x ->
                {
                        try {
                                int catalogId = itemRepository.selectById(x.getKey()).getCatalogItemId();
                                return new AbstractMap.SimpleEntry<>(catalogId, x.getValue());
                        } catch (Exception e) {
                                return new AbstractMap.SimpleEntry<>(0, new ArrayList());
                        }
                }).collect(Collectors.groupingBy(x -> x.getValue(), Collectors.mapping(x -> x.getKey(), Collectors.toList())));

                payoutModelsMap.entrySet().stream().forEach(x ->
                {
                        itemCriteria.setCatalogIds(x.getValue());

                        com.spice.profitmandi.dao.entity.catalog.ItemCriteria itemCriteria1 = new com.spice.profitmandi.dao.entity.catalog.ItemCriteria();
                        itemCriteria1.setCriteria(gson.toJson(itemCriteria));
                        itemCriteriaRepository.persist(itemCriteria1);
                        com.spice.profitmandi.dao.entity.catalog.TargetSlab ts = new com.spice.profitmandi.dao.entity.catalog.TargetSlab();
                        ts.setOfferId(offer.getId());
                        ts.setAmountType(targetSlabs.get(0).getItemCriteriaPayouts().get(0).getAmountType());
                        ts.setPayoutTarget(25);
                        ts.setItemCriteriaId(itemCriteria1.getId());
                        ts.setPayoutValue(x.getKey().get(0));
                        offerTargetSlabRepository.persist(ts);

                        com.spice.profitmandi.dao.entity.catalog.TargetSlab ts1 = new com.spice.profitmandi.dao.entity.catalog.TargetSlab();
                        ts1.setOfferId(offer.getId());
                        ts1.setAmountType(targetSlabs.get(0).getItemCriteriaPayouts().get(0).getAmountType());
                        ts1.setPayoutTarget(100);
                        ts1.setItemCriteriaId(itemCriteria1.getId());
                        ts1.setPayoutValue(x.getKey().get(1));
                        offerTargetSlabRepository.persist(ts1);
                });

        }

        @Autowired
        PriceDropRepository priceDropRepository;


        @Autowired
        PriceDropIMEIRepository priceDropIMEIRepository;

        public void fixPriceDrop() throws ProfitMandiBusinessException {
                //List<Integer> priceDropIds = Arrays.asList(609, 610, 611, 648, 649, 650, 651, 653, 667, 691, 692, 693, 695, 696, 697, 698);
                List<Integer> priceDropIds = Arrays.asList(609, 610, 611, 648, 649, 650, 651, 653, 667, 691, 692, 693, 695, 696, 697, 698, 645, 688);
                for (int priceDropId : priceDropIds) {
                        PriceDrop pd = priceDropRepository.selectById(priceDropId);
                        LOGGER.info("Price Drop ---- {}", pd);
                        List<ImeiDropSummaryModel> actualList = priceDropService.getAllSerialNumbersByAffectedDate(pd.getAffectedOn(), pd.getCatalogItemId());
                        Map<String, ImeiDropSummaryModel> actualMap = actualList.stream().collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x));

                        List<PriceDropIMEI> priceDropIMEIs = priceDropIMEIRepository.selectByPriceDropId(pd.getId());
                        Map<String, PriceDropIMEI> oldImeisMap = priceDropIMEIs.stream().collect(Collectors.toMap(x -> x.getImei(), x -> x));

                        for (Map.Entry<String, PriceDropIMEI> entry : oldImeisMap.entrySet()) {
                                String imei = entry.getKey();
                                if (!actualMap.containsKey(imei)) {
                                        //This imei is invalid and need to be checked
                                        if (!entry.getValue().getStatus().equals(PriceDropImeiStatus.REJECTED)) {
                                                if (entry.getValue().getStatus().equals(PriceDropImeiStatus.PENDING)) {
                                                        LOGGER.info("Invalid pending imei -- {} should be deleted", imei);
                                                } else if (entry.getValue().getStatus().equals(PriceDropImeiStatus.APPROVED)) {
                                                        LOGGER.info("Invalid approved imei -- {} should be reversed", imei);
                                                }
                                                //These values should either be rejected or rolledBack
                                                LOGGER.info("Should be rejected or rolledBack -- Imei --- {}, Status --- {}", imei, entry.getValue().getStatus());
                                        } else {
                                                //Rejections can be ignored
                                        }
                                } else {
                                        if (entry.getValue().getStatus().equals(PriceDropImeiStatus.REJECTED)) {
                                                LOGGER.info("Valid but rejected imeis should be retried, marked pending --- {}", imei);
                                                entry.getValue().setStatus(PriceDropImeiStatus.PENDING);
                                        }
                                }
                        }

                        for (Map.Entry<String, ImeiDropSummaryModel> entry : actualMap.entrySet()) {
                                ImeiDropSummaryModel imeiDropSummaryModel = entry.getValue();
                                String imei = entry.getKey();
                                if (!oldImeisMap.containsKey(imei)) {
                                        //this imei should be added for processing in pending state
                                        PriceDropIMEI priceDropIMEI = new PriceDropIMEI();
                                        priceDropIMEI.setPriceDropId(priceDropId);
                                        priceDropIMEI.setStatus(PriceDropImeiStatus.PENDING);
                                        priceDropIMEI.setImei(imei);
                                        priceDropIMEI.setPartnerId(imeiDropSummaryModel.getRetailerId());
                                        priceDropIMEI.setUpdateTimestamp(LocalDateTime.now());
                                        priceDropIMEIRepository.persist(priceDropIMEI);
                                        LOGGER.info("These imeis are added and were missing earlier --- {}", imei);

                                }
                        }

                }
        }

        @Autowired
        private SaholicInventoryService saholicInventoryService;

        public void updateSaholicCISTable() {
                saholicInventoryService.updateSaholicCIS();
        }

        @Autowired
        BAGService bagService;

        public void testBag() throws Exception {
                //bagService.getPlans(10006, 10000f);
                //bagService.getBrandsMaster();
                bagService.getAllPlans();
        }

        @Autowired
        private OneAssistService oneAssistService;

        public void cancelOnceAssist(String invoiceNumber) throws Exception {
                FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
                insuranceService.cancelInsurance(fofoOrder);
        }

        public void mapBag() throws Exception {
                List<Item> items = itemRepository.selectAllItems(10006, Arrays.asList("OnePlus", "Oppo", "Realme", "Samsung", "Vivo", "Xiaomi"));
                items.stream().collect(Collectors.groupingBy(x -> x.getBrand()));

                List<CSVRecord> csvRecordList = FileUtil.readFile(new File("/home/amit/Documents/sample.csv"));
                for (CSVRecord csvRecord : csvRecordList) {
                        Sample sample = new Sample(csvRecord.get(0), csvRecord.get(1), csvRecord.get(2));
                        //StringUtils.getLevenshteinDistance()
                }
        }

        public void reverseInvalidActivation(List<Integer> inventoryItemIds) throws Exception {
                orderService.reverseActivationScheme(inventoryItemIds);
        }


        @Autowired
        CartRepository cartRepository;

        @Autowired
        CartService cartService;

        @Autowired
        private CommonPaymentService commonPaymentService;
        ;

        public void getSweet() throws Exception {
                List<Integer> fofoIds = Arrays.asList(175139179, 175139178, 175138987, 175138174, 175138843, 175139094, 175135227, 175138908, 175138814, 175139015, 175135707, 175138886, 175139211, 175139130, 159690067, 175139161, 175138842, 175138867, 175139218, 175127215, 175139238, 175139267, 175138541, 175139248, 175138989, 175139232, 175139257, 175138840, 175138829, 175138836, 175139242, 175139217, 175139246, 175139222, 175139256, 175139261, 175139154, 175139266, 175138906, 175138820, 175138951, 175139255, 175139172, 175139264, 175138863, 175139029, 175138934, 175139258, 175139270, 175138408, 175139180, 175139230, 175135923, 175139237, 175139227, 175139191, 175139268, 175139203, 166900459, 175138982, 175139236, 175139205, 175139241, 175138875, 175139184, 175138948, 175139176, 175139189, 175139019, 175139233, 175139204, 175138868, 175139138, 175139262, 175139207, 175138871, 175139188, 175138929, 175139199, 167996137, 175139102, 175139259, 175139260, 175138827, 175139082, 175139158, 175139229, 175139149, 175139073, 175139215, 175139249, 175139223, 175139235, 175139006, 175139107, 175138970, 175139123, 175139114, 175139074, 175139135, 175138883, 175139187, 175139247, 175138856, 175138983, 175138832, 175139190, 175139231, 175139079, 157327507, 175138864, 175139129, 175139214, 175138876, 175139212, 175139146, 175139150, 175139069, 175139025, 175139202, 175139224, 175139243, 175138958, 175139045, 175139108, 175139195, 175139164, 175139181, 175139013, 175138844, 175139226, 175138816, 175139219, 175139088, 175138897, 175139081, 175139197, 175138931);
                for (int fofoId : fofoIds) {
                        User user = userRepository.selectById(fofoId);
                        UserCart uc = new UserCart();
                        uc.setUserId(fofoId);
                        uc.setCartId(user.getActiveCartId());
                        List<CartItem> cartItems = new ArrayList<>();
                        CartItem cartItem = new CartItem();
                        cartItem.setItemId(33855);
                        cartItem.setSellingPrice(0.1d);
                        cartItem.setQuantity(1);
                        cartItems.add(cartItem);
                        cartService.addItemsToCart(uc.getCartId(), cartItems);
                        int transactionId = transactionService.createTransaction(uc, 0.1, 0);
                        commonPaymentService.payThroughWallet(transactionId);
                        // Once paid let proceed to process the order further.

                        transactionService.processTransaction(transactionId);
                }
        }

        private class SioTuple {
                int inventoryId;
                SchemeType schemeType;

                public SioTuple(int inventoryItemId, SchemeType schemeType) {
                        this.inventoryId = inventoryItemId;
                        this.schemeType = schemeType;
                }

                public int getInventoryId() {
                        return inventoryId;
                }

                public void setInventoryId(int inventoryId) {
                        this.inventoryId = inventoryId;
                }

                public SchemeType getSchemeType() {
                        return schemeType;
                }

                public void setSchemeType(SchemeType schemeType) {
                        this.schemeType = schemeType;
                }

                @Override
                public int hashCode() {
                        final int prime = 31;
                        int result = 1;
                        result = prime * result + getOuterType().hashCode();
                        result = prime * result + inventoryId;
                        result = prime * result + ((schemeType == null) ? 0 : schemeType.hashCode());
                        return result;
                }

                @Override
                public boolean equals(Object obj) {
                        if (this == obj)
                                return true;
                        if (obj == null)
                                return false;
                        if (getClass() != obj.getClass())
                                return false;
                        SioTuple other = (SioTuple) obj;
                        if (!getOuterType().equals(other.getOuterType()))
                                return false;
                        if (inventoryId != other.inventoryId)
                                return false;
                        if (schemeType != other.schemeType)
                                return false;
                        return true;
                }

                private RunOnceTasks getOuterType() {
                        return RunOnceTasks.this;
                }

        }

        public void printPendingLeads() {
                LOGGER.info("PENDING LEADES {}", leadRepository.selectLeadsScheduledBetweenDate(null,
                                LocalDateTime.now().minusDays(15), LocalDateTime.now().plusHours(4)));
        }

        public void removeDuplicateOrders() throws Exception {
                List<String> invoiceNumbers = Arrays.asList(/*
                                 * "DLWE066/1108", "DLWE066/299", "DLWE066/348", "HRFB004/242",
                                 * "HRFB004/243", "HRFB004/514", "HRFTB155/29", "HRJND076/1146",
                                 * "HRJND076/966", "HRKA134/295", "HRKA134/421", "HRKK091/381",
                                 * "HRMGH106/576", "HRSP056/139", "HRYN030/103", "UPGZ019/395",
                                 * "UPHRD130/1299", "UPHRD130/456", "UPHRD130/634", "UPLKO063/897",
                                 * "UPMRT149/54", "UPSJP119/748", "UPSJP119/980", "UPSTP065/1218",
                                 * "UPSTP065/2039", "UPSTP090/437", "UPSTP120/164",
                                 */
                                "HRMGH106/1576");

                int totalAmount = 0;
                float saleAmount = 0;
                float schemeReverseAmount = 0;
                for (String invoiceNumber : invoiceNumbers) {
                        List<FofoOrder> orders = fofoOrderRepository.selectByInvoiceNumberLike(invoiceNumber);
                        orders = orders.stream().skip(1).collect(Collectors.toList());
                        for (FofoOrder fofoOrder : orders) {
                                LOGGER.info("Fofo Order Id - {}, Invoice {}", fofoOrder.getId(), invoiceNumber);
                                int inventoryItemId = 0;
                                saleAmount += fofoOrder.getTotalAmount();
                                fofoOrderRepository.delete(fofoOrder);
                                LOGGER.info("Fofo Order Id - {}, Invoice {}", fofoOrder.getId(), invoiceNumber);
                                List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());
                                List<PaymentOptionTransaction> paymentOptionTransactions = paymentOptionTransactionRepository
                                                .selectByReferenceIdAndType(fofoOrder.getId(), PaymentOptionReferenceType.ORDER);
                                for (PaymentOptionTransaction paymentOptionTransaction : paymentOptionTransactions) {
                                        paymentOptionTransactionRepository.delete(paymentOptionTransaction);
                                }
                                for (FofoOrderItem foi : fofoOrderItems) {
                                        List<FofoLineItem> flis = fofoLineItemRepository.selectByFofoOrderItemId(foi.getId());
                                        fofoOrderItemRepository.delete(foi);
                                        for (FofoLineItem fli : flis) {
                                                inventoryItemId = fli.getInventoryItemId();
                                                fofoLineItemRepository.delete(fli);
                                        }
                                }
                                // Rollback entry with reversal reason
                                if (fofoOrder.getCreateTimestamp().isAfter(LocalDate.of(2020, 4, 1).atStartOfDay())) {
                                        float invoiceSchemeReversalAmount = 0;
                                        List<UserWalletHistory> userWalletHistory = userWalletHistoryRepository
                                                        .selectAllByreferenceIdandreferenceType(fofoOrder.getId(), WalletReferenceType.SCHEME_OUT);
                                        float invoiceWalletAmount = userWalletHistory.stream()
                                                        .collect(Collectors.summingInt(y -> y.getAmount()));
                                        totalAmount += invoiceWalletAmount;
                                        try {
                                                walletService.rollbackAmountFromWallet(fofoOrder.getFofoId(), invoiceWalletAmount,
                                                                fofoOrder.getId(), WalletReferenceType.SCHEME_OUT,
                                                                "Same order for Invoice-" + invoiceNumber + "created twice, duplicate invoice rollback",
                                                                fofoOrder.getCancelledTimestamp());
                                        } catch (Exception e) {
                                                LOGGER.info("Failed wallet update Reson [{}]", e.getMessage());
                                        }
                                        LOGGER.info("inventoryItemId - {}", inventoryItemId);
                                        List<SchemeInOut> schemeInOuts = schemeInOutRepository
                                                        .selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItemId)));
                                        Set<Integer> schemeIds = new HashSet<>();
                                        Set<Integer> schemeIdsRolledback = new HashSet<>();
                                        for (SchemeInOut sio : schemeInOuts) {
                                                if (Math.abs(sio.getCreateTimestamp().until(fofoOrder.getCreateTimestamp(),
                                                                ChronoUnit.MINUTES)) <= 35 && sio.getRolledBackTimestamp() == null) {
                                                        LOGGER.info(sio);
                                                        if (!schemeIds.contains(sio.getSchemeId())) {
                                                                schemeIds.add(sio.getSchemeId());
                                                        } else if (!schemeIdsRolledback.contains(sio.getSchemeId())) {
                                                                schemeIdsRolledback.add(sio.getSchemeId());
                                                                sio.setRolledBackTimestamp(LocalDateTime.now());
                                                                schemeReverseAmount += sio.getAmount();
                                                                invoiceSchemeReversalAmount += sio.getAmount();
                                                        }
                                                }
                                        }
                                        if (Math.abs(invoiceWalletAmount - invoiceSchemeReversalAmount) > 3) {
                                                LOGGER.info("No Matchhhh");
                                        }
                                        LOGGER.info("invoiceWalletAmount - {}, invoiceSchemeReversalAmount {}", invoiceWalletAmount,
                                                        invoiceSchemeReversalAmount);
                                }
                        }
                }
                LOGGER.info(
                                "Total Sale Amount Reversal - {}, Total Wallet Amount Reversal {}, Total Scheme Reversal Amount - {}",
                                saleAmount, totalAmount, schemeReverseAmount);
                // throw new Exception();
        }

        public void createGeofence() throws IOException, ProfitMandiBusinessException {

                // List<FofoStore> fofoStores = fofoStoreRepository.selectActiveStores();
                // for (FofoStore fofoStore : fofoStores) {
                // if (fofoStore.getLatitude() != null && fofoStore.getLongitude() != null) {
                CustomRetailer customRetailer = retailerService.getFofoRetailer(175138812);
                OkHttpClient client = new OkHttpClient();
                okhttp3.MediaType mediaType = okhttp3.MediaType.parse("application/json");
                JSONObject geofe = new JSONObject();
                JSONArray geofences = new JSONArray();
                JSONObject geometry = new JSONObject();
                JSONObject geo = new JSONObject();
                JSONArray coordinates = new JSONArray();
                ArrayList<Double> crds = new ArrayList<>();
                // crds.add(Double.parseDouble(fofoStore.getLongitude()));
                // crds.add(Double.parseDouble(fofoStore.getLatitude()));
                crds.add(79.739197);
                crds.add(27.961215);
                // crds.add(77.08596155373755);
                // crds.add(28.64944201113976);
                // coordinates.put(fofoStore.getLongitude());
                // coordinates.put(fofoStore.getLatitude());
                geo.put("type", "Point");
                geo.put("coordinates", crds);
                geometry.put("geometry", geo);
                JSONObject metadata = new JSONObject();
                metadata.put("name", customRetailer.getBusinessName());
                metadata.put("city", customRetailer.getAddress().getCity());
                metadata.put("Code", customRetailer.getCode());
                geometry.put("metadata", metadata);
                geometry.put("radius", 200);

                geofences.put(geometry);
                geofe.put("geofences", geofences);
                okhttp3.RequestBody body = okhttp3.RequestBody.create(mediaType, geofe.toString());
                String authString = "Basic "
                                + Base64.getEncoder().encodeToString(String.format("%s:%s", ACCOUNT_ID, SECRET_KEY).getBytes());

                Request request1 = new Request.Builder().url("https://v3.api.hypertrack.com/geofences").post(body)
                                .addHeader("Authorization", authString).build();

                Response response = client.newCall(request1).execute();

                JSONArray ja = new JSONArray(response.body().string());
                LOGGER.info("geofence" + ja);
                LOGGER.info("jalength" + ja.length());
                /*
                 * for (int i = 0; i < ja.length(); i++) { JSONObject c = ja.getJSONObject(i);
                 * String geofenceId = c.getString("geofence_id"); LOGGER.info("geofenceId" +
                 * geofenceId); FofoStoreGeofence fsg = new FofoStoreGeofence();
                 * fsg.setFofoId(customRetailer.getPartnerId()); fsg.setGeofenceId(geofenceId);
                 * fofoStoreGeofenceRepository.persist(fsg); }
                 *
                 * }
                 *
                 * }
                 */

        }

        public void getAllGeofences() throws IOException, ProfitMandiBusinessException {

                OkHttpClient client = new OkHttpClient();

                String authString = "Basic "
                                + Base64.getEncoder().encodeToString(String.format("%s:%s", ACCOUNT_ID, SECRET_KEY).getBytes());

                // Get geofences created for all app users
                Request request1 = new Request.Builder().url("https://v3.api.hypertrack.com/geofences")
                                .addHeader("Authorization", authString).build();

                Response response = client.newCall(request1).execute();

                LOGGER.info("response" + response.body().string());
        }

        public void deleteGeofences(List<String> geofenceIds) throws IOException, ProfitMandiBusinessException {
                OkHttpClient client = new OkHttpClient();

                String authString = "Basic "
                                + Base64.getEncoder().encodeToString(String.format("%s:%s", ACCOUNT_ID, SECRET_KEY).getBytes());

                for (String geofenceId : geofenceIds) {
                        Request request1 = new Request.Builder().url("https://v3.api.hypertrack.com/geofences/" + geofenceId)
                                        .delete().addHeader("Authorization", authString).build();
                        LOGGER.info("geofenceId" + geofenceId);
                        Response response = client.newCall(request1).execute();

                        LOGGER.info("response" + response.body().string());
                }

        }

        public void processSchemeOut(int fofoId, int orderId) throws Exception {
                schemeService.processSchemeOut(orderId, fofoId);

        }

        public void createDummyInvoices() {
                List<WarehouseInventoryItem> lavaInventoryItems = warehouseInventoryItemRepository.getSerialNumbers("Lava",
                                LocalDate.of(2020, Month.SEPTEMBER, 1).atStartOfDay(), LocalDateTime.now());
                LOGGER.info("Lava Inventory Size is {}", lavaInventoryItems.size());
        }

        @Autowired
        private WarehouseScanRepository warehouseScanRepository;

        @Autowired
        private WarehouseInventoryService warehouseInventoryService;

        public void genericCreateCurrentInventorySnapshot() throws Exception {
                purchaseService.genericCreateCurrentInventorySnapshot(175138856, 32820, 2);
        }

        public void fixScans() {
                Map<Integer, Integer> inventoryOrderMap = new HashMap<>();
                inventoryOrderMap.put(348795, 1628598);
                inventoryOrderMap.put(348796, 1628599);
                inventoryOrderMap.put(329854, 1628600);
                inventoryOrderMap.put(334197, 1628602);
                inventoryOrderMap.put(330110, 1628603);
                inventoryOrderMap.put(330111, 1628604);
                inventoryOrderMap.put(332843, 1628605);
                inventoryOrderMap.put(338067, 1628606);
                inventoryOrderMap.put(338974, 1628609);
                inventoryOrderMap.put(338975, 1628610);
                inventoryOrderMap.put(338971, 1628612);
                inventoryOrderMap.put(338588, 1628615);
                inventoryOrderMap.put(368205, 1631619);
                inventoryOrderMap.put(368206, 1631620);
                inventoryOrderMap.put(368207, 1631621);
                inventoryOrderMap.put(368208, 1631622);
                inventoryOrderMap.put(368209, 1631623);
                inventoryOrderMap.put(368211, 1631625);
                inventoryOrderMap.put(368213, 1631627);
                inventoryOrderMap.put(368214, 1631628);
                inventoryOrderMap.put(368203, 1631629);
                inventoryOrderMap.put(368216, 1631630);
                inventoryOrderMap.put(368217, 1631631);
                inventoryOrderMap.put(368218, 1631632);
                inventoryOrderMap.put(368219, 1631633);
                inventoryOrderMap.put(368222, 1631635);
                List<WarehouseScan> scans = warehouseScanRepository
                                .selectAllByInventoryItemIds(new ArrayList<>(inventoryOrderMap.keySet()));
                Map<Integer, List<WarehouseScan>> inventoryScansMap = scans.stream()
                                .collect(Collectors.groupingBy(WarehouseScan::getInventoryItemId));

                for (Map.Entry<Integer, List<WarehouseScan>> mapEntry : inventoryScansMap.entrySet()) {
                        int inventoryItemId = mapEntry.getKey();
                        List<WarehouseScan> duplicateScans = mapEntry.getValue().stream().filter(
                                                        x -> x.getOrderId() != null && x.getOrderId().equals(inventoryOrderMap.get(inventoryItemId)))
                                        .collect(Collectors.toList());
                        WarehouseScan duplicateScan = duplicateScans.stream().skip(1).findFirst().get();
                        warehouseScanRepository.delete(duplicateScan);
                        warehouseInventoryService.addQuantity(duplicateScan.getInventoryItemId(), duplicateScan.getQuantity());

                }

        }

        public void fixOffer() throws Exception {
                List<Integer> offerIds = Arrays.asList(228, 241, 242, 243, 244, 253);
                List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().filter(x -> x.getWarehouseId() == 7678)
                                .map(x -> x.getId()).collect(Collectors.toList());
                LOGGER.info("UP West Partner Ids - {}", fofoIds);
                for (int offerId : offerIds) {
                        Offer offer = offerRepository.selectById(offerId);

                        PartnerCriteria partnerCriteria = gson.fromJson(offer.getPartnerCriteria(), PartnerCriteria.class);
                        LOGGER.info("Offer Partner Ids - {}", partnerCriteria.getFofoIds());
                        for (Integer fofoId : fofoIds) {
                                if (partnerCriteria.getFofoIds().contains(fofoId)) {
                                        // This shoud be removed
                                        LOGGER.info("This shoud be removed FofoStore Code - {}",
                                                        fofoStoreRepository.selectByRetailerId(fofoId).getCode());
                                        partnerCriteria.getFofoIds().remove(fofoId);
                                }
                        }
                        offer.setPartnerCriteria(gson.toJson(partnerCriteria));
                }
        }

        public void reverseMaa() throws Exception {
                Purchase purchase = purchaseRepository.selectById(28877);
                Set<Integer> inventoryItemIds = inventoryItemRepository.selectByPurchaseId(28877).stream().map(x -> x.getId())
                                .collect(Collectors.toSet());
                double totalAmount = schemeInOutRepository.selectByInventoryItemIds(inventoryItemIds).stream()
                                /*
                                 * .filter(x -> x.getRolledBackTimestamp() == null ||
                                 * x.getStatusDescription().contains("investment")) .map(x -> {
                                 * x.setRolledBackTimestamp(LocalDateTime.now());
                                 * x.setStatus(SchemePayoutStatus.REJECTED); x.
                                 * setStatusDescription("Invoice-NSLCK3350 was cancelled, hence all schemes were rolled back"
                                 * ); return x; })
                                 */
                                .collect(Collectors.summingDouble(x -> x.getAmount()));
                WalletReferenceType walletReferenceType = WalletReferenceType.OTHERS;
                ManualPaymentType paymentType = manualPaymentRequestRepository.selectByReferenceType(walletReferenceType);
                if (paymentType == null) {
                        paymentType = new ManualPaymentType();
                        paymentType.setReferenceType(walletReferenceType);
                        manualPaymentRequestRepository.persist(paymentType);
                }
                paymentType.setCounter(paymentType.getCounter() + 1);
                int reference = paymentType.getCounter();
                walletService.consumeAmountFromWallet(purchase.getFofoId(), reference, WalletReferenceType.OTHERS,
                                "Invoice-NSLCK3350 was cancelled, hence all schemes were rolled back", (int) totalAmount,
                                LocalDateTime.now());
                LOGGER.info("Total Deduction is around Rs. {}", totalAmount);
        }

        public void opporeno() {
                List<Integer> offerIds = Arrays.asList(270, 269, 267, 265, 264, 257, 253, 244, 243, 242, 241, 240, 239, 228,
                                227, 226, 225);
                for (Integer offerId : offerIds) {
                        Offer offer = offerRepository.selectById(offerId);
                        com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = gson.fromJson(offer.getItemCriteria(),
                                        com.spice.profitmandi.service.offers.ItemCriteria.class);
                        if (itemCriteria.getExcludeCatalogIds().contains(1022950)) {
                                System.out.println("Excludes reno");
                        } else {
                                System.out.println("Does not excludes reno.. excluding it");
                                itemCriteria.getExcludeCatalogIds().add(1022950);
                                offer.setItemCriteria(gson.toJson(itemCriteria));
                        }

                }
        }

        @Autowired
        SaholicReservationSnapshotRepository saholicReservationSnapshotRepository;

        public void fixReservations() throws Exception {
                // Clear all Reservations
                saholicInventorySnapshotRepository.selectAll().stream().forEach(x -> x.setReserved(0));
                saholicReservationSnapshotRepository.selectAll().forEach(x -> saholicReservationSnapshotRepository.delete(x));
                List<Order> orders = orderRepository.selectAllOrderDatesBetweenByStatus(
                                LocalDate.now().minusDays(40).atStartOfDay(), LocalDateTime.now(),
                                OrderStatus.SUBMITTED_FOR_PROCESSING);
                for (Order order : orders) {
                        SaholicReservationSnapshot saholicReservationSnapshot = saholicReservationSnapshotRepository
                                        .selectByOrderId(order.getId());
                        if (saholicReservationSnapshot == null) {
                                saholicInventoryService.addReservationCount(order.getLineItem().getItemId(),
                                                order.getFulfilmentWarehouseId(), order.getLineItem().getQuantity(), order.getId());
                        }
                }
        }

        public void fixOrders() throws Exception {
                List<Order> orders = orderRepository.selectAllOrderDatesBetweenByStatus(
                                LocalDate.now().minusDays(10).atStartOfDay(), LocalDateTime.now(),
                                OrderStatus.SUBMITTED_FOR_PROCESSING);
                orders = orders.stream().filter(x -> x.getCreateTimestamp().isAfter(LocalDateTime.of(2021, 7, 21, 0, 0, 0)))
                                .collect(Collectors.toList());
                for (Order order : orders) {

                        LineItem lineItem = lineItemRepository.selectById(order.getLineItem().getId());
                        if (order.getOrderType() == null) {
                                order.setProductCondition(0);
                                order.setOrderType(0);
                                int itemId = order.getLineItem().getItemId();
                                int fulfillmentWarehouseId = order.getFulfilmentWarehouseId();
                                System.out.println("Item id " + itemId);
                                Item item = itemRepository.selectById(itemId);

                                VendorItemPricing vendorItemPricing = vendorItemPricingRepository.selectByItemIdAndVendorId(itemId,
                                                fulfillmentWarehouseId);
                                if (vendorItemPricing == null) {
                                        vendorItemPricing = vendorItemPricingRepository.selectAll(itemId).get(0);
                                }
                                System.out.println("vendorItemPricing " + vendorItemPricing);
                                lineItem.setProductGoup(item.getProductGroup());
                                lineItem.setColor(item.getColor());
                                lineItem.setNlc(vendorItemPricing.getNlc());
                                lineItem.setTransferPrice(vendorItemPricing.getTp());
                                lineItem.setLogisticsCost(0f);
                                lineItem.setCodCollectionCharges(0f);

                        }

                        int warehouseTo = fofoStoreRepository.selectByRetailerId(order.getRetailerId()).getWarehouseId();
                        int itemId = order.getLineItem().getItemId();
                        Warehouse warehouse = transactionService.getFulfilmentWarehouseMap(Arrays.asList(itemId), warehouseTo)
                                        .get(itemId);
                        LOGGER.info(
                                        "Order Id - {}, WarehouseTo - {}, Item Id - {}, Warehouse From - {}, Fulfilment Warehouse Id - {}",
                                        order.getId(), warehouseTo, itemId, warehouse.getBillingWarehouseId(), warehouse.getId());
                        order.setWarehouseId(warehouse.getBillingWarehouseId());
                        order.setFulfilmentWarehouseId(warehouse.getId());

                }

        }

        @Autowired
        PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

        public void addInvestment() {
                List<LocalDate> dates = Arrays.asList(
                                LocalDate.of(2022, 12, 1)
                );
                // List<Integer> fofoIds = Arrays.asList(175136207, 175138910, 175138967,
                // 175138990, 175138999);
                for (LocalDate date : dates) {
                        LOGGER.info("Date - {}", date);
                        Map<Integer, PartnerDailyInvestment> investmentMap = partnerDailyInvestmentRepository
                                        .selectAll(date.plusDays(1)).stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
                        List<PartnerDailyInvestment> investments = partnerDailyInvestmentRepository.selectAll(date.minusDays(1));
                        for (PartnerDailyInvestment investment : investments) {
                                if (investmentMap.get(investment.getFofoId()) == null || (investmentMap.get(investment.getFofoId())
                                                .getShortPercentage() <= 10) == (investment.getShortPercentage() <= 10)) {
                                        // Do nothing add investment as is
                                } else {
                                        LOGGER.info("Problem with fofo id => {}", investment.getFofoId());
                                        // Lets give benefit of doubt
                                        if (investment.getShortPercentage() > 10) {
                                                investment = investmentMap.get(investment.getFofoId());
                                        }
                                }
                                PartnerDailyInvestment partnerDailyInvestment = new PartnerDailyInvestment();
                                partnerDailyInvestment.setActivatedStockAmount(investment.getActivatedStockAmount());
                                partnerDailyInvestment.setDate(date);
                                partnerDailyInvestment.setFofoId(investment.getFofoId());
                                partnerDailyInvestment.setMinInvestment(investment.getMinInvestment());
                                partnerDailyInvestment.setGrnPendingAmount(investment.getGrnPendingAmount());
                                partnerDailyInvestment.setActivatedStockAmount(investment.getActivatedStockAmount());
                                partnerDailyInvestment.setUnbilledAmount(investment.getUnbilledAmount());
                                partnerDailyInvestment.setReturnInTransitAmount(investment.getReturnInTransitAmount());
                                partnerDailyInvestment.setSalesAmount(investment.getSalesAmount());
                                partnerDailyInvestment.setInStockAmount(investment.getInStockAmount());
                                partnerDailyInvestment.setWalletAmount(investment.getWalletAmount());
                                partnerDailyInvestment.setActivatedGrnPendingAmount(investment.getActivatedGrnPendingAmount());
                                partnerDailyInvestmentRepository.persist(partnerDailyInvestment);
                        }
                }
        }

        @Autowired
        BrandRegionMappingRepository brandRegionMappingRepository;

        public void brandRegion() {
                Set<Integer> warehouseIds = ProfitMandiConstants.WAREHOUSE_MAP.keySet();
                Map<String, Map<Boolean, List<BrandRegionMapping>>> mapping = brandRegionMappingRepository.selectAll().stream()
                                .collect(Collectors.groupingBy(BrandRegionMapping::getBrand,
                                                Collectors.collectingAndThen(Collectors.toList(),
                                                                x -> x.stream().collect(Collectors.groupingBy(BrandRegionMapping::isAccessory)))));
                for (Map.Entry<String, Map<Boolean, List<BrandRegionMapping>>> entry : mapping.entrySet()) {
                        String brand = entry.getKey();
                        for (Map.Entry<Boolean, List<BrandRegionMapping>> isAccessoryEntry : entry.getValue().entrySet()) {
                                boolean isAccessory = isAccessoryEntry.getKey();
                                Map<Integer, List<Integer>> warehouseToIdsMap = isAccessoryEntry.getValue().stream()
                                                .collect(Collectors.groupingBy(BrandRegionMapping::getToWarehouseId,
                                                                Collectors.mapping(BrandRegionMapping::getFromWarehouseId, Collectors.toList())));
                                for (int warehouseIdTo : warehouseIds) {
                                        List<Integer> warehouseIdsFrom = warehouseToIdsMap.get(warehouseIdTo);
                                        if (warehouseIdsFrom == null || !warehouseIdsFrom.contains(warehouseIdTo)) {
                                                LOGGER.info("Missing entries for brand region mapping = {}, {}, {}", brand, isAccessory,
                                                                warehouseIdTo);

                                                BrandRegionMapping brandRegionMapping = new BrandRegionMapping();
                                                brandRegionMapping.setAccessory(isAccessory);
                                                brandRegionMapping.setBrand(brand);
                                                brandRegionMapping.setFromWarehouseId(warehouseIdTo);
                                                brandRegionMapping.setToWarehouseId(warehouseIdTo);
                                                brandRegionMappingRepository.persist(brandRegionMapping);

                                        }
                                }
                        }
                }
        }

        public void reverseSchemes(String invoiceNumber) throws Exception {
                FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);
                if (fofoOrder.getCancelledTimestamp() != null) {
                        orderService.reverseScheme(fofoOrder);
                }
        }

        @Autowired
        PartnerTypeChangeService partnerTypeChangeService;

        public void runMe() throws Exception {
                /*System.out.println("runme ==== " + fofoOrderItemRepository.selectSumMopGroupByRetailer(
                                LocalDate.of(2021, 11, 1).atStartOfDay(), LocalDate.of(2021, 12, 1).atStartOfDay(), 175138408, false));
                System.out.println("change " + partnerTypeChangeService.getTypeOnDate(175138408, LocalDate.now()));*/

                List<Integer> catalogItemIds = Arrays.asList(1023209, 1023209, 1023208, 1023208, 1023199, 1023199, 1023198, 1023198, 1023200, 1023200, 1023197, 1023196, 1023113, 1023112, 1023194, 1023194, 1023194, 1023193, 1023193, 1023190, 1023190, 1023190, 1023189, 1023189, 1023189, 1023188, 1023188, 1023181, 1023181, 1023180, 1023180, 1023179, 1023179, 1023178, 1023178, 1023183, 1023183, 1023182, 1023182, 1022511, 1023066, 1023164, 1023163, 1023064, 1023174, 1023174, 1023173, 1023173, 1023172, 1023172, 1023171, 1023171, 1023171, 1022765, 1023170, 1023170, 1023166, 1023166, 1023166, 1023012, 1023073, 1023168, 1023167, 1023167, 1023118, 1023118, 1023118, 1023164, 1023163, 1023162, 1022971, 1023161, 1023160, 1023159, 1023158, 1023157, 1023156, 1023058, 1023142, 1023142, 1023141, 1023141, 1023145, 1023145, 1023145, 1023145, 1023144, 1023144, 1023144, 1023144, 1023143, 1023143, 1023143, 1023139, 1023137, 1023135, 1023134, 1023133, 1023130, 1023129, 1023126, 1023125, 1023124, 1023121, 1023128, 1023116, 1023077, 1023102, 1023079, 1023113, 1023113, 1023112, 1023112, 1023110, 1023110, 1023109, 1023109, 1023108, 1023108, 1023107, 1023107, 1022809, 1022871, 1023078, 1023101, 1023103, 1023102, 1023102, 1023100, 1023100, 1023099, 1023099, 1023079, 1023079, 1023078, 1023078, 1023081, 1023081, 1023080, 1023080, 1023080, 1022872, 1023077, 1023077, 1023076, 1023076, 1023076, 1022861, 1022970, 1023074, 1023073, 1023073, 1023072, 1023072, 1023071, 1023071, 1023045, 1023070, 1023070, 1023069, 1023063, 1023063, 1023062, 1023062, 1023061, 1023061, 1023057, 1023056, 1023055, 1023054, 1023053, 1023052, 1023068, 1023068, 1023067, 1023067, 1023066, 1023066, 1023065, 1023065, 1023064, 1023064, 1023059, 1023058, 1023058, 1023059, 1023050, 1023050, 1023049, 1023049, 1023048, 1023048, 1023047, 1023047, 1022845, 1023046, 1023046, 1023045, 1023045, 1022955, 1023044, 1023042, 1023043, 1023043, 1023043, 1023018, 1023017, 1023017, 1023016, 1023016, 1023015, 1023015, 1023041, 1023041, 1023041, 1023040, 1023039, 1023039, 1022769, 1023038, 1023038, 1023037, 1023037, 1023036, 1023036, 1023035, 1023035, 1023027, 1023027, 1023034, 1023034, 1023033, 1023033, 1023031, 1023031, 1023030, 1023029, 1023028, 1022630, 1022630, 1022630, 1023026, 1023013, 1022987, 1022982, 1023019, 1023019, 1022979, 1022978, 1022977, 1023023, 1023022, 1023022, 1023014, 1023014, 1023013, 1023013, 1022956, 1022816, 1023012, 1023012, 1023011, 1023011, 1023010, 1023010, 1023010, 1023009, 1023009, 1023006, 1023006, 1023006, 1023005, 1023005, 1023005, 1023004, 1023004, 1023004, 1023003, 1023003, 1023002, 1023002, 1023001, 1023001, 1022971, 1022970, 1022974, 1022973, 1022976, 1022976, 1022764, 1022782, 1022972, 1022972, 1022971, 1022970, 1022955, 1022956, 1022833, 1022967, 1022967, 1022967, 1022965, 1022965, 1022965, 1022965, 1022963, 1022963, 1022767, 1022962, 1022962, 1022960, 1022960, 1022957, 1022956, 1022956, 1022955, 1022955, 1022955, 1022950, 1022950, 1022944, 1022949, 1022949, 1022784, 1022566, 1022871, 1022947, 1022947, 1022946, 1022946, 1022946, 1022944, 1022944, 1022943, 1022943, 1022941, 1022941, 1022941, 1022800, 1022937, 1022937, 1022936, 1022936, 1022940, 1022940, 1022939, 1022939, 1022938, 1022931, 1022931, 1022930, 1022929, 1022934, 1022934, 1022932, 1022932, 1022783, 1022917, 1022897, 1022896, 1022893, 1022892, 1022888, 1022882, 1022833, 1022928, 1022928, 1022877, 1022877, 1022876, 1022876, 1022842, 1022875, 1022875, 1022874, 1022874, 1022872, 1022872, 1022871, 1022871, 1022809, 1022868, 1022868, 1022868, 1022867, 1022867, 1022867, 1022866, 1022866, 1022866, 1022862, 1022862, 1022862, 1022861, 1022861, 1022861, 1022859, 1022858, 1022808, 1022851, 1022851, 1022851, 1022850, 1022850, 1022850, 1022835, 1022846, 1022846, 1022845, 1022845, 1022844, 1022844, 1022843, 1022843, 1022842, 1022842, 1022841, 1022841, 1022840, 1022840, 1022839, 1022839, 1022799, 1022834, 1022834, 1022833, 1022833, 1022830, 1022830, 1022830, 1022825, 1022825, 1022824, 1022783, 1022817, 1022817, 1022816, 1022816, 1022815, 1022815, 1022814, 1022814, 1022401, 1022402, 1022400, 1022399, 1022813, 1022813, 1022813, 1022813, 1022812, 1022812, 1022812, 1022812, 1022811, 1022811, 1022811, 1022811, 1022811, 1022810, 1022810, 1022810, 1022810, 1022810, 1022809, 1022808, 1022808, 1022806, 1022806, 1022806, 1022805, 1022805, 1022805, 1022804, 1022804, 1022804, 1022803, 1022803, 1022803, 1022802, 1022802, 1022802, 1022802, 1022801, 1022801, 1022801, 1022801, 1022800, 1022800, 1022800, 1022799, 1022799, 1022799, 1022798, 1022798, 1022798, 1022797, 1022797, 1022797, 1022796, 1022796, 1022796, 1022794, 1022793, 1022792, 1022792, 1022792, 1022791, 1022791, 1022791, 1022790, 1022790, 1022790, 1022789, 1022789, 1022789, 1022785, 1022785, 1022788, 1022788, 1022784, 1022784, 1022783, 1022783, 1022782, 1022782, 1022546, 1022546, 1022781, 1022781, 1022781, 1022773, 1021600, 1022779, 1022779, 1022778, 1022774, 1022774, 1022774, 1022773, 1022773, 1022773, 1022770, 1022771, 1022771, 1022770, 1022770, 1022770, 1022769, 1022769, 1022769, 1022759, 1022758, 1022754, 1022753, 1022752, 1022757, 1022757, 1022756, 1022755, 1022767, 1022765, 1022743, 1022742, 1022742, 1022741, 1022741, 1022741, 1022740, 1022740, 1022740, 1022739, 1022739, 1022739, 1022738, 1022738, 1022738, 1022748, 1022748, 1022737, 1022677, 1022736, 1022736, 1022736, 1022735, 1022735, 1022735, 1022734, 1022734, 1022592, 1022705, 1022705, 1022699, 1022699, 1022694, 1022694, 1022693, 1022693, 1022629, 1022461, 1022592, 1022590, 1022590, 1022590, 1022590, 1022582, 1022582, 1022566, 1022565, 1022565, 1022559, 1022559, 1022559, 1022558, 1022558, 1022558, 1022546, 1022546, 1022542, 1022542, 1022541, 1022541, 1022541, 1022521, 1022521, 1022521, 1022521, 1022520, 1022520, 1022520, 1022518, 1022518, 1022518, 1022515, 1022515, 1022515, 1022514, 1022514, 1022514, 1022514, 1022511, 1022511, 1022511, 1022501, 1022501, 1022501, 1022500, 1022500, 1022500, 1021443, 1022467, 1022467, 1022467, 1022467, 1022461, 1022461, 1022465, 1022465, 1022465, 1022443, 1022451, 1022451, 1022451, 1022435, 1022435, 1022419, 1022419, 1022418, 1022418, 1022402, 1022402, 1022402, 1022401, 1022401, 1022401, 1022400, 1022400, 1022400, 1022399, 1022399, 1022399, 1022395, 1022395, 1022392, 1022392, 1015059, 1022361, 1022361, 1022010, 1021600, 1022017, 1022017, 1021848, 1022010, 1022009, 1021848, 1021848, 1021848, 1021958, 1021958, 1021958, 1021443, 1021431, 1021430, 1021429, 1021428, 1021427, 1021425, 1021424, 1021422, 1021421, 1021420, 1021419, 1021417, 1021600, 1015060, 1015061, 1003800, 1015061, 1015059, 1015059, 1015059, 1015060, 1015060, 1015060, 1003800, 1003800, 1003800, 1015061, 1015061);
                for (Integer catalogItemId : catalogItemIds) {
                        try {

                                ContentPojo cp = mongoClient.getEntityById(catalogItemId);
                                System.out.println(cp.getDefaultImageUrl());
                        } catch (Exception e) {
                                System.out.println("------");
                        }
                }
        }

        public void createOffers(FileInputStream stream) throws Exception {
                offerService.createOffers(stream);
        }

        @Autowired
        MandiiService mandiiService;

        @Autowired
        FofoKycRepository fofoKycRepository;

        @Autowired
        PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

        @Autowired
        DocumentRepository documentRepository;

        @Autowired
        com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;

        public void mandiiUser(String firstName, String lastName, String pan, String dob, String aadhaar, String gender,
                                                   String father) throws Exception {
                FofoStore fs = fofoStoreRepository.selectByPan(pan);
                CustomRetailer cr = retailerService.getFofoRetailer(fs.getId());
                com.spice.profitmandi.dao.entity.dtr.User dtrUser = dtrUserRepository.selectByEmailId(cr.getEmail());
                MandiiUser mandiiUser = mandiiService.getUser(dtrUser.getFirstName(), dtrUser.getLastName(), father,
                                Gender.valueOf(gender), cr.getEmail(), pan, cr.getMobileNumber(), LocalDate.parse(dob),
                                cr.getAddress().getLine1() + " " + cr.getAddress().getLine2(), cr.getAddress().getCity(),
                                cr.getAddress().getState(), cr.getAddress().getPinCode());
                mandiiUser.setFatherName(father);
                if (StringUtils.isNotEmpty(firstName)) {
                        mandiiUser.setFirstName(firstName);
                        mandiiUser.setLastName(lastName);
                }
                if (StringUtils.isNotEmpty(father)) {
                        mandiiUser.setFatherName(father);
                }
                if (StringUtils.isNotEmpty(aadhaar)) {
                        mandiiUser.setAadharNumber(aadhaar);
                }
                mandiiUser.setGender(Gender.valueOf(gender));
                mandiiService.createAccount(cr.getBusinessName(), mandiiUser);
        }

        @Autowired
        CreditAccountRepository creditAccountRepository;

        public void mandiiUsers() throws Exception {
                List<CreditAccount> creditAccounts = creditAccountRepository.selectAll();
                List<Integer> fofoIds = creditAccounts.stream().filter(x -> x.getGateway().equals(Gateway.MANDII) && (x.getCreditStatus().equals(CreditStatus.UNKNOWN) || x.getCreditStatus().equals(CreditStatus.TO_BE_EVALUATED))).map(x -> x.getFofoId()).collect(Collectors.toList());
                List<FofoStore> fsList = fofoStoreRepository.selectByRetailerIds(fofoIds);
                for (FofoStore store : fsList) {
                        this.mandiiUsers(store.getPan());
                }

        }

        public void mandiiUsers(String pan) throws Exception {
                FofoStore fs = fofoStoreRepository.selectByPan(pan);

                PartnerOnBoardingPanel pob = partnerOnBoardingPanelRepository.selectByCode(fs.getCode());
                List<FofoKyc> fofoKycs = fofoKycRepository.selectByPartnerOnBoardingId(pob.getId());
                CustomRetailer cr = retailerService.getFofoRetailer(fs.getId());
                com.spice.profitmandi.dao.entity.dtr.User dtrUser = dtrUserRepository.selectByEmailId(cr.getEmail());
                boolean ca = false;
                for (FofoKyc fk : fofoKycs) {

                        MandiiUser mandiiUser = mandiiService.getUser(fk.getFirstName(), fk.getLastName(), fk.getFatherName(),
                                        fk.getGender(), fk.getEmail(), pan, fk.getMobile(), fk.getDob(),
                                        fk.getAddress1() + " " + fk.getAddress2() + " " + fk.getAddress3(), fk.getCity(), fk.getState(),
                                        fk.getPincode());

                        LOGGER.info("mandiiUser" + mandiiUser);

                        ca = mandiiService.createAccount(cr.getBusinessName(), mandiiUser);

                        Document panDoc = documentRepository.selectById(fk.getPanDoc());
                        File fPan = new File(panDoc.getPath() + panDoc.getName());
                        String encodeString = encodeFileToBase64Binary(fPan);

                        mandiiService.documentUpload(pan, fk.getMobile(), "PROPRIETOR_PAN", encodeString, null);

                        Document adhaarF = documentRepository.selectById(fk.getPoaFront());
                        File adharf = new File(adhaarF.getPath() + adhaarF.getName());
                        String adhaarFEncodstring = encodeFileToBase64Binary(adharf);
                        mandiiService.documentUpload(pan, fk.getMobile(), "AADHAAR", adhaarFEncodstring, "FRONT");

                        Document adhaarB = documentRepository.selectById(fk.getPoaBack());
                        File adharb = new File(adhaarB.getPath() + adhaarF.getName());
                        String adhaarBEncodstring = encodeFileToBase64Binary(adharb);
                        mandiiService.documentUpload(pan, fk.getMobile(), "AADHAAR", adhaarBEncodstring, "BACK");

                        if (ca == true) {
                                AccountStatusResponseOut accountStatusResponseOut = mandiiService.getStatus(fs.getPan());
                                this.setCreditAccount(fs.getId(), accountStatusResponseOut);
                        }

                }

        }

        private void setCreditAccount(int fofoId, AccountStatusResponseOut accountStatusResponseOut) {

                CreditAccount creditAccount = creditAccountRepository.selectByFofoIdAndGateway(fofoId, Gateway.MANDII);

                if (creditAccount == null) {
                        creditAccount = new CreditAccount();
                        creditAccount.setFofoId(fofoId);
                        creditAccount.setGateway(Gateway.MANDII);
                }

                if (accountStatusResponseOut == null) {
                        creditAccount.setCreditStatus(CreditStatus.UNKNOWN);
                        creditAccount.setDescription("User company not found");

                } else {
                        if (accountStatusResponseOut.getSanctionLimit() != null) {
                                creditAccount.setSanctionedAmount(accountStatusResponseOut.getSanctionLimit().floatValue());
                        } else {
                                creditAccount.setSanctionedAmount(0);
                        }

                        creditAccount.setInterestRate(accountStatusResponseOut.getRateOfInterest());
                        if (accountStatusResponseOut.getBalanceAmount() != null) {
                                creditAccount.setAvailableAmount(accountStatusResponseOut.getBalanceAmount().floatValue());
                        } else {
                                creditAccount.setAvailableAmount(0);
                        }

                        if (accountStatusResponseOut.getCurrentStage() != null) {
                                creditAccount.setDescription(accountStatusResponseOut.getCurrentStage().toString());
                        }
                        if (accountStatusResponseOut.getStatus().equals(EligibilityStatusEnum.SANCTION_AVAILABLE)) {
                                creditAccount.setCreditStatus(CreditStatus.SANCTIONED);
                        } else if (accountStatusResponseOut.getStatus().equals(EligibilityStatusEnum.IN_ELIGIBLE)) {
                                creditAccount.setCreditStatus(CreditStatus.INELIGIBLE);
                        } else {

                                creditAccount.setCreditStatus(CreditStatus.TO_BE_EVALUATED);
                        }
                }

                creditAccount.setUpdatedOn(LocalDateTime.now());
                creditAccountRepository.persist(creditAccount);
        }

        private static String encodeFileToBase64Binary(File file) throws Exception {
                FileInputStream fileInputStreamReader = new FileInputStream(file);
                byte[] bytes = new byte[(int) file.length()];
                fileInputStreamReader.read(bytes);
                return new String(Base64.getEncoder().encodeToString(bytes));
        }

        public void testIrnLive(String invoiceNumber) throws Exception {
                List<Order> orders = orderRepository.selectByInvoiceNumber(invoiceNumber);
                gstProService.getEInvoice(orders);
        }

        public void processSchemeByIds(List<Integer> schemeIds) throws Exception {
                List<Scheme> schemes = schemeRepository.selectBySchemeIds(schemeIds);
                for (Scheme scheme : schemes) {
                        List<Integer> catalogIds = schemeItemRepository.selectBySchemeIds(new HashSet<>(Arrays.asList(scheme.getId()))).stream().map(x -> x.getCatalogId()).collect(Collectors.toList());
                        if (Arrays.asList(SchemeType.SPECIAL_SUPPORT, SchemeType.ACTIVATION, SchemeType.CATEGORY, SchemeType.INVESTMENT, SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT).contains(scheme.getType())) {
                                List<FofoOrder> fofoOrders = fofoOrderRepository.selectOrderByModelAndSaleBetween(catalogIds, scheme.getStartDateTime(), scheme.getEndDateTime());
                                for (FofoOrder fofoOrder : fofoOrders) {
                                        System.out.println("Processing fofoOrder --- " + fofoOrder.getInvoiceNumber());
                                        System.out.println("Processing fofoOrder --- " + fofoOrder.getInvoiceNumber());
                                        schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());
                                }
                        } else if (Arrays.asList(SchemeType.IN).contains(scheme.getType())) {
                                List<Purchase> purchases = purchaseRepository.selectPurchaseByCatalogsAndSaleBetween(catalogIds, scheme.getStartDateTime(), scheme.getEndDateTime());
                                for (Purchase purchase : purchases) {
                                        System.out.println("Processing purchase --- " + purchase.getPurchaseReference());
                                        schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());
                                }

                        }
                }
        }

        @Autowired
        InsurancePolicyRepository insurancePolicyRepository;

        public void addMissingWalletDebitsForInsurance() throws Exception {
                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectAllByProviderId(5, Optional.empty());
                for (InsurancePolicy insurancePolicy : insurancePolicies) {
                        FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(insurancePolicy.getInvoiceNumber());
                        List<UserWalletHistory> userWalletHistories = userWalletHistoryRepository.selectAllByreferenceIdandreferenceType(insurancePolicy.getId(), WalletReferenceType.DAMAGE_PROTECTION);
                        if (userWalletHistories.size() > 1) {
                                UserWalletHistory userWalletHistory = userWalletHistories.get(0);
                                walletService.addAmountToWallet(insurancePolicy.getRetailerId(), userWalletHistory.getReference(), WalletReferenceType.DAMAGE_PROTECTION, "Excess deduction - settled", 198, LocalDateTime.now());
                        }
                }
        }


}

//7015845171