Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import java.io.Serializable;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

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.apache.solr.common.util.Hash;

import org.openqa.selenium.OutputType;

import org.openqa.selenium.TakesScreenshot;

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.chrome.ChromeDriver;

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.smartdukaan.cron.scheduled.ScheduledTasks;

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

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

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

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

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

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

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

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

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.enumuration.catalog.AmountType;

import com.spice.profitmandi.dao.enumuration.catalog.SchemeType;

import com.spice.profitmandi.dao.repository.GenericRepository;

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

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

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

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

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

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

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

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

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

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

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

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.service.inventory.InventoryService;

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 in.shop2020.model.v1.order.OrderStatus;

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

@Component

@Transactional(rollbackFor = Throwable.class)

public class RunOnceTasks {

	private static final Logger LOGGER = LogManager.getLogger(RunOnceTasks.class);

	@Autowired

	private LineItemRepository lineItemRepository;

	@Autowired

	private SaholicInventorySnapshotRepository saholicInventorySnapshotRepository;

	@Autowired

	private CsService csService;

	@Autowired

	private SaholicReservationInventorySnapshotRepository saholicReservationInventorySnapshotRepository;

	@Autowired

	private TargetSlabRepository targetSlabRepository;

	@Autowired

	private PartnerTargetRepository partnerTargetRepository;

	@Autowired

	private SellerWarehouseRepository sellerWarehouseRepository;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

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

	// 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 InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private SchemeInOutRepository schemeInOutRepository;

	@Autowired

	private DebitNoteRepository debitNoteRepository;

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

	public void dropCorrection() throws Exception {

		walletService.rollbackAmountFromWallet(175128034, 274, 4, WalletReferenceType.PRICE_DROP,

				"Scheme  differential for Price Drop of Rs.712 on Samsung J6 J600GG, on 01-08-2018 for missing 1pc");

		walletService.rollbackAmountFromWallet(175128034, -259, 4, WalletReferenceType.PRICE_DROP,

				"Scheme  differential for Price Drop of Rs.712 on Samsung J6 J600GG, on 01-08-2018 for missing 1pc");

		List<InventoryItem> iis = inventoryItemRepository.selectByIds(new HashSet<>(Arrays.asList(3518, 3516)));

		schemeService.reverseSchemes(iis, 8,

				"Scheme  differential for Price Drop of Rs.712 on Samsung J6 J600GG, on 01-08-2018. Total 2 item(s)");

		List<InventoryItem> iis1 = inventoryItemRepository.selectByIds(new HashSet<>(Arrays.asList(3502, 3334, 3503)));

		schemeService.reverseSchemes(iis1, 13,

				"Scheme  differential for Price Drop of Rs.485 on Samsung Galaxy J4 J400FD, on 18-07-2018. Total 3 item(s)");

		List<InventoryItem> iis2 = inventoryItemRepository.selectByIds(new HashSet<>(Arrays.asList(3319)));

		schemeService.reverseSchemes(iis2, 13,

				"Scheme  differential for Price Drop of Rs.485 on Samsung Galaxy J4 J400FD, on 18-07-2018. Total 1 item(s)");

	}

	public void schemeRollback() throws Exception {

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

		fofoIdAmount.put(175135218, 1942f);

		String description = "Price drop/differential rolled out as, they were already returned, Total 2pcs.";

		for (Map.Entry<Integer, Float> fofoIdAmountEntry : fofoIdAmount.entrySet()) {

			Integer fofoId = fofoIdAmountEntry.getKey();

			Float amount = fofoIdAmountEntry.getValue();

			walletService.rollbackAmountFromWallet(fofoId, amount, 4, WalletReferenceType.PRICE_DROP, description);

		}

		fofoIdAmount.put(175135218, 438f);

		for (Map.Entry<Integer, Float> fofoIdAmountEntry : fofoIdAmount.entrySet()) {

			Integer fofoId = fofoIdAmountEntry.getKey();

			Float amount = fofoIdAmountEntry.getValue();

			walletService.rollbackAmountFromWallet(fofoId, amount, 4, WalletReferenceType.PRICE_DROP, description);

		}

	}

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

						orderRepository.persist(order);

					}

				}

			}

		}

	}

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

	}

	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<? extends Serializable>> 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 createMonthlyTargets() throws Exception {

		Map<String, List<TargetSlab>> defaultSlabs = targetSlabRepository.getAllDefaultSlabs();

		for (String memberType : defaultSlabs.keySet()) {

			PartnerTargetDetails ptd = new PartnerTargetDetails();

			ptd.setBrandName(null);

			LocalDate startDate = LocalDate.now().withDayOfMonth(1);

			int totalDays = startDate.lengthOfMonth();

			String monthName = startDate.getMonth().toString();

			ptd.setStartDate(startDate.atStartOfDay());

			ptd.setEndDate(startDate.plusDays(totalDays - 1).atTime(LocalTime.MAX));

			ptd.setTargetName(String.format("%s Sales Target for %s Partners", monthName, memberType));

			partnerTargetRepository.persist(ptd);

			TargetSlabRepositoryImpl.TYPE_PARTNER_MAPPING.get(memberType).forEach(x -> {

				x.setTargetId(ptd.getId());

				partnerTargetRepository.persist(x);

			});

			List<TargetSlab> slabs = defaultSlabs.get(memberType);

			slabs.stream().forEach(x -> {

				x.setTargetId(ptd.getId());

				targetSlabRepository.persist(x);

			});

		}

	}

	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<SaholicInventorySnapshot> saholicInventorySnapshots =

		 * saholicInventorySnapshotRepository.selectAll(); Map<Integer, Integer>

		 * itemReservedMap = saholicInventorySnapshots.stream().filter(x ->

		 * x.getReserved() > 0)

		 * .collect(Collectors.groupingBy(SaholicInventorySnapshot::getItemId,

		 * Collectors.summingInt(SaholicInventorySnapshot::getReserved)));

		 */

		List<Order> allInProcessOrders = orderRepository.selectAllOrder(OrderStatus.SUBMITTED_FOR_PROCESSING);

		/*

		 * Map<Integer, Integer> lineItemQtyMap = allInProcessOrders

		 * .stream().collect(Collectors.groupingBy(y -> y.getLineItem().getItemId(),

		 * Collectors.summingInt(y -> y.getLineItem().getQuantity())));

		 */

		/*

		 * Map<Integer, Order> orderMap =

		 * allInProcessOrders.stream().collect(Collectors.toMap(Order::getId, x->x));

		 * Map<Integer, List<Order>> itemOrdersMap = allInProcessOrders.stream()

		 * .collect(Collectors.groupingBy(o->o.getLineItem().getItemId(),

		 * Collectors.toList()));

		 */

		Map<String, Integer> lineItemWhQtyMap = allInProcessOrders.stream()

				.collect(Collectors.groupingBy(y -> y.getLineItem().getItemId() + "-" + y.getFulfilmentWarehouseId(),

						Collectors.summingInt(y -> y.getLineItem().getQuantity())));

		/*

		 * itemReservedMap.forEach((itemId, reserved)->{

		 * if(lineItemQtyMap.containsKey(itemId)) { int orderedQty =

		 * lineItemQtyMap.get(itemId); System.out.printf("%d\t%d\t%d\n",itemId,

		 * orderedQty, reserved); } else {

		 * saholicInventorySnapshotRepository.removeAllReservations(itemId);

		 * System.out.printf("%d\t%d\t%d\n",itemId, 0, reserved); } });

		 */

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

		});

		/*

		 * List<SaholicReservationInventorySnapshot> reservationInventorySnapshots =

		 * saholicReservationInventorySnapshotRepository.selectAll(); Map<Integer,

		 * SaholicReservationInventorySnapshot> reservationInventorySnapshotsMap

		 * =reservationInventorySnapshots.stream()

		 * .collect(Collectors.toMap(x->x.getOrderId(), x->x));

		 * 

		 * List<Integer> orderIds =

		 * reservationInventorySnapshots.stream().map(x->x.getOrderId()).collect(

		 * Collectors.toList()); List<Order> orders =

		 * orderRepository.selectByOrderIds(orderIds);

		 * orders.stream().filter(x->Arrays.asList(OrderStatus.PAYMENT_PENDING,

		 * OrderStatus.PAYMENT_FAILED). contains(x.getStatus())).forEach(x->{

		 * SaholicReservationInventorySnapshot snapshot =

		 * reservationInventorySnapshotsMap.get(x.getId()); try {

		 * saholicInventorySnapshotRepository.reduceReservationCount(snapshot.getItemId(

		 * ), snapshot.getWarehouseId(), snapshot.getReserved(), snapshot.getOrderId());

		 * System.out.printf("%d Reduced by %d for Order Id %d\n",snapshot.getItemId(),

		 * snapshot.getReserved(), snapshot.getOrderId()); }

		 * catch(ProfitMandiBusinessException e) {

		 * LOGGER.info("Problem whiile reducing count for Order Id - {}",

		 * snapshot.getOrderId()); } });

		 */

		// throw new Exception();

	}

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

		WebDriver driver = new ChromeDriver();

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

			String base64Image = ((TakesScreenshot)driver).getScreenshotAs(OutputType.BASE64);

			partnerSnapshotMap.put(fofoId, base64Image);

		}

		for(Map.Entry<String, Set<Integer>> entry : authUserPartnerIdMapping.entrySet()) {

			String email = entry.getKey();

			Set<Integer> partnerIds = entry.getValue();

			StringBuffer body = new StringBuffer();

			for(int fofoId: partnerIds) {

				body.append(String.format("<br><image src=\"%s\" />", partnerSnapshotMap.get(fofoId)));

			}

			Utils.sendHtmlMailWithAttachments(mailSender, new String[]{"amit.gupta@shop2020.in"}, new String[] {}, String.format("Franchise Screenshots - %s", FormattingUtils.formatDate(LocalDateTime.now())), body.toString());

		}

		driver.quit();

	}

}

//7015845171