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

import org.springframework.transaction.annotation.Transactional;

import com.spice.profitmandi.common.model.CustomRetailer;

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

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

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.repository.dtr.FofoStoreRepository;

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

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

import com.spice.profitmandi.service.transaction.TransactionService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.service.wallet.WalletService;

@Component

@Transactional(rollbackFor = Throwable.class)

public class RunOnceTasks {

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

	@Autowired

	private LineItemRepository lineItemRepository;

	@Autowired

	private WalletService walletService;

	@Autowired

	private InventoryService inventoryService;

	@Autowired

	private TransactionService transactionService;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private LineItemImeisRepository lineItemImeisRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private PurchaseRepository purchaseRepository;

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

		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 getInvestmentDetails() throws Exception {

		LOGGER.info(

				"Code\tStoreName\tEmail\tMobile\tminimumInvestment\twalletAmount\tinStockAmount\tunbilledStockAmount\tgrnPendingStockAmount\tTotalInvested");

		List<FofoStore> fofoStores = fofoStoreRepository.selectAll();

		Map<Integer, CustomRetailer> customRetailerMap = retailerService

				.getFofoRetailers(fofoStores.stream().map(x -> x.getId()).collect(Collectors.toList()));

		for (FofoStore fofoStore : fofoStores) {

			CustomRetailer retailer = customRetailerMap.get(fofoStore.getId());

			float walletAmount = walletService.getUserWallet(fofoStore.getId()).getAmount();

			float inStockAmount = inventoryService.getTotalAmountInStock(fofoStore.getId());

			float unbilledStockAmount = 0;

			List<Order> unbilledOrders = transactionService.getInTransitOrders(fofoStore.getId());

			for (Order unBilledOrder : unbilledOrders) {

				unbilledStockAmount += unBilledOrder.getTotalAmount();

			}

			float grnPendingStockAmount = 0;

			List<Order> grnPendingOrders = transactionService.getGrnPendingOrders(fofoStore.getId());

			for (Order grnPendingOrder : grnPendingOrders) {

				grnPendingStockAmount += grnPendingOrder.getTotalAmount();

			}

			float totalInvestedAmount = walletAmount + inStockAmount + unbilledStockAmount + grnPendingStockAmount;

			try {

				LOGGER.info(String.join("\t", fofoStore.getCode(), retailer.getBusinessName(), retailer.getMobileNumber(),

						String.valueOf(fofoStore.getMinimumInvestment()), String.valueOf(walletAmount),

						String.valueOf(inStockAmount), String.valueOf(unbilledStockAmount),

						String.valueOf(grnPendingStockAmount), String.valueOf(totalInvestedAmount)));

			} catch (Exception e) {

				continue;

			}

		}

	}

}