Subversion Repositories SmartDukaan

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

import com.spice.profitmandi.dao.model.CreateOfferRequest;

import com.spice.profitmandi.dao.model.MediaPojo;

import com.spice.profitmandi.dao.model.TargetSlab;

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