Subversion Repositories SmartDukaan

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.transaction.LoanRepository;

import com.spice.profitmandi.dao.repository.transaction.*;

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

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

	private String oxigenRechargeTransactionUrl;

    private String oxigenRechargeTransactionUrl;

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

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

	private String oxigenRechargeEnquiryUrl;

    private String oxigenRechargeEnquiryUrl;

	@Autowired

    @Autowired

	private RegionRepository regionRepository;

    private RegionRepository regionRepository;

	@Autowired

    @Autowired

	private ServiceConfigService serviceConfigService;

    private ServiceConfigService serviceConfigService;

	@Autowired

    @Autowired

	private TecnoImeiActivation tecnoImeiActivation;

    private TecnoImeiActivation tecnoImeiActivation;

	private static final DateTimeFormatter leadTimeFormatter = DateTimeFormatter.ofPattern("d LLL, hh:mm a");

    private static final DateTimeFormatter leadTimeFormatter = DateTimeFormatter.ofPattern("d LLL, hh:mm a");

	@Autowired

    @Autowired

	private PartnerRegionRepository partnerRegionRepository;

    private PartnerRegionRepository partnerRegionRepository;

	@Autowired

    @Autowired

	private EmployeeAttendanceRepository employeeAttendanceRepository;

    private EmployeeAttendanceRepository employeeAttendanceRepository;

	@Autowired

    @Autowired

	VivoImeiActivationService vivoImeiActivationService;

    VivoImeiActivationService vivoImeiActivationService;

	@Autowired

    @Autowired

	ItelImeiActivationService itelImeiActivationService;

    ItelImeiActivationService itelImeiActivationService;

	@Autowired

    @Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

    private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

    @Autowired

	private ActivatedImeiRepository activatedImeiRepository;

    private ActivatedImeiRepository activatedImeiRepository;

	@Autowired

    @Autowired

	private LineItemRepository lineItemRepository;

    private LineItemRepository lineItemRepository;

	@Autowired

    @Autowired

	private LeadRepository leadRepository;

    private LeadRepository leadRepository;

	@Autowired

    @Autowired

	private AuthRepository authRepository;

    private AuthRepository authRepository;

	@Autowired

    @Autowired

	private PriceDropService priceDropService;

    private PriceDropService priceDropService;

	@Autowired

    @Autowired

	private FranchiseeVisitRepository franchiseeVisitRepository;

    private FranchiseeVisitRepository franchiseeVisitRepository;

	@Autowired

    @Autowired

	private FranchiseeActivityRepository franchiseeActivityRepository;

    private FranchiseeActivityRepository franchiseeActivityRepository;

	@Autowired

    @Autowired

	private HdfcPaymentRepository hdfcPaymentRepository;

    private HdfcPaymentRepository hdfcPaymentRepository;

	@Autowired

    @Autowired

	private CsService csService;

    private CsService csService;

	@Autowired

    @Autowired

	private SaholicInventoryService saholicInventoryService;

    private SaholicInventoryService saholicInventoryService;

	@Autowired

    @Autowired

	private InsurancePolicyRepository insurancePolicyRepository;

    private InsurancePolicyRepository insurancePolicyRepository;

	@Autowired

    @Autowired

	private ToffeeService toffeeService;

    private ToffeeService toffeeService;

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

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

	private String oxigenRechargeAuthKey;

    private String oxigenRechargeAuthKey;

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

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

	private String oxigenRechargeValidationUrl;

    private String oxigenRechargeValidationUrl;

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

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

	private String oxigenRechargeValidationAuthKey;

    private String oxigenRechargeValidationAuthKey;

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

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

	private String thinkWalnutDigitalRechargeTransactionMobileUrl;

    private String thinkWalnutDigitalRechargeTransactionMobileUrl;

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

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

	private String thinkWalnutDigitalRechargeTransactionDthUrl;

    private String thinkWalnutDigitalRechargeTransactionDthUrl;

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

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

	private String thinkWalnutDigitalRechargeEnquiryUrl;

    private String thinkWalnutDigitalRechargeEnquiryUrl;

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

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

	private String thinkWalnutDigitalRechargeBalanceUrl;

    private String thinkWalnutDigitalRechargeBalanceUrl;

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

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

	private String thinkWalnutDigitalRechargeUserName;

    private String thinkWalnutDigitalRechargeUserName;

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

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

	private String thinkWalnutDigitalRechargePassword;

    private String thinkWalnutDigitalRechargePassword;

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

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

	private String thinkWalnutDigitalRechargeAuthKey;

    private String thinkWalnutDigitalRechargeAuthKey;

	@Autowired

    @Autowired

	private PurchaseRepository purchaseRepository;

    private PurchaseRepository purchaseRepository;

	@Autowired

    @Autowired

	private PriceDropIMEIRepository priceDropIMEIRepository;

    private PriceDropIMEIRepository priceDropIMEIRepository;

	@Autowired

    @Autowired

	PriceDropRepository priceDropRepository;

    PriceDropRepository priceDropRepository;

	@Autowired

    @Autowired

	private PartnerTypeChangeRepository partnerTypeChangeRepository;

    private PartnerTypeChangeRepository partnerTypeChangeRepository;

	@Autowired

    @Autowired

	private SchemeService schemeService;

    private SchemeService schemeService;

	@Autowired

    @Autowired

	private ServiceConfigRepository serviceConfigRepository;

    private ServiceConfigRepository serviceConfigRepository;

	@Value("${delhivery.tracking.token}")

    @Value("${delhivery.tracking.token}")

	private String token;

    private String token;

	private static final String[] STOCK_AGEING_MAIL_LIST = new String[] { "uday.singh@smartudkaan.com",

    private static final String[] STOCK_AGEING_MAIL_LIST = new String[]{"uday.singh@smartudkaan.com",

			"mohinder.mutreja@smartdukaan.com", "ankit.bhatia@smartdukaan.com", "tarun.verma@smartdukaan.com",

            "mohinder.mutreja@smartdukaan.com", "ankit.bhatia@smartdukaan.com", "tarun.verma@smartdukaan.com",

			"kuldeep.kumar@smartdukaan.com", "manish.gupta@smartdukaan.com" };

            "kuldeep.kumar@smartdukaan.com", "manish.gupta@smartdukaan.com"};

	private static final String[] ITEMWISE_PENDING_INDENT_MAIL_LIST = new String[] { "kamini.sharma@smartdukaan.com",

    private static final String[] ITEMWISE_PENDING_INDENT_MAIL_LIST = new String[]{"kamini.sharma@smartdukaan.com",

			"tarun.verma@smartdukaan.com", "uday.singh@smartdukaan.com", "kuldeep.kumar@smartdukaan.com",

            "tarun.verma@smartdukaan.com", "uday.singh@smartdukaan.com", "kuldeep.kumar@smartdukaan.com",

			"niranjan.kala@smartdukaan.com" };

            "niranjan.kala@smartdukaan.com"};

	private static final String[] INDENT_TERTIARY_MAIL_LIST = new String[] { "uday.singh@smartdukaan.com",

    private static final String[] INDENT_TERTIARY_MAIL_LIST = new String[]{"uday.singh@smartdukaan.com",

			"kuldeep.kumar@smartdukaan.com" };

            "kuldeep.kumar@smartdukaan.com"};

	private static final String[] EMPLOYEE_ATTENDANCE_MAIL_LIST = new String[] { "sm@smartdukaan.com",

    private static final String[] EMPLOYEE_ATTENDANCE_MAIL_LIST = new String[]{"sm@smartdukaan.com",

			"sm@smartdukaan.com" };

            "sm@smartdukaan.com"};

	private List<OrderStatus> orderStatusList = Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING);

    private List<OrderStatus> orderStatusList = Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING);

	@Autowired

    @Autowired

	private ReporticoService reporticoService;

    private ReporticoService reporticoService;

	@Autowired

    @Autowired

	private PartnerInvestmentService partnerInvestmentService;

    private PartnerInvestmentService partnerInvestmentService;

	@Autowired

    @Autowired

	private PositionRepository positionRepository;

    private PositionRepository positionRepository;

	@Autowired

    @Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

    private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

    @Autowired

	private NotificationService notificationService;

    private NotificationService notificationService;

	@Autowired

    @Autowired

	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	@Autowired

    @Autowired

	private SchemeInOutRepository schemeInOutRepository;

    private SchemeInOutRepository schemeInOutRepository;

	@Autowired

    @Autowired

	private RechargeTransactionRepository rechargeTransactionRepository;

    private RechargeTransactionRepository rechargeTransactionRepository;

	@Autowired

    @Autowired

	private CustomerAddressRepository customerAddressRepository;

    private CustomerAddressRepository customerAddressRepository;

	@Autowired

    @Autowired

	private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;

    private RechargeProviderCreditWalletHistoryRepository rechargeProviderCreditWalletHistoryRepository;

	@Autowired

    @Autowired

	private FofoLineItemRepository fofoLineItemRepository;

    private FofoLineItemRepository fofoLineItemRepository;

	@Autowired

    @Autowired

	private FofoOrderRepository fofoOrderRepository;

    private FofoOrderRepository fofoOrderRepository;

	@Autowired

    @Autowired

	private UserWalletHistoryRepository userWalletHistoryRepository;

    private UserWalletHistoryRepository userWalletHistoryRepository;

	@Autowired

    @Autowired

	private UserWalletRepository userWalletRepository;

    private UserWalletRepository userWalletRepository;

	@Autowired

    @Autowired

	private InventoryItemRepository inventoryItemRepository;

    private InventoryItemRepository inventoryItemRepository;

	@Autowired

    @Autowired

	private WalletService walletService;

    private WalletService walletService;

	@Autowired

    @Autowired

	private ThinkWalnutDigitalRechargeProviderService thinkWalnutDigitalRechargeProviderService;

    private ThinkWalnutDigitalRechargeProviderService thinkWalnutDigitalRechargeProviderService;

	@Autowired

    @Autowired

	private OxigenRechargeProviderService oxigenRechargeProviderService;

    private OxigenRechargeProviderService oxigenRechargeProviderService;

	@Autowired

    @Autowired

	private RechargeProviderRepository rechargeProviderRepository;

    private RechargeProviderRepository rechargeProviderRepository;

	@Autowired

    @Autowired

	private ScanRecordRepository scanRecordRepository;

    private ScanRecordRepository scanRecordRepository;

	@Autowired

    @Autowired

	private DailyRechargeRepository dailyRechargeRepository;

    private DailyRechargeRepository dailyRechargeRepository;

	@Autowired

    @Autowired

	private FofoStoreRepository fofoStoreRepository;

    private FofoStoreRepository fofoStoreRepository;

	@Value("${prod}")

    @Value("${prod}")

	private boolean prod;

    private boolean prod;

	@Autowired

    @Autowired

	private StateGstRateRepository stateGstRateRepository;

    private StateGstRateRepository stateGstRateRepository;

	@Autowired

    @Autowired

	private RetailerService retailerService;

    private RetailerService retailerService;

	@Autowired

    @Autowired

	private TransactionService transactionService;

    private TransactionService transactionService;

	@Autowired

    @Autowired

	private ItemRepository itemRepository;

    private ItemRepository itemRepository;

	@Autowired

    @Autowired

	private OrderRepository orderRepository;

    private OrderRepository orderRepository;

	@Autowired

    @Autowired

	private OrderService orderService;

    private OrderService orderService;

	@Autowired

    @Autowired

	private SchemeRepository schemeRepository;

    private SchemeRepository schemeRepository;

	@Autowired

    @Autowired

	private SchemeItemRepository schemeItemRepository;

    private SchemeItemRepository schemeItemRepository;

	@Autowired

    @Autowired

	private JavaMailSender mailSender;

    private JavaMailSender mailSender;

	@Autowired

    @Autowired

	private PartnerTargetRepository partnerTargetRepository;

    private PartnerTargetRepository partnerTargetRepository;

	@Autowired

    @Autowired

	@Qualifier(value = "googleMailSender")

    @Qualifier(value = "googleMailSender")

	private JavaMailSender googleMailSender;

    private JavaMailSender googleMailSender;

	@Autowired

    @Autowired

	private InventoryService inventoryService;

    private InventoryService inventoryService;

	@Autowired

    @Autowired

	private AddressRepository addressRepository;

    private AddressRepository addressRepository;

	@Autowired

    @Autowired

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

    @Autowired

	private Mongo mongoClient;

    private Mongo mongoClient;

	@Autowired

    @Autowired

	private DeviceRepository deviceRepository;

    private DeviceRepository deviceRepository;

	@Autowired

    @Autowired

	private PushNotificationRepository pushNotificationRepository;

    private PushNotificationRepository pushNotificationRepository;

	@Autowired

    @Autowired

	private NotificationCampaignRepository notificationCampaignRepository;

    private NotificationCampaignRepository notificationCampaignRepository;

	@Autowired

    @Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

    @Autowired

	private FocusedModelRepository focusedModelRepository;

    private FocusedModelRepository focusedModelRepository;

	@Autowired

    @Autowired

	private UserAccountRepository userAccountRepository;

    private UserAccountRepository userAccountRepository;

	@Autowired

    @Autowired

	private UserRepository userUserRepository;

    private UserRepository userUserRepository;

	@Autowired

    @Autowired

	private com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;

    private com.spice.profitmandi.dao.repository.dtr.UserRepository dtrUserRepository;

	@Autowired

    @Autowired

	private UserCampaignRepository userCampaignRepository;

    private UserCampaignRepository userCampaignRepository;

	@Autowired

    @Autowired

	private Gson gson;

    private Gson gson;

	@Autowired

    @Autowired

	private TicketRepository ticketRepository;

    private TicketRepository ticketRepository;

	@Autowired

    @Autowired

	private RefferalRepository refferalRepository;

    private RefferalRepository refferalRepository;

	@Autowired

    @Autowired

	private PartnerProblemRepository partnerProblemRepository;

    private PartnerProblemRepository partnerProblemRepository;

	@Autowired

    @Autowired

	private PendingOrderRepository pendingOrderRepository;

    private PendingOrderRepository pendingOrderRepository;

	@Autowired

    @Autowired

	private PendingOrderItemRepository pendingOrderItemRepository;

    private PendingOrderItemRepository pendingOrderItemRepository;

	@Value("${razorpay.account.keyId}")

    @Value("${razorpay.account.keyId}")

	private String keyId;

    private String keyId;

	@Value("${razorpay.account.keySecret}")

    @Value("${razorpay.account.keySecret}")

	private String keySecret;

    private String keySecret;

	@Autowired

    @Autowired

	private RazorpayPaymentService razorPaymentService;

    private RazorpayPaymentService razorPaymentService;

	@Autowired

    @Autowired

	private RazorPayRepository razorPayRepository;

    private RazorPayRepository razorPayRepository;

	@Autowired

    @Autowired

	private PendingOrderService pendingOrderService;

    private PendingOrderService pendingOrderService;

	@Autowired

    @Autowired

	private CustomerRepository customerRepository;

    private CustomerRepository customerRepository;

	@Autowired

    @Autowired

	private RestClient restClient;

    private RestClient restClient;

	@Autowired

    @Autowired

	private MandiiService mandiiService;

    private MandiiService mandiiService;

	@Autowired

    @Autowired

	CreditAccountRepository creditAccountRepository;

    CreditAccountRepository creditAccountRepository;

	@Autowired

    @Autowired

	CustomerOfferRepository customerOfferRepository;

    CustomerOfferRepository customerOfferRepository;

	@Autowired

    @Autowired

	CustomerOfferItemRepository customerOfferItemRepository;

    CustomerOfferItemRepository customerOfferItemRepository;

	@Autowired

    @Autowired

	private FofoSolr fofoSolr;

    private FofoSolr fofoSolr;

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

	private String FCM_URL = "https://fcm.googleapis.com/fcm/send";

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

	private String FCM_API_KEY = "AAAASAjNcn4:APA91bG6fWRIgYJI0L9gCjP5ynaXz2hJHYKtD9dfH7Depdv31Nd9APJwhx-OPkAJ1WSz4BGNYG8lHThLFSjDGFxIwUZv241YcAJEGDLgt86mxq9FXJe-yBRu-S0_ZwHqmX-QaVKl5F_A";

    private String FCM_URL = "https://fcm.googleapis.com/fcm/send";

	@Autowired

    private String FCM_API_KEY = "AAAASAjNcn4:APA91bG6fWRIgYJI0L9gCjP5ynaXz2hJHYKtD9dfH7Depdv31Nd9APJwhx-OPkAJ1WSz4BGNYG8lHThLFSjDGFxIwUZv241YcAJEGDLgt86mxq9FXJe-yBRu-S0_ZwHqmX-QaVKl5F_A";

	private TagListingRepository tagListingRepository;

    @Autowired

	public void generateDailyRecharge() {

    private TagListingRepository tagListingRepository;

		List<RechargeProviderCreditWalletHistory> allCreditHistory = rechargeProviderCreditWalletHistoryRepository

				.selectAll(0, 2000);

    public void generateDailyRecharge() {

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

        List<RechargeProviderCreditWalletHistory> allCreditHistory = rechargeProviderCreditWalletHistoryRepository

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

                .selectAll(0, 2000);

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

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

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

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

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

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

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

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

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

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

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

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

			float previousDayClosing = 0;

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

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

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

			while (date.isBefore(endDate)) {

            float previousDayClosing = 0;

				List<RechargeTransaction> dateWiseRechargeTransactions = rechargeTransactionRepository

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

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

            while (date.isBefore(endDate)) {

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

                List<RechargeTransaction> dateWiseRechargeTransactions = rechargeTransactionRepository

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

				List<RechargeTransaction> successfulTransactions = dateWiseRechargeTransactions.stream()

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

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

                List<RechargeTransaction> successfulTransactions = dateWiseRechargeTransactions.stream()

				float dailyAmount = 0;

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

				float totalCommission = 0;

				for (RechargeTransaction rechargeTransaction : successfulTransactions) {

                float dailyAmount = 0;

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

                float totalCommission = 0;

						dailyAmount += rechargeTransaction.getAmount();

                for (RechargeTransaction rechargeTransaction : successfulTransactions) {

						totalCommission += rechargeTransaction.getCommission();

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

					}

                        dailyAmount += rechargeTransaction.getAmount();

				}

                        totalCommission += rechargeTransaction.getCommission();

                    }

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

                }

				float dailyWalletRecharge = 0;

				if (rechargeHistoryList != null) {

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

					for (RechargeProviderCreditWalletHistory rechargeProviderCreditWalletHistory : rechargeHistoryList) {

                float dailyWalletRecharge = 0;

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

                if (rechargeHistoryList != null) {

							dailyWalletRecharge += rechargeProviderCreditWalletHistory.getAmount();

                    for (RechargeProviderCreditWalletHistory rechargeProviderCreditWalletHistory : rechargeHistoryList) {

						}

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

					}

                            dailyWalletRecharge += rechargeProviderCreditWalletHistory.getAmount();

				}

                        }

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

                    }

					DailyRecharge dailyRecharge = null;

                }

					try {

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

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

                    DailyRecharge dailyRecharge = null;

					} catch (Exception e) {

                    try {

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

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

					}

                    } catch (Exception e) {

					if (dailyRecharge == null) {

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

						dailyRecharge = new DailyRecharge();

                    }

						dailyRecharge.setCreateDate(date);

                    if (dailyRecharge == null) {

					}

                        dailyRecharge = new DailyRecharge();

					dailyRecharge.setOpeningBalance(previousDayClosing);

                        dailyRecharge.setCreateDate(date);

					dailyRecharge.setProviderId(x.getId());

                    }

					dailyRecharge.setWalletRechargeAmount(dailyWalletRecharge);

                    dailyRecharge.setOpeningBalance(previousDayClosing);

					dailyRecharge.setTotalAmount(dailyAmount);

                    dailyRecharge.setProviderId(x.getId());

					dailyRecharge.setTotalCommission(totalCommission);

                    dailyRecharge.setWalletRechargeAmount(dailyWalletRecharge);

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

                    dailyRecharge.setTotalAmount(dailyAmount);

					dailyRecharge.setClosingBalance(closingBalance);

                    dailyRecharge.setTotalCommission(totalCommission);

					dailyRechargeRepository.persist(dailyRecharge);

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

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

                    dailyRecharge.setClosingBalance(closingBalance);

					previousDayClosing = dailyRecharge.getClosingBalance();

                    dailyRechargeRepository.persist(dailyRecharge);

				}

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

				date = date.plusDays(1);

                    previousDayClosing = dailyRecharge.getClosingBalance();

			}

                }

			rechargeProviderRepository.persist(x);

                date = date.plusDays(1);

		});

            }

		LOGGER.info("finished generating daily recharge");

            rechargeProviderRepository.persist(x);

	}

        });

        LOGGER.info("finished generating daily recharge");

	public void reconcileRecharge() throws Exception {

    }

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

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

    public void reconcileRecharge() throws Exception {

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

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

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

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

		nonSuccessRechargeStatuses.remove(RechargeStatus.SUCCESS);

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

		nonSuccessRechargeStatuses.remove(RechargeStatus.FAILED);

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

		RechargeCredential thinkWalnutDigitalRechargeEnquiryCredential = new RechargeCredential();

        nonSuccessRechargeStatuses.remove(RechargeStatus.SUCCESS);

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUrl(thinkWalnutDigitalRechargeEnquiryUrl);

        nonSuccessRechargeStatuses.remove(RechargeStatus.FAILED);

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUserName(thinkWalnutDigitalRechargeUserName);

        RechargeCredential thinkWalnutDigitalRechargeEnquiryCredential = new RechargeCredential();

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargePassword(thinkWalnutDigitalRechargePassword);

        thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUrl(thinkWalnutDigitalRechargeEnquiryUrl);

		thinkWalnutDigitalRechargeEnquiryCredential.setRechargeAuthKey(thinkWalnutDigitalRechargeAuthKey);

        thinkWalnutDigitalRechargeEnquiryCredential.setRechargeUserName(thinkWalnutDigitalRechargeUserName);

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

        thinkWalnutDigitalRechargeEnquiryCredential.setRechargePassword(thinkWalnutDigitalRechargePassword);

		List<RechargeTransaction> rechargeTransactions = rechargeTransactionRepository

        thinkWalnutDigitalRechargeEnquiryCredential.setRechargeAuthKey(thinkWalnutDigitalRechargeAuthKey);

				.selectAllBetweenTimestamp(nonSuccessRechargeStatuses, fromDate, toDate);

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

		for (RechargeTransaction rechargeTransaction : rechargeTransactions) {

        List<RechargeTransaction> rechargeTransactions = rechargeTransactionRepository

			try {

                .selectAllBetweenTimestamp(nonSuccessRechargeStatuses, fromDate, toDate);

				int providerId = rechargeTransaction.getProviderId();

        for (RechargeTransaction rechargeTransaction : rechargeTransactions) {

				if (providerId == 1) {

            try {

					oxigenRechargeProviderService.doCheckStatusRequest(oxigenRechargeEnquiryUrl, oxigenRechargeAuthKey,

                int providerId = rechargeTransaction.getProviderId();

							rechargeTransaction);

                if (providerId == 1) {

				} else if (providerId == 2) {

                    oxigenRechargeProviderService.doCheckStatusRequest(oxigenRechargeEnquiryUrl, oxigenRechargeAuthKey,

					thinkWalnutDigitalRechargeProviderService

                            rechargeTransaction);

							.doCheckStatusRequest(thinkWalnutDigitalRechargeEnquiryCredential, rechargeTransaction);

                } else if (providerId == 2) {

				}

                    thinkWalnutDigitalRechargeProviderService

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

                            .doCheckStatusRequest(thinkWalnutDigitalRechargeEnquiryCredential, rechargeTransaction);

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

                }

					requestRechargeStatusChanged.put(rechargeTransaction.getRequestId(),

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

							rechargeTransaction.getStatus());

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

				}

                    requestRechargeStatusChanged.put(rechargeTransaction.getRequestId(),

			} catch (Exception e) {

                            rechargeTransaction.getStatus());

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

                }

			}

            } catch (Exception e) {

		}

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

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

            }

	}

        }

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

	public void processActivation() throws Exception {

    }

		schemeService.processActivation();

	}

    public void processActivation() throws Exception {

        schemeService.processActivation();

	// TemporaryMethod

    }

	public void migrateInvoice() {

		List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));

    // TemporaryMethod

		Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();

    public void migrateInvoice() {

		partnerOrdersMap = fofoOrders.stream()

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));

				.collect(Collectors.groupingBy(FofoOrder::getFofoId, Collectors.toList()));

        Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();

		for (List<FofoOrder> orderList : partnerOrdersMap.values()) {

        partnerOrdersMap = fofoOrders.stream()

			int sequence = 0;

                .collect(Collectors.groupingBy(FofoOrder::getFofoId, Collectors.toList()));

			String prefix = "";

        for (List<FofoOrder> orderList : partnerOrdersMap.values()) {

			List<FofoOrder> sortedList = orderList.stream().sorted((x1, x2) -> x1.getId() - x2.getId())

            int sequence = 0;

					.collect(Collectors.toList());

            String prefix = "";

			for (FofoOrder order : sortedList) {

            List<FofoOrder> sortedList = orderList.stream().sorted((x1, x2) -> x1.getId() - x2.getId())

                    .collect(Collectors.toList());

				LOGGER.info("Order Id is {}, partner Id is {}", order.getId(), order.getFofoId());

            for (FofoOrder order : sortedList) {

				if (!order.getInvoiceNumber().contains("SEC")) {

					sequence = Integer.parseInt(order.getInvoiceNumber().split("/")[1]);

                LOGGER.info("Order Id is {}, partner Id is {}", order.getId(), order.getFofoId());

					prefix = order.getInvoiceNumber().split("/")[0];

                if (!order.getInvoiceNumber().contains("SEC")) {

				} else {

                    sequence = Integer.parseInt(order.getInvoiceNumber().split("/")[1]);

					sequence += 1;

                    prefix = order.getInvoiceNumber().split("/")[0];

					String invoiceNumber = prefix + "/" + sequence;

                } else {

					order.setInvoiceNumber(invoiceNumber);

                    sequence += 1;

					fofoOrderRepository.persist(order);

                    String invoiceNumber = prefix + "/" + sequence;

				}

                    order.setInvoiceNumber(invoiceNumber);

			}

                    fofoOrderRepository.persist(order);

                }

		}

            }

	}

        }

	@Autowired

    }

	private ReporticoCacheTableRepository reporticoCacheTableRepository;

    @Autowired

	public void processScheme(int offset, boolean dryRun) throws Exception {

    private ReporticoCacheTableRepository reporticoCacheTableRepository;

		LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);

		LocalDateTime endDate = startDate.plusDays(30);

    public void processScheme(int offset, boolean dryRun) throws Exception {

		processScheme(startDate, endDate, dryRun);

        LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);

	}

        LocalDateTime endDate = startDate.plusDays(30);

        processScheme(startDate, endDate, dryRun);

	public void processSchemeOut(List<String> invoiceNumbers) throws Exception {

    }

		for (String invoiceNumber : invoiceNumbers) {

			System.out.println("Invoice Number - " + invoiceNumber);

    public void processSchemeOut(List<String> invoiceNumbers) throws Exception {

			FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

        for (String invoiceNumber : invoiceNumbers) {

			orderService.reverseScheme(fofoOrder);

            System.out.println("Invoice Number - " + invoiceNumber);

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

            FofoOrder fofoOrder = fofoOrderRepository.selectByInvoiceNumber(invoiceNumber);

		}

            orderService.reverseScheme(fofoOrder);

	}

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

        }

	public void processSchemeIn(List<String> invoiceNumbers) throws Exception {

    }

		for (String invoiceNumber : invoiceNumbers) {

			System.out.println("Invoice Number - " + invoiceNumber);

    public void processSchemeIn(List<String> invoiceNumbers) throws Exception {

			Purchase purchase = purchaseRepository.selectByPurchaseReference(invoiceNumber);

        for (String invoiceNumber : invoiceNumbers) {

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

            System.out.println("Invoice Number - " + invoiceNumber);

		}

            Purchase purchase = purchaseRepository.selectByPurchaseReference(invoiceNumber);

	}

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

        }

	public void processScheme(int offset, int durationDays, boolean dryRun) throws Exception {

    }

		LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);

		LocalDateTime endDate = startDate.plusDays(durationDays);

    public void processScheme(int offset, int durationDays, boolean dryRun) throws Exception {

		processScheme(startDate, endDate, dryRun);

        LocalDateTime startDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT).minusDays(offset);

	}

        LocalDateTime endDate = startDate.plusDays(durationDays);

        processScheme(startDate, endDate, dryRun);

	public void processScheme(boolean dryRun) throws Exception {

    }

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

		processScheme(fromDate, LocalDateTime.now(), dryRun);

    public void processScheme(boolean dryRun) throws Exception {

	}

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

        processScheme(fromDate, LocalDateTime.now(), dryRun);

	public void processScheme(LocalDateTime startDate, LocalDateTime endDate, boolean dryRun) throws Exception {

    }

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

		System.out.println(

    public void processScheme(LocalDateTime startDate, LocalDateTime endDate, boolean dryRun) throws Exception {

				"InventoryId\tSerialNumber\tItem Id\tScheme Id\tScheme Name\tScheme Type\tAmount Type\tDP\tTaxable\tScheme Amount\tAmount Paid");

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

		try {

        System.out.println(

			List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);

                "InventoryId\tSerialNumber\tItem Id\tScheme Id\tScheme Name\tScheme Type\tAmount Type\tDP\tTaxable\tScheme Amount\tAmount Paid");

			for (Purchase purchase : purchases) {

        try {

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

            List<Purchase> purchases = purchaseRepository.selectAllBetweenPurchaseDate(startDate, endDate);

			}

            for (Purchase purchase : purchases) {

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

			List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);

            }

			for (FofoOrder fofoOrder : fofoOrders) {

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

            List<FofoOrder> fofoOrders = fofoOrderRepository.selectBetweenSaleDate(startDate, endDate);

			}

            for (FofoOrder fofoOrder : fofoOrders) {

		} catch (Exception e) {

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

			e.printStackTrace();

            }

			throw e;

        } catch (Exception e) {

		}

            e.printStackTrace();

		List<UserWalletHistory> uwhs = userWalletHistoryRepository.selectAllByDateType(LocalDate.now().atStartOfDay(),

            throw e;

				endDate, Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));

        }

		System.out.println("Amount\tReference\tReferenceType\tTimestamp\tDescription");

        List<UserWalletHistory> uwhs = userWalletHistoryRepository.selectAllByDateType(LocalDate.now().atStartOfDay(),

		for (UserWalletHistory uwh : uwhs) {

                endDate, Arrays.asList(WalletReferenceType.SCHEME_IN, WalletReferenceType.SCHEME_OUT));

			System.out.println(String.format("%d\t%d\t%s\t%s\t%s", uwh.getAmount(), uwh.getReference(),

        System.out.println("Amount\tReference\tReferenceType\tTimestamp\tDescription");

					uwh.getReferenceType(), uwh.getTimestamp().toString(), uwh.getDescription()));

        for (UserWalletHistory uwh : uwhs) {

		}

            System.out.println(String.format("%d\t%d\t%s\t%s\t%s", uwh.getAmount(), uwh.getReference(),

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

                    uwh.getReferenceType(), uwh.getTimestamp().toString(), uwh.getDescription()));

		if (dryRun) {

        }

			throw new Exception();

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

		}

        if (dryRun) {

	}

            throw new Exception();

        }

	public void processRechargeCashback() throws Throwable {

    }

		LocalDateTime cashbackTime = LocalDateTime.now();

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

    public void processRechargeCashback() throws Throwable {

		List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository

        LocalDateTime cashbackTime = LocalDateTime.now();

				.getPendingCashBackRehargeTransactions();

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

		Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(

        List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository

				Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));

                .getPendingCashBackRehargeTransactions();

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

        Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(

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

                Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));

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

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

			if (Math.round(amount) > 0) {

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

				walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK,

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

						"Recharge Cashback", Math.round(amount), LocalDateTime.now());

            if (Math.round(amount) > 0) {

			}

                walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK,

		}

                        "Recharge Cashback", Math.round(amount), LocalDateTime.now());

		for (RechargeTransaction rt : pendingTransactions) {

            }

			rt.setCashbackTimestamp(cashbackTime);

        }

			rt.setCashbackReference(referenceId);

        for (RechargeTransaction rt : pendingTransactions) {

			rechargeTransactionRepository.persist(rt);

            rt.setCashbackTimestamp(cashbackTime);

		}

            rt.setCashbackReference(referenceId);

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

            rechargeTransactionRepository.persist(rt);

	}

        }

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

	public void rollOutUpgardedMarginsNextMonth() throws Exception {

    }

		LocalDate startOfPreviousMonth = LocalDate.now().with(ChronoField.DAY_OF_MONTH, 1).minusMonths(1);

    public void rollOutUpgardedMarginsNextMonth() throws Exception {

		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();

        LocalDate startOfPreviousMonth = LocalDate.now().with(ChronoField.DAY_OF_MONTH, 1).minusMonths(1);

		for (FofoStore store : stores) {

			int fofoId = store.getId();

        List<FofoStore> stores = fofoStoreRepository.selectActiveStores();

        for (FofoStore store : stores) {

			PartnerType startOfPreviousMonthPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId,

            int fofoId = store.getId();

					startOfPreviousMonth);

			PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnMonth(fofoId,

            PartnerType startOfPreviousMonthPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId,

					YearMonth.from(startOfPreviousMonth.atStartOfDay()));

                    startOfPreviousMonth);

			if (!startOfPreviousMonthPartnerType.nextPartnerTypes().contains(todayPartnerType)) {

            PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnMonth(fofoId,

				continue;

                    YearMonth.from(startOfPreviousMonth.atStartOfDay()));

			}

            if (!startOfPreviousMonthPartnerType.nextPartnerTypes().contains(todayPartnerType)) {

			if (!startOfPreviousMonthPartnerType.equals(todayPartnerType)) {

                continue;

				LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),

            }

						startOfPreviousMonthPartnerType, todayPartnerType);

            if (!startOfPreviousMonthPartnerType.equals(todayPartnerType)) {

				List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,

                LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),

						startOfPreviousMonth.atStartOfDay(), startOfPreviousMonth.plusMonths(1).atStartOfDay(), 0, 0);

                        startOfPreviousMonthPartnerType, todayPartnerType);

				for (FofoOrder fofoOrder : fofoOrders) {

                List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,

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

                        startOfPreviousMonth.atStartOfDay(), startOfPreviousMonth.plusMonths(1).atStartOfDay(), 0, 0);

				}

                for (FofoOrder fofoOrder : fofoOrders) {

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

			}

                }

		}

	}

            }

        }

	public void rollOutUpgardedMargins() throws Exception {

    }

		LocalDate today = LocalDate.now();

		LocalDate yesterday = today.minusDays(1);

    public void rollOutUpgardedMargins() throws Exception {

		int upgradedCount = 0;

        LocalDate today = LocalDate.now();

		List<FofoStore> stores = fofoStoreRepository.selectActiveStores();

        LocalDate yesterday = today.minusDays(1);

		StringBuilder sb = new StringBuilder();

        int upgradedCount = 0;

		for (FofoStore store : stores) {

        List<FofoStore> stores = fofoStoreRepository.selectActiveStores();

			int fofoId = store.getId();

        StringBuilder sb = new StringBuilder();

        for (FofoStore store : stores) {

			PartnerType yesterdayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, yesterday);

            int fofoId = store.getId();

			PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, today);

			if (!yesterdayPartnerType.nextPartnerTypes().contains(todayPartnerType)) {

            PartnerType yesterdayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, yesterday);

				continue;

            PartnerType todayPartnerType = partnerTypeChangeService.getTypeOnDate(fofoId, today);

			}

            if (!yesterdayPartnerType.nextPartnerTypes().contains(todayPartnerType)) {

			if (!yesterdayPartnerType.equals(todayPartnerType)) {

                continue;

				upgradedCount++;

            }

				sb.append(String.format("Partner Type has been changed for code %s from %s to %s", store.getCode(),

            if (!yesterdayPartnerType.equals(todayPartnerType)) {

						yesterdayPartnerType.toString(), todayPartnerType.toString()));

                upgradedCount++;

				sb.append("<br>");

                sb.append(String.format("Partner Type has been changed for code %s from %s to %s", store.getCode(),

				LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),

                        yesterdayPartnerType.toString(), todayPartnerType.toString()));

						yesterdayPartnerType, todayPartnerType);

                sb.append("<br>");

				List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,

                LOGGER.info("Partner Type has been changed for code {} from {} to {}", store.getCode(),

						yesterday.withDayOfMonth(1).atStartOfDay(), yesterday.atStartOfDay(), 0, 0);

                        yesterdayPartnerType, todayPartnerType);

				for (FofoOrder fofoOrder : fofoOrders) {

                List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId,

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

                        yesterday.withDayOfMonth(1).atStartOfDay(), yesterday.atStartOfDay(), 0, 0);

				}

                for (FofoOrder fofoOrder : fofoOrders) {

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

			}

                }

		}

		if (upgradedCount > 0) {

            }

			sendMailHtmlFormat(

        }

					new String[] { "amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com",

        if (upgradedCount > 0) {

							"neeraj.gupta@smartdukaan.com" },

            sendMailHtmlFormat(

					sb.toString(), null, "Few Partners Category have been Upgraded");

                    new String[]{"amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com",

		} else {

                            "neeraj.gupta@smartdukaan.com"},

			sendMailHtmlFormat(

                    sb.toString(), null, "Few Partners Category have been Upgraded");

					new String[] { "amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com",

        } else {

							"neeraj.gupta@smartdukaan.com" },

            sendMailHtmlFormat(

					sb.toString(), null, "No partners Category have been upgraded today");

                    new String[]{"amit.gupta@smartdukaan.com", "tarun.verma@smartdukaan.com",

		}

                            "neeraj.gupta@smartdukaan.com"},

	}

                    sb.toString(), null, "No partners Category have been upgraded today");

        }

	@Autowired

    }

	private PartnerStatsService partnerStatsService;

    @Autowired

	// Temporary Method

    private PartnerStatsService partnerStatsService;

	public void evaluateExcessSchemeOut() throws Exception {

		Map<Integer, String> userNameMap = retailerService.getAllFofoRetailerIdNameMap();

    // Temporary Method

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

    public void evaluateExcessSchemeOut() throws Exception {

        Map<Integer, String> userNameMap = retailerService.getAllFofoRetailerIdNameMap();

		List<List<?>> rows = new ArrayList<>();

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

		List<String> headers = Arrays.asList("Scheme", "Item", "Partner", "Amount", "Credited On", "Invoice Number",

				"Sale On", "Scheme Start", "Scheme End", "Active On", "Expired On");

        List<List<?>> rows = new ArrayList<>();

		schemeRepository.selectAll().stream().forEach(x -> {

        List<String> headers = Arrays.asList("Scheme", "Item", "Partner", "Amount", "Credited On", "Invoice Number",

			if (x.getType().equals(SchemeType.OUT)) {

                "Sale On", "Scheme Start", "Scheme End", "Active On", "Expired On");

				List<SchemeInOut> sioList = schemeInOutRepository

        schemeRepository.selectAll().stream().forEach(x -> {

						.selectBySchemeIds(new HashSet<>(Arrays.asList(x.getId())));

            if (x.getType().equals(SchemeType.OUT)) {

				if (x.getActiveTimestamp() != null) {

                List<SchemeInOut> sioList = schemeInOutRepository

					LocalDateTime endDateTime = x.getEndDateTime();

                        .selectBySchemeIds(new HashSet<>(Arrays.asList(x.getId())));

					if (x.getExpireTimestamp() != null && x.getExpireTimestamp().isBefore(x.getEndDateTime())) {

                if (x.getActiveTimestamp() != null) {

						endDateTime = x.getExpireTimestamp();

                    LocalDateTime endDateTime = x.getEndDateTime();

					}

                    if (x.getExpireTimestamp() != null && x.getExpireTimestamp().isBefore(x.getEndDateTime())) {

					for (SchemeInOut sio : sioList) {

                        endDateTime = x.getExpireTimestamp();

						InventoryItem inventoryItem = null;

                    }

						inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());

                    for (SchemeInOut sio : sioList) {

						FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndSerialNumber(

                        InventoryItem inventoryItem = null;

								inventoryItem.getFofoId(), inventoryItem.getSerialNumber(), null, null, 0, 1).get(0);

                        inventoryItem = inventoryItemRepository.selectById(sio.getInventoryItemId());

						Optional<ScanRecord> record = scanRecordRepository

                        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndSerialNumber(

								.selectByInventoryItemId(sio.getInventoryItemId()).stream()

                                inventoryItem.getFofoId(), inventoryItem.getSerialNumber(), null, null, 0, 1).get(0);

								.filter(y -> y.getType().equals(ScanType.SALE)).findFirst();

                        Optional<ScanRecord> record = scanRecordRepository

						if (record.isPresent()) {

                                .selectByInventoryItemId(sio.getInventoryItemId()).stream()

							int fofoId = record.get().getFofoId();

                                .filter(y -> y.getType().equals(ScanType.SALE)).findFirst();

							if (record.get().getCreateTimestamp().isAfter(endDateTime)

                        if (record.isPresent()) {

									|| record.get().getCreateTimestamp().isBefore(x.getStartDateTime())) {

                            int fofoId = record.get().getFofoId();

								if (!userAmountMap.containsKey(fofoId)) {

                            if (record.get().getCreateTimestamp().isAfter(endDateTime)

									userAmountMap.put(fofoId, 0f);

                                    || record.get().getCreateTimestamp().isBefore(x.getStartDateTime())) {

								}

                                if (!userAmountMap.containsKey(fofoId)) {

								userAmountMap.put(fofoId, sio.getAmount() + userAmountMap.get(fofoId));

                                    userAmountMap.put(fofoId, 0f);

								try {

                                }

									rows.add(Arrays.asList(x.getDescription(),

                                userAmountMap.put(fofoId, sio.getAmount() + userAmountMap.get(fofoId));

											itemRepository.selectById(inventoryItem.getItemId()).getItemDescription(),

                                try {

											userNameMap.get(fofoId), sio.getAmount(),

                                    rows.add(Arrays.asList(x.getDescription(),

											FormattingUtils.formatDate(sio.getCreateTimestamp()),

                                            itemRepository.selectById(inventoryItem.getItemId()).getItemDescription(),

											fofoOrder.getInvoiceNumber(),

                                            userNameMap.get(fofoId), sio.getAmount(),

											FormattingUtils.formatDate(record.get().getCreateTimestamp()),

                                            FormattingUtils.formatDate(sio.getCreateTimestamp()),

											FormattingUtils.formatDate(x.getStartDateTime()),

                                            fofoOrder.getInvoiceNumber(),

											FormattingUtils.formatDate(x.getEndDateTime()),

                                            FormattingUtils.formatDate(record.get().getCreateTimestamp()),

											FormattingUtils.formatDate(x.getActiveTimestamp()),

                                            FormattingUtils.formatDate(x.getStartDateTime()),

											FormattingUtils.formatDate(x.getExpireTimestamp())));

                                            FormattingUtils.formatDate(x.getEndDateTime()),

								} catch (Exception e) {

                                            FormattingUtils.formatDate(x.getActiveTimestamp()),

									e.printStackTrace();

                                            FormattingUtils.formatDate(x.getExpireTimestamp())));

								}

                                } catch (Exception e) {

							}

                                    e.printStackTrace();

						}

                                }

					}

                            }

				}

                        }

			}

                    }

		});

                }

		userAmountMap.entrySet().stream()

            }

				.forEach(x -> LOGGER.info("{} to be deducted from {}({}) for wrongly disbursed due to technical error.",

        });

						x.getValue(), userNameMap.get(x.getKey())));

        userAmountMap.entrySet().stream()

                .forEach(x -> LOGGER.info("{} to be deducted from {}({}) for wrongly disbursed due to technical error.",

		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);

                        x.getValue(), userNameMap.get(x.getKey())));

		Utils.sendMailWithAttachment(googleMailSender,

				new String[] { "amit.gupta@shop2020.in", "adeel.yazdani@smartdukaan.com" }, null,

        ByteArrayOutputStream baos = FileUtil.getCSVByteStream(headers, rows);

				"Partner Excess Amount", "PFA", "ListofSchemes.csv", new ByteArrayResource(baos.toByteArray()));

        Utils.sendMailWithAttachment(googleMailSender,

                new String[]{"amit.gupta@shop2020.in", "adeel.yazdani@smartdukaan.com"}, null,

	}

                "Partner Excess Amount", "PFA", "ListofSchemes.csv", new ByteArrayResource(baos.toByteArray()));

	public void fetchParnterStats() throws Exception {

    }

		Map<Integer, PartnerDetailModel> partnerStats = partnerStatsService.getAllPartnerStats();

		ObjectOutputStream oos = null;

    public void fetchParnterStats() throws Exception {

		FileOutputStream fout = null;

        Map<Integer, PartnerDetailModel> partnerStats = partnerStatsService.getAllPartnerStats();

		try {

        ObjectOutputStream oos = null;

			fout = new FileOutputStream("/tmp/partnerStat.tmp", false);

        FileOutputStream fout = null;

			oos = new ObjectOutputStream(fout);

        try {

			oos.writeObject(partnerStats);

            fout = new FileOutputStream("/tmp/partnerStat.tmp", false);

            oos = new ObjectOutputStream(fout);

		} catch (Exception ex) {

            oos.writeObject(partnerStats);

			ex.printStackTrace();

		} finally {

        } catch (Exception ex) {

			if (oos != null) {

            ex.printStackTrace();

				oos.close();

        } finally {

			}

            if (oos != null) {

		}

                oos.close();

		ReporticoCacheTable rct = reporticoCacheTableRepository.selectByTableName("partnerStat");

            }

		if (rct == null) {

        }

			rct = new ReporticoCacheTable();

        ReporticoCacheTable rct = reporticoCacheTableRepository.selectByTableName("partnerStat");

			rct.setTableName("partnerStat");

        if (rct == null) {

			rct.setLastCreatedTimestamp(LocalDateTime.now());

            rct = new ReporticoCacheTable();

			reporticoCacheTableRepository.persist(rct);

            rct.setTableName("partnerStat");

		} else {

            rct.setLastCreatedTimestamp(LocalDateTime.now());

			rct.setLastCreatedTimestamp(LocalDateTime.now());

            reporticoCacheTableRepository.persist(rct);

		}

        } else {

	}

            rct.setLastCreatedTimestamp(LocalDateTime.now());

        }

	public void processPriceDrop() throws Exception {

    }

		List<PriceDrop> priceDrops = priceDropRepository.selectAllByDatesBetween(LocalDateTime.now(),

				LocalDateTime.now().minusYears(1));

    public void processPriceDrop() throws Exception {

		for (PriceDrop priceDrop : priceDrops) {

        List<PriceDrop> priceDrops = priceDropRepository.selectAllByDatesBetween(LocalDateTime.now(),

			if (priceDrop.getDropAmount() > 0) {

                LocalDateTime.now().minusYears(1));

				priceDropService.processPriceDrop(priceDrop.getId(), true);

        for (PriceDrop priceDrop : priceDrops) {

			}

            if (priceDrop.getDropAmount() > 0) {

		}

                priceDropService.processPriceDrop(priceDrop.getId(), true);

	}

            }

        }

	@Autowired

    }

	CreditNoteService creditNoteService;

    @Autowired

	public void sendCreditNote(YearMonth yearMonth) throws Exception {

    CreditNoteService creditNoteService;

		creditNoteService.issueMonthlyMarginsCN(yearMonth);

	}

    public void sendCreditNote(YearMonth yearMonth) throws Exception {

        creditNoteService.issueMonthlyMarginsCN(yearMonth);

	private class SaleRoles {

    }

		private List<String> l1;

    private class SaleRoles {

		private List<String> l2;

        private List<String> l1;

		public SaleRoles() {

        private List<String> l2;

			l1 = new ArrayList<>();

			l2 = new ArrayList<>();

        public SaleRoles() {

		}

            l1 = new ArrayList<>();

            l2 = new ArrayList<>();

		public List<String> getL1() {

        }

			return l1;

		}

        public List<String> getL1() {

            return l1;

		public List<String> getL2() {

        }

			return l2;

		}

        public List<String> getL2() {

            return l2;

	}

        }