Subversion Repositories SmartDukaan

package com.smartdukaan.cron.migrations;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

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

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;

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

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

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

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

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

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

	@Autowired

	private SchemeInOutRepository schemeInOutRepository;

	@Autowired

	private DebitNoteRepository debitNoteRepository;

	@Autowired

	private GenericRepository genericRepository;

	@Autowired

	private PurchaseRepository purchaseRepository;

	@Autowired

	private PriceDropService priceDropService;

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

		Map<String, List<Order>> invoiceOrdersMap = orderRepository.selectAllChallans().stream().filter(x->x.getLineItem().getHsnCode().equals("NOGST"))

				.collect(Collectors.groupingBy(Order::getInvoiceNumber, Collectors.toList()));

		for(String invoice : invoiceOrdersMap.keySet()) {

			Order oneOrder = invoiceOrdersMap.get(invoice).get(0);

			int totalOrders = invoiceOrdersMap.get(invoice).size();

			LineItem lineItem = oneOrder.getLineItem();

			LOGGER.info("Total Orders {}, Challan No {}, Product Name {} {} {}, hsnCode", 

					totalOrders, oneOrder.getInvoiceNumber(), lineItem.getBrand(), lineItem.getModelName(), lineItem.getModelName());

		}

	}

}