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.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.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.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.Utils;

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

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

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

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

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

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

@Component

@Transactional(rollbackFor = Throwable.class)

public class RunOnceTasks {

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

	@Autowired

	private LineItemRepository lineItemRepository;

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

	@Autowired

	private TransactionService transactionService;

	// Service for Tertiary/Partner Orders

	@Autowired

	private OrderService orderService;

	@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() {

		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 (quantityToReduce > 0 && ii.getGoodQuantity() > 0) {

							LOGGER.info("Changed in inventoryItems {}, {}, {}, {}, {}, {}",

									purchase.getPurchaseReference(), ii.getId(), ii.getItemId(),

									ii.getInitialQuantity(), ii.getGoodQuantity(), quantityToReduce);

							if (ii.getGoodQuantity() > 0) {

								List<ScanRecord> scanRecords = scanRecordRepository.selectByInventoryItemId(ii.getId());

								for (ScanRecord scanRecord : scanRecords) {

									if (scanRecord.getType().equals(ScanType.PURCHASE)) {

										CurrentInventorySnapshot cis = currentInventorySnapshotRepository

												.selectByItemIdAndFofoId(itemQtyEntry.getKey(), purchase.getFofoId());

										scanRecord.setQuantity(scanRecord.getQuantity() - ii.getGoodQuantity());

										ii.setInitialQuantity(ii.getInitialQuantity() - ii.getBadQuantity());

										quantityToReduce = quantityToReduce - ii.getGoodQuantity();

										ii.setGoodQuantity(0);

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

										purchase.setUnfullfilledNonSerializedQuantity(

												purchase.getUnfullfilledNonSerializedQuantity() + quantityToReduce);

										LOGGER.info("Rectified {}, {}, {}, {}, {}, {}", purchase.getPurchaseReference(),

												ii.getId(), ii.getItemId(), ii.getInitialQuantity(),

												ii.getGoodQuantity(), quantityToReduce);

										break;

									}

								}

							}

						}

					}

				}

			}

		}

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

			});

		}

	}

}