Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import java.io.File;

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

import java.util.Arrays;

import java.util.Base64;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import java.util.stream.Collectors;

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 com.google.gson.Gson;

import com.smartdukaan.cron.scheduled.SamsungIMEIActivationService;

import com.smartdukaan.cron.scheduled.ScheduledTasks;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.inventory.SaholicInventorySnapshot;

import com.spice.profitmandi.dao.entity.transaction.HdfcPayment;

import com.spice.profitmandi.dao.entity.transaction.LineItem;

import com.spice.profitmandi.dao.entity.transaction.LineItemImei;

import com.spice.profitmandi.dao.entity.transaction.ManualPaymentType;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.transaction.SellerWarehouse;

import com.spice.profitmandi.dao.entity.transaction.UserWallet;

import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;

import com.spice.profitmandi.dao.entity.user.Address;

import com.spice.profitmandi.dao.entity.user.User;

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

import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;

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.repository.GenericRepository;

import com.spice.profitmandi.dao.repository.catalog.ItemRepository;

import com.spice.profitmandi.dao.repository.catalog.ManualPaymentRequestRepository;

import com.spice.profitmandi.dao.repository.catalog.OfferRepository;

import com.spice.profitmandi.dao.repository.catalog.SchemeRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

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

import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;

import com.spice.profitmandi.dao.repository.dtr.LeadRepository;

import com.spice.profitmandi.dao.repository.dtr.Mongo;

import com.spice.profitmandi.dao.repository.dtr.PaymentOptionTransactionRepository;

import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;

import com.spice.profitmandi.dao.repository.fofo.DebitNoteRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

import com.spice.profitmandi.dao.repository.fofo.InvoiceNumberGenerationSequenceRepository;

import com.spice.profitmandi.dao.repository.fofo.PartnerTargetRepository;

import com.spice.profitmandi.dao.repository.fofo.PrebookingOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;

import com.spice.profitmandi.dao.repository.fofo.PurchaseReturnItemRepository;

import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;

import com.spice.profitmandi.dao.repository.fofo.SchemeInOutRepository;

import com.spice.profitmandi.dao.repository.fofo.SchemeItemRepository;

import com.spice.profitmandi.dao.repository.inventory.SaholicInventorySnapshotRepository;

import com.spice.profitmandi.dao.repository.inventory.SaholicReservationSnapshotRepository;

import com.spice.profitmandi.dao.repository.transaction.HdfcPaymentRepository;

import com.spice.profitmandi.dao.repository.transaction.LineItemImeisRepository;

import com.spice.profitmandi.dao.repository.transaction.LineItemRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.transaction.ReturnOrderRepository;

import com.spice.profitmandi.dao.repository.transaction.SellerWarehouseRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.dao.repository.user.UserRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;

import com.spice.profitmandi.service.inventory.InventoryService;

import com.spice.profitmandi.service.inventory.PurchaseService;

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

@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

	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 SamsungIMEIActivationService samsungActivationService;

	@Autowired

	private PrebookingOrderRepository prebookingOrderRepository;

	@Autowired

	private SaholicReservationSnapshotRepository saholicReservationInventorySnapshotRepository;

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

		}

		samsungActivationService.getActivationsBetweenNew(startDate, endDate);

	}

	public void migarateLineItemsToNewTable() throws Exception {

		LOGGER.info("Before Migrated LineItems Successfully");

		int lineItemImeiId = 0;

		LocalDateTime startDate = null;

		try {

			lineItemImeiId = lineItemImeisRepository.selectMaxId();

			LineItem lineItem = lineItemRepository

					.selectById(lineItemImeisRepository.selectById(lineItemImeiId).getLineItemId());

			Order order = orderRepository.selectById(lineItem.getOrderId());

			startDate = order.getBillingTimestamp();

		} catch (Exception e) {

			LOGGER.info("Running before first time");

			startDate = LocalDateTime.of(LocalDate.of(2017, 7, 1), LocalTime.MIDNIGHT);

		}

		List<Order> orders = orderRepository.selectAllByBillingDatesBetween(startDate, LocalDateTime.now());

		Collections.reverse(orders);

		for (Order order : orders) {

			try {

				String serialNumbers = order.getLineItem().getSerialNumber();

				if (!StringUtils.isEmpty(serialNumbers)) {

					List<String> serialNumberList = Arrays.asList(serialNumbers.split(","));

					for (String serialNumber : serialNumberList) {

						int lineItemId = order.getLineItem().getId();

						LineItemImei lineItemImei = new LineItemImei();

						lineItemImei.setSerialNumber(serialNumber);

						lineItemImei.setLineItemId(lineItemId);

						lineItemImeisRepository.persist(lineItemImei);

					}

				} else {

					LOGGER.info("Serial Numbers dont exist for Order {}", order.getId());

				}

			} catch (Exception e) {

				LOGGER.info("Error occurred while creating lineitem imei {}, because of {}", order.getId(),

						e.getMessage());

			}

		}

		LOGGER.info("Migrated LineItems Successfully");

	}

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

		}

	}

	public void migratePurchase() 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());

			}

		}

	}

	public void populateSchemes() {

		List<Integer> list05 = Arrays.asList(29093, 29094, 29095, 29096, 29097, 29098, 29099, 29101, 29102);

		List<Integer> list10 = Arrays.asList(29187, 29188);

		List<Integer> list13 = Arrays.asList(28095, 28097, 28098, 28101, 28102, 28104, 28106, 28107, 28108, 28227,

				28228, 28229, 28231, 29055, 29056, 29066, 29079);

		List<Integer> list15 = Arrays.asList(20891, 27938, 27939, 27940, 27941, 27943, 27947, 27948, 27953, 27954,

				27955, 28220, 28467, 29020, 29033, 29034, 29035, 29592, 29886, 29890, 29891, 29941, 29942, 27445, 27958,

				27960, 27961);

		List<Integer> list18 = Arrays.asList(28137, 28138, 28140, 28157, 28158, 28161, 28162, 28163, 28164, 28176,

				28177, 28178, 28199, 28200, 28208, 28209, 28210, 28211, 28215, 28216, 28217, 28230, 28380, 28381, 28382,

				28383, 28384, 28385, 28386, 28387, 28388, 28389, 28390, 28391, 28392, 28395, 28461, 28462, 28463, 28464,

				28465, 28466, 28488, 28489, 28490, 28491, 28564, 28565, 28762, 28773, 28871, 28872, 28873, 28874, 28880,

				28881, 28914, 28915, 28916, 28917, 28918, 28919, 28920, 29046, 29047, 29048, 29068, 29069, 29110, 29111,

				29112, 29113, 29114, 29115, 29116, 29117, 29207, 29208, 29217, 29218, 29225, 29474, 29475, 29476, 29477,

				29478, 29479, 29483, 29485, 29486, 29487, 29488, 29739, 29740, 29741, 29742, 29743, 29744, 29745, 29746,

				29747, 29748, 29749, 29753, 29756, 29757, 29758, 29760, 29761, 29762, 29763, 29764, 29765, 29766, 29767,

				29779, 29780, 29781, 29792, 29793, 29828, 29829, 29830, 29879, 29880, 29881, 29882, 29951);

		List<Integer> list20 = Arrays.asList(27975, 27976, 28091, 28363, 29023, 29024, 29025);

		List<Integer> list25 = Arrays.asList(28763, 28764, 28765, 29152, 29154, 29157, 29209, 29210, 29601, 29602,

				29720, 29721, 29722, 29723, 29725, 29726, 29727);

		List<Integer> list30 = Arrays.asList(27962, 27963, 27964, 27965, 27966, 27968, 27969, 28328, 28362, 28566,

				28567, 28568, 28571, 28572, 29073, 29074, 29075, 29080, 29081, 29120, 29121, 29122, 29124, 29189, 29190,

				29191, 29192, 29193, 29194, 29196, 29197, 29198, 29199, 29515, 29516, 29517, 29675, 29676, 29677, 29678,

				29679, 29707, 29708, 29794, 29795, 29883, 29884, 29885, 29887, 29888, 29889, 29931, 29932, 29935, 29936,

				29937, 29938, 29939, 29940);

		List<Integer> list35 = Arrays.asList(27996, 27998, 29067, 29071, 29643, 29644, 29945, 29946, 29987, 29052,

				29053, 29078, 29085, 29086, 29567, 29568, 29569, 29570, 29797, 29914, 29915, 29930, 28877, 28878, 29604,

				29605, 29606, 29775, 29776, 29777, 29778, 28862, 28863, 28864, 29026, 29103, 29104, 29105, 28979, 28980,

				28981, 28982, 28983, 29002, 29003, 29004, 29834, 29835, 29836, 29837, 29943);

		List<Integer> list40 = Arrays.asList(29082, 29083, 28766, 28767, 28768, 28769, 28771);

		List<Integer> list45 = Arrays.asList(28026, 28027, 28028, 29528, 29529, 29530, 29534, 29535, 29536, 29538,

				29755);

		List<Integer> list55 = Arrays.asList(28010, 28011, 28015, 28016, 28019, 28240, 28469, 28470, 28471, 28569,

				28570, 28674, 28759, 28761, 28909, 28910, 28911, 28912, 28913, 29108, 29109, 29143, 29144, 29145, 29146,

				29211, 29212, 29213, 29214, 29482, 29511, 29512, 29521, 29525, 29526, 29527, 29574, 29575, 29576, 29611,

				29612, 29616, 29641, 29642, 29728, 29729, 29750, 29771, 29782, 29783, 29784, 29923, 29924, 29944, 29953,

				29992, 29994, 27977, 27978, 28092, 28325, 28326, 28327, 28486, 28487, 29148, 29149, 29150, 29151, 29384,

				29385, 29386, 29427, 29489, 29518, 29519, 29520, 29577, 29578, 29579, 29580, 29586, 29660, 29661, 29662,

				29663, 29769, 29770, 29790, 29791, 29796, 29928, 29929, 29947, 29948, 28093, 28094, 28556, 28557, 28673,

				28867, 28868, 28870, 29089, 29090, 29091, 29106, 29107);

		List<Integer> list65 = Arrays.asList(28058, 28223, 28224, 28225, 28226, 28329, 29201, 29202, 29203, 29204,

				29205, 29206, 29466, 29467, 29468, 29469, 29470, 29471, 29472, 29573);

		Map<Float, List<Integer>> m = new HashMap<>();

		m.put(0.5f, list05);

		m.put(1.0f, list10);

		m.put(1.3f, list13);

		m.put(1.5f, list15);

		m.put(1.8f, list18);

		m.put(2.0f, list20);

		m.put(2.5f, list25);

		m.put(3.0f, list30);

		m.put(3.5f, list35);

		m.put(4.0f, list40);

		m.put(4.5f, list45);

		m.put(5.5f, list55);

		m.put(6.5f, list65);

		for (Map.Entry<Float, List<Integer>> itemsListEntry : m.entrySet()) {

			Scheme s1 = getScheme();

			s1.setAmount(itemsListEntry.getKey());

			schemeRepository.persist(s1);

			for (Integer itemId : itemsListEntry.getValue()) {

				SchemeItem schemeItem = new SchemeItem();

				schemeItem.setItemId(itemId);

				schemeItem.setSchemeId(s1.getId());

				schemeItemRepository.persist(schemeItem);

			}

		}

	}

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

		System.out.println(allPartners.size());

		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<Item> items = itemRepository.selectAllByCatalogItemId(1022304);

		for (Item item : items) {

			List<InventoryItem> inventoryItems = inventoryItemRepository.selectByItemId(item.getId(), 0, 500);

			for (InventoryItem inventoryItem : inventoryItems) {

				List<PrebookingOrder> prebookingOrders = prebookingOrderRepository

						.selectByFofoIdAndCatalogIds(inventoryItem.getFofoId(), item.getCatalogItemId()).stream()

						.collect(Collectors.toList());

				if (prebookingOrders.size() > 0) {

					purchaseService.sendPrebookingNotifyMessage(prebookingOrders.get(0));

				}

				// inventoryItem.getFofoId()

			}

		}

		// throw new ProfitMandiBusinessException("", "", "");

		// prebookingOrderRepository.select

		// TODO Auto-generated method stub

	}

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