Subversion Repositories SmartDukaan

package com.smartdukaan.cron.scheduled;

import java.sql.Timestamp;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.temporal.ChronoUnit;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;

import com.smartdukaan.cron.monitored.NagiosMonitorTasks;

import com.spice.profitmandi.common.enumuration.RechargeStatus;

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

import com.spice.profitmandi.dao.entity.dtr.DailyRecharge;

import com.spice.profitmandi.dao.entity.dtr.RechargeProvider;

import com.spice.profitmandi.dao.entity.dtr.RechargeProviderCreditWalletHistory;

import com.spice.profitmandi.dao.entity.dtr.RechargeTransaction;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.recharge.provider.OxigenRechargeProviderService;

import com.spice.profitmandi.service.recharge.provider.ThinkWalnutDigitalRechargeProviderService;

import com.spice.profitmandi.service.scheme.SchemeService;

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

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

@Component

@Transactional(rollbackFor = Throwable.class)

public class ScheduledTasks {

	@Value("${oxigen.recharge.transaction.url}")

	private String oxigenRechargeTransactionUrl;

	@Value("${oxigen.recharge.enquiry.url}")

	private String oxigenRechargeEnquiryUrl;

	@Value("${oxigen.recharge.auth.key}")

	private String oxigenRechargeAuthKey;

	@Value("${oxigen.recharge.validation.url}")

	private String oxigenRechargeValidationUrl;

	@Value("${oxigen.recharge.validation.auth.key}")

	private String oxigenRechargeValidationAuthKey;

	@Value("${think.walnut.digital.recharge.transaction.mobile.url}")

	private String thinkWalnutDigitalRechargeTransactionMobileUrl;

	@Value("${think.walnut.digital.recharge.transaction.dth.url}")

	private String thinkWalnutDigitalRechargeTransactionDthUrl;

	@Value("${think.walnut.digital.recharge.enquiry.url}")

	private String thinkWalnutDigitalRechargeEnquiryUrl;

	@Value("${think.walnut.digital.recharge.balance.url}")

	private String thinkWalnutDigitalRechargeBalanceUrl;

	@Value("${think.walnut.digital.recharge.username}")

	private String thinkWalnutDigitalRechargeUserName;

	@Value("${think.walnut.digital.recharge.password}")

	private String thinkWalnutDigitalRechargePassword;

	@Value("${think.walnut.digital.recharge.auth.key}")

	private String thinkWalnutDigitalRechargeAuthKey;

	@Autowired

	private PurchaseRepository purchaseRepository;

	@Autowired

	private SchemeService schemeService;

	@Autowired

	private RechargeTransactionRepository rechargeTransactionRepository;

	@Autowired

	private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Autowired

	private WalletService walletService;

	@Autowired

	private ThinkWalnutDigitalRechargeProviderService thinkWalnutDigitalRechargeProviderService;

	@Autowired

	private OxigenRechargeProviderService oxigenRechargeProviderService;

	@Autowired

	private RechargeProviderRepository rechargeProviderRepository;

	@Autowired

	private DailyRechargeRepository dailyRechargeRepository;

	@Value("${prod}")

	private boolean prod;

	private static final Logger LOGGER = LoggerFactory.getLogger(NagiosMonitorTasks.class);

	@Scheduled(cron = "1 00 * * * *")

	public void generateDailyRecharge() {

		List<RechargeProviderCreditWalletHistory> allCreditHistory = rechargeProviderCreditWalletHistoryRepository

				.selectAll(0, 2000);

		List<RechargeProvider> rechargeProviders = rechargeProviderRepository.selectAll();

		rechargeProviders.stream().forEach(x -> x.setAmount(0));

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

			Map<LocalDate, List<RechargeProviderCreditWalletHistory>> dateWiseProviderCreditsMap = allCreditHistory

					.stream().filter(z -> z.getProviderId() == x.getId())

					.collect(Collectors.groupingBy(x1 -> x1.getReceiveTimestamp().toLocalDate()));

			LOGGER.info("dateWiseProviderCreditsMap -- {}", dateWiseProviderCreditsMap);

			LocalDate endDate = LocalDate.now().plusDays(1);

			float previousDayClosing = 0;

			LocalDate date = LocalDate.of(2018, 4, 6);

			while (date.isBefore(endDate)) {

				List<RechargeTransaction> dateWiseRechargeTransactions = rechargeTransactionRepository

						.selectAllBetweenTimestamp(Arrays.asList(RechargeStatus.values()), date.atStartOfDay(),

								date.plusDays(1).atStartOfDay());

				List<RechargeTransaction> successfulTransactions = dateWiseRechargeTransactions.stream()

						.filter(y -> y.getStatus().equals(RechargeStatus.SUCCESS)).collect(Collectors.toList());

				float dailyAmount = 0;

				float totalCommission = 0;

				for (RechargeTransaction rechargeTransaction : successfulTransactions) {

					if (rechargeTransaction.getProviderId() == x.getId()) {

						dailyAmount += rechargeTransaction.getAmount();

						totalCommission += rechargeTransaction.getCommission();

					}

				}

				List<RechargeProviderCreditWalletHistory> rechargeHistoryList = dateWiseProviderCreditsMap.get(date);

				float dailyWalletRecharge = 0;

				if (rechargeHistoryList != null) {

					for (RechargeProviderCreditWalletHistory rechargeProviderCreditWalletHistory : rechargeHistoryList) {

						if (rechargeProviderCreditWalletHistory.getProviderId() == x.getId()) {

							dailyWalletRecharge += rechargeProviderCreditWalletHistory.getAmount();

						}

					}

				}

				if (dailyAmount > 0 || dailyWalletRecharge > 0) {

					DailyRecharge dailyRecharge = null;

					try {

						dailyRecharge = dailyRechargeRepository.selectByProviderIdAndCreateDate(x.getId(), date);

					} catch (Exception e) {

						LOGGER.info("Could not find Recharge entry");

					}

					if (dailyRecharge == null) {

						dailyRecharge = new DailyRecharge();

						dailyRecharge.setCreateDate(date);

					}

					dailyRecharge.setOpeningBalance(previousDayClosing);

					dailyRecharge.setProviderId(x.getId());

					dailyRecharge.setWalletRechargeAmount(dailyWalletRecharge);

					dailyRecharge.setTotalAmount(dailyAmount);

					dailyRecharge.setTotalCommission(totalCommission);

					float closingBalance = dailyRecharge.getOpeningBalance() + dailyWalletRecharge - dailyAmount;

					dailyRecharge.setClosingBalance(closingBalance);

					dailyRechargeRepository.persist(dailyRecharge);

					x.setAmount(x.getAmount() + dailyRecharge.getClosingBalance() - dailyRecharge.getOpeningBalance());

					previousDayClosing = dailyRecharge.getClosingBalance();

				}

				date = date.plusDays(1);

			}

			rechargeProviderRepository.persist(x);

		});

		LOGGER.info("executio");

	}

	@Scheduled(cron = "0 45 * * * *")

	public void reconcileRecharge() throws Exception {

		LocalDateTime fromDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS).minusDays(30);

		LocalDateTime toDate = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS);

		List<RechargeStatus> nonSuccessRechargeStatuses = new ArrayList<>(Arrays.asList(RechargeStatus.values()));

		LOGGER.info("nonSuccessRechargeStatuses {} ", nonSuccessRechargeStatuses);

		nonSuccessRechargeStatuses.remove(RechargeStatus.SUCCESS);

		nonSuccessRechargeStatuses.remove(RechargeStatus.FAILED);

		RechargeCredential thinkWalnutDigitalRechargeEnquiryCredential = new RechargeCredential();

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUrl(thinkWalnutDigitalRechargeEnquiryUrl);

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUserName(thinkWalnutDigitalRechargeUserName);

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargePassword(thinkWalnutDigitalRechargePassword);

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeAuthKey(thinkWalnutDigitalRechargeAuthKey);

		Map<String, RechargeStatus> requestRechargeStatusChanged = new HashMap<>();

		List<RechargeTransaction> rechargeTransactions = rechargeTransactionRepository

				.selectAllBetweenTimestamp(nonSuccessRechargeStatuses, fromDate, toDate);

		for (RechargeTransaction rechargeTransaction : rechargeTransactions) {

			try {

				int providerId = rechargeTransaction.getProviderId();

				if (providerId == 1) {

					oxigenRechargeProviderService.doCheckStatusRequest(oxigenRechargeEnquiryUrl, oxigenRechargeAuthKey,

							rechargeTransaction);

				} else if (providerId == 2) {

					thinkWalnutDigitalRechargeProviderService

							.doCheckStatusRequest(thinkWalnutDigitalRechargeEnquiryCredential, rechargeTransaction);

				}

				if (rechargeTransaction.getStatus().equals(RechargeStatus.SUCCESS)

						|| rechargeTransaction.getStatus().equals(RechargeStatus.FAILED)) {

					requestRechargeStatusChanged.put(rechargeTransaction.getRequestId(),

							rechargeTransaction.getStatus());

				}

			} catch (Exception e) {

				LOGGER.info("Could not check status for Request {}", rechargeTransaction.getRequestId());

			}

		}

		LOGGER.info("Reconcile recharge ran successfully");

	}

	@Scheduled(cron = "0 45 0 * * *")

	public void processScheme() throws Exception {

		LocalDateTime fromDate = LocalDateTime.now().minusDays(15);

		LOGGER.info("Started execution at {}", LocalDateTime.now());

		List<Purchase> purchases = purchaseRepository.selectFromPurchaseCompleteDate(fromDate);

		for (Purchase purchase : purchases) {

			try {

				schemeService.processSchemeIn(purchase.getId(), purchase.getFofoId());

			} catch (Exception e) {

				LOGGER.error("Error while processing purchase {} for scheme In ", purchase.getId());

				e.printStackTrace();

			}

		}

		List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(fromDate);

		for (FofoOrder fofoOrder : fofoOrders) {

			try {

				schemeService.processSchemeOut(fofoOrder.getId(), fofoOrder.getFofoId());

			} catch (Exception e) {

				LOGGER.error("Error while processing sale order {} for scheme Out", fofoOrder.getId());

			}

		}

		LOGGER.info("Schemes process successfully.");

	}

	@Scheduled(cron = "0 30 10 1,16 * ?")

	public void processRechargeCashback() throws Throwable {

		int referenceId = (int)Timestamp.valueOf(LocalDateTime.now()).getTime()/1000;

		List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository.getPendingCashBackRehargeTransactions();

		Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(Collectors.groupingBy(x->x.getId(), Collectors.summingDouble(x->x.getCommission())));

		for (Map.Entry<Object, Double>totalRetailerCashback : totalRetailerCashbacks.entrySet()) {

			int retailerId = (Integer)totalRetailerCashback.getKey();

			float amount = totalRetailerCashback.getValue().floatValue();

			walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK, "Recharge Cashback", Math.round(amount));

		}

		pendingTransactions.forEach(x-> {

			x.setCashbackTimestamp(LocalDateTime.now());

			x.setCashbackReference(referenceId);

			rechargeTransactionRepository.persist(x);

		});

		LOGGER.info("Cashbacks for Recharge processed Successfully");

	}

}