Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import com.google.gson.Gson;

import com.smartdukaan.cron.scheduled.SamsungIMEIActivationService;

import com.smartdukaan.cron.scheduled.ScheduledTasks;

import com.smartdukaan.cron.scheduled.amazon.shop.AmazonPurchaseService;

import com.smartdukaan.cron.scheduled.amazon.shop.OrderSummary;

import com.smartdukaan.cron.scheduled.amazon.shop.model.OrderRow;

import com.smartdukaan.cron.scheduled.ambreports.AbmReportSender;

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

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

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.InvoicePdfModel;

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.*;

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.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.catalog.StockTransactionType;

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.LoanReferenceType;

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.cs.TicketRepository;

import com.spice.profitmandi.dao.repository.cs.ActivityRepository;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.entity.cs.Ticket;

import com.spice.profitmandi.dao.entity.cs.Activity;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

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

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.dao.service.LiquidationService;

import com.spice.profitmandi.dao.service.LocationTrackingService;

import com.spice.profitmandi.dao.service.SaleRewardService;

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.oneassist.model.CancelPlanRequestModel;

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.SDCreditService;

import com.spice.profitmandi.service.transaction.TransactionService;

import com.spice.profitmandi.service.transaction.invoicing.InvoiceService;

import com.spice.profitmandi.service.transaction.scheduled.SDCreditScheduler;

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 com.spice.profitmandi.service.warehouse.WarehouseService;

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

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

import in.shop2020.model.v1.order.OrderStatus;

import in.shop2020.model.v1.order.WalletReferenceType;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpDelete;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.util.EntityUtils;

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.apache.poi.ss.usermodel.CellType;

import org.apache.poi.ss.usermodel.DataFormatter;

import org.apache.poi.xssf.usermodel.XSSFCell;

import org.apache.poi.xssf.usermodel.XSSFRow;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

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.Propagation;

import org.springframework.transaction.annotation.Transactional;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.math.BigDecimal;

import java.time.*;

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 RestClient restClient;

    @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 TicketRepository ticketRepository;

    @Autowired

    private ActivityRepository activityRepository;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private ManualPaymentRequestRepository manualPaymentRequestRepository;

    @Autowired

    private OfferRepository offerRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private Gson gson;

    @Autowired

    private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

    @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 LiquidationService liquidationService;

    @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 PurchaseReturnOrderRepository purchaseReturnOrderRepository;

    @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 gmailRelaySender;

    @Autowired

    private LocationTrackingService locationTrackingService;

    @Autowired

    private AbmReportSender abmReportSender;

    @Autowired

    private SaleRewardService saleRewardService;

    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 (quantityToReduce > 0) {

                    LOGGER.info("Invoice {}, Item {}, Quantity to reduce {}", purchase.getPurchaseReference(), itemQtyEntry.getKey(), quantityToReduce);

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

                                    cis.setAvailability(cis.getAvailability() - ii.getInitialQuantity());

                                    purchase.setUnfullfilledNonSerializedQuantity(

                                            purchase.getUnfullfilledNonSerializedQuantity() + quantityToReduce);

                                    quantityToReduce = quantityToReduce - ii.getInitialQuantity();

                                    inventoryItemRepository.delete(ii);

                                    scanRecordRepository.delete(scanRecord);

                                    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(Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW));

        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 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.moveOrdersFulfimentWarehouse(7573);

    }

    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(gmailRelaySender, 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()),

                    "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() throws ProfitMandiBusinessException {

        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, boolean recreatePri) throws Exception {

        DebitNote debitNote = debitNoteRepository.selectDebitNoteByNumber(debitNoteNumber);

        List<PurchaseReturnItem> purchaseReturnItems = purchaseReturnItemRepository

                .selectAllByDebitNoteId(debitNote.getId());

        // Block cancellation if any item is already refunded

        boolean hasReturned = purchaseReturnItems.stream()

                .anyMatch(x -> PurchaseReturnStatus.RETURNED.equals(x.getStatus()));

        if (hasReturned) {

            throw new Exception("Cannot cancel DN " + debitNoteNumber + " - items already returned and refunded to wallet");

        }

        // Select all inventory Item

        Set<Integer> inventoryItemIds = purchaseReturnItems.stream().map(x -> x.getInventoryItemId())

                .collect(Collectors.toSet());

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds);

        // Reverse wallet refund if already processed

        List<PurchaseReturnOrder> purchaseReturnOrders = purchaseReturnOrderRepository.selectByDebitNoteId(debitNote.getId());

        for (PurchaseReturnOrder pro : purchaseReturnOrders) {

            if (pro.getRefundTimestamp() != null && pro.getRefundAmount() != null && pro.getRefundAmount() > 0) {

                walletService.consumeAmountFromWallet(debitNote.getFofoId(), debitNote.getId(),

                        WalletReferenceType.PURCHASE, "Reversed - DN cancelled " + debitNoteNumber,

                        pro.getRefundAmount(), LocalDateTime.now());

                LOGGER.info("Reversed wallet refund of {} for DN {}", pro.getRefundAmount(), debitNoteNumber);

            }

        }

        for (InventoryItem inventoryItem : inventoryItems) {

            if (!StringUtils.isEmpty(inventoryItem.getSerialNumber())) {

                inventoryItem.setGoodQuantity(1);

                inventoryItem.setLastScanType(ScanType.PURCHASE);

                scanRecordRepository.selectByInventoryItemId(inventoryItem.getId()).stream()

                        .filter(x -> x.getType().equals(ScanType.PURCHASE_RET)).findFirst()

                        .ifPresent(sr -> scanRecordRepository.delete(sr));

                CurrentInventorySnapshot cis = currentInventorySnapshotRepository

                        .selectByItemAndFofoId(inventoryItem.getItemId(), inventoryItem.getFofoId());

                if (cis == null) {

                    cis = new CurrentInventorySnapshot();

                    cis.setFofoId(inventoryItem.getFofoId());

                    cis.setItemId(inventoryItem.getItemId());

                    currentInventorySnapshotRepository.persist(cis);

                }

                cis.setAvailability(cis.getAvailability() + 1);

                schemeService.processSchemeIn(inventoryItem.getPurchaseId(), inventoryItem.getFofoId());

            }

        }

        if (recreatePri) {

            // Reset PRIs to CREATED so partner can re-initiate DN without re-requesting

            for (PurchaseReturnItem pri : purchaseReturnItems) {

                pri.setStatus(PurchaseReturnStatus.CREATED);

                pri.setDebitNoteId(0);

                pri.setApproveTimestamp(null);

                pri.setDenyTimestamp(null);

                pri.setRefundTimestamp(null);

                pri.setCreateTimestamp(LocalDateTime.now());

            }

        } else {

            purchaseReturnItems.forEach(x -> purchaseReturnItemRepository.delete(x));

        }

        LOGGER.info("Cancelled DN {} recreatePri={}", debitNoteNumber, recreatePri);

    }

    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;

    private static DataFormatter formatter = new DataFormatter();

    @Autowired

    OfferTargetSlabRepository offerTargetSlabRepository;

    public void amazonPurchase() throws Exception {

        //Read file

        FileInputStream fis = new FileInputStream(new File("/Users/amit/Downloads/amazon.xlsx"));

        //creating workbook instance that refers to .xls file

        XSSFWorkbook wb = new XSSFWorkbook(fis);

        //creating a Sheet object to retrieve the object

        XSSFSheet sheet = wb.getSheetAt(0);

        OrderSummary orderSummary = this.getOrderSummary(sheet);

        List<OrderRow> orderRows = new ArrayList<>();

        int rows = sheet.getLastRowNum();

        for (int rowNum = 3; rowNum < rows; rowNum++) {

            try {

                OrderRow orderRow = parseRow(orderSummary, sheet.getRow(rowNum));

                orderRows.add(orderRow);

            } catch (RuntimeException re) {

                System.out.println("Could not parse rownum - " + rowNum);