Subversion Repositories SmartDukaan

package com.smartdukaan.cron;

import com.smartdukaan.cron.migrations.RunOnceTasks;
import com.smartdukaan.cron.scheduled.*;
import com.smartdukaan.cron.scheduled.leadsync.LeadSyncRunner;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.fofo.FofoOrderItemRepository;
import com.spice.profitmandi.dao.util.ContentPojoPopulator;
import com.spice.profitmandi.service.integrations.samsung.upgradeoffer.UpgradeOfferService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.exception.VelocityException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Primary;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.io.ClassPathResource;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.security.core.parameters.P;
import org.springframework.ui.velocity.VelocityEngineFactoryBean;

import java.io.FileInputStream;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.stream.Collectors;

@SpringBootApplication
//@EnableCaching
@EnableScheduling
@ComponentScan("com.smartdukaan.cron.*, com.spice.profitmandi.common.*")
public class Application implements ApplicationRunner {

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

        @Autowired
        LeadSyncRunner leadSyncRunner;

        @Autowired
        StandAlone standAlone;

        @Autowired
        UpgradeOfferService upgradeOfferService;

        @Autowired
        private TicketRelatedScheduledTask ticketRelatedScheduledTask;

        @Autowired
        private OnBoardingRelatedSchelduleTask onBoardingRelatedSchelduleTask;

        @Autowired
        private InvestmentRelatedTasks investmentRelatedTasks;

        @Autowired
        private CsService csService;

        @Autowired
        private FofoOrderItemRepository fofoOrderItemRepository;

        @Autowired
        private ContentPojoPopulator contentPojoPopulator;

        public static void main(String[] args) throws Throwable {
                try {
                        new SpringApplicationBuilder(Application.class).web(WebApplicationType.NONE).run(args);
                } catch (Throwable t) {
                        t.printStackTrace();
                }
        }

        @Bean
        public static PropertySourcesPlaceholderConfigurer propertyConfigurer1() {
                LOGGER.info("Called Configuration");
                PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();
                propertySourcesPlaceholderConfigurer.setLocation(new ClassPathResource("/META-INF/env.properties"));
                return propertySourcesPlaceholderConfigurer;
        }

        @Bean(name = "veloctyEngine")
        public VelocityEngine velocityEngine() throws VelocityException, IOException {
                VelocityEngineFactoryBean factory = new VelocityEngineFactoryBean();

                Properties velocityProperties = new Properties();
                velocityProperties.put("resource.loader", "class");
                velocityProperties.put("class.resource.loader.class",
                                "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
                velocityProperties.put("file.resource.loader.cache", true);
                velocityProperties.put("file.resource.loader.unicode", true);
                velocityProperties.put("input.encoding", "UTF-8");
                velocityProperties.put("output.encoding", "UTF-8");
                velocityProperties.put("response.encoding", "UTF-8");
                velocityProperties.put("overrideLogging", true);

                // velocityProperties.put("file.resource.loader.path", ".");

                factory.setVelocityProperties(velocityProperties);

                return factory.createVelocityEngine();

        }

        @Bean(name = "mailSender")
        @Primary
        public JavaMailSender sendGridMailSender() {
                JavaMailSenderImpl mailSender = new JavaMailSenderImpl();

                // Using gmail
                mailSender.setHost("smtp.sendgrid.net");
                mailSender.setPort(587);
                mailSender.setUsername("apikey");
                mailSender.setPassword("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");

                Properties javaMailProperties = new Properties();
                javaMailProperties.put("mail.smtp.starttls.enable", "false");
                javaMailProperties.put("mail.smtp.auth", "true");
                javaMailProperties.put("mail.transport.protocol", "smtp");
                // javaMailProperties.put("mail.debug", "true");// Prints out everything on
                // screen

                mailSender.setJavaMailProperties(javaMailProperties);
                return mailSender;
        }

        @Bean
        public JavaMailSender googleMailSender() {
                JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
                // Using gmail
                mailSender.setHost("smtp.gmail.com");
                mailSender.setPort(587);
                mailSender.setUsername("build@shop2020.in");
                mailSender.setPassword("cafe@nes");

                Properties javaMailProperties = new Properties();
                javaMailProperties.put("mail.smtp.starttls.enable", "true");
                javaMailProperties.put("mail.smtp.auth", "true");
                javaMailProperties.put("mail.transport.protocol", "smtp");
                javaMailProperties.put("mail.debug", "true");// Prints out everything on screen
                mailSender.setJavaMailProperties(javaMailProperties);
                return mailSender;
        }

        @Autowired
        private RunOnceTasks runOnceTasks;

        @Autowired
        private ScheduledTasks scheduledTasks;

        @Autowired
        private Reconciliation reconciliation;

        @Autowired
        CaptchaService captchaService;

        @Override
        public void run(ApplicationArguments args) throws Exception {
                LOGGER.info("Called run method");
                if (args.containsOption("tc")) {
                        System.out.println("Toffee service called");
                        scheduledTasks.toffeeRollback();
                        System.exit(0);
                }
                if (args.containsOption("bag")) {
                        System.out.println("Bag service called");
                        runOnceTasks.testBag();
                        System.exit(0);
                }

                if (args.containsOption("rw")) {
                        System.out.println("Reverse wallet");
                        scheduledTasks.reverseWallet();
                        System.exit(0);
                }
                if (args.containsOption("sendIndentTertiary")) {
                        System.out.println("sendIndentTertiary");
                        scheduledTasks.sendIndentTertiary();
                        System.exit(0);
                }
                if (args.containsOption("checkPartnerActiveStore")) {
                        System.out.println("checkPartnerActiveStore");
                        scheduledTasks.checkPartnerActiveStore();
                        System.exit(0);
                }

                if (args.containsOption("selectFinServiceFollowUpDateByCurrDate")) {
                        System.out.println("selectfinServiceFollowUpDateByCurrDate");

                        scheduledTasks.selectFinServiceFollowUpDateByCurrDate(LocalDate.now());
                        System.exit(0);
                }

                if (args.containsOption("addHdfcPayment")) {
                        runOnceTasks.addPayment();
                        System.exit(0);
                }
                if (args.containsOption("processSchemeOut")) {
                        System.out.println("Process schemeOut");
                        int orderId = Integer.parseInt(args.getOptionValues("orderid").get(0));
                        int fofoId = Integer.parseInt(args.getOptionValues("fofoid").get(0));
                        runOnceTasks.processSchemeOut(fofoId, orderId);
                        System.exit(0);
                }
                if (args.containsOption("at")) {
                        System.out.println("Toffee service called");
                        ticketRelatedScheduledTask.alertforTicket();
                        System.exit(0);
                }
                if (args.containsOption("et")) {
                        ticketRelatedScheduledTask.escalateTicket();
                        ;
                        System.exit(0);
                }
                if (args.containsOption("sr")) {
                        List<String> schemeIds = args.getOptionValues("schemeId");
                        System.out.println(schemeIds);
                        scheduledTasks.schemeRollback(schemeIds);
                        System.exit(0);
                }
                if (args.containsOption("processActivation")) {
                        scheduledTasks.processActivation();
                        System.exit(0);
                }
                if (args.containsOption("sendAttendanceMorningAlert")) {
                        scheduledTasks.sendAttendanceMorningAlert();
                        System.exit(0);
                }
                if (args.containsOption("sendAttendanceEveningAlert")) {
                        scheduledTasks.sendAttendanceEveningAlert();
                        System.exit(0);
                }

                if (args.containsOption("checkRazorPayPaymentStatus")) {
                        scheduledTasks.checkRazorPayPaymentStatus();
                        System.exit(0);
                }
                if (args.containsOption("grouping")) {
                        scheduledTasks.grouping();
                        System.exit(0);
                }
                if (args.containsOption("fixWallet")) {
                        runOnceTasks.fixWallet();
                        System.exit(0);
                }
                if (args.containsOption("reconcileExpiredFixedSchemes")) {
                        reconciliation.reconcileExpiredFixedSchemes();
                        System.exit(0);
                }
                if (args.containsOption("dailyReconciliation")) {
                        if (args.containsOption("date")) {
                                LocalDate date = LocalDate.parse(args.getOptionValues("date").get(0));
                                reconciliation.dailyReconciliation(date);
                        } else {
                                reconciliation.dailyReconciliation(LocalDate.now().minusDays(1));
                        }
                        System.exit(0);
                }
                /*
                 * if (args.containsOption("test")) { schemeService.processSchemeIn(9243,
                 * 175138102); throw new Exception(); }
                 */
                if (args.containsOption("fixSchemePayouts")) {

                        runOnceTasks.fixSchemePayouts();
                        System.exit(0);
                }
                if (args.containsOption("sendNotification")) {
                        scheduledTasks.sendNotification();
                        System.exit(0);
                }

                if (args.containsOption("ticketClosed")) {
                        scheduledTasks.ticketClosed();
                        System.exit(0);
                }

                if (args.containsOption("getVendorWarehouses")) {
                        int warehouseId = Integer.parseInt(args.getOptionValues("warehouseId").get(0));
                        scheduledTasks.getVendorWarehouses(warehouseId);
                        System.exit(0);
                }

                if (args.containsOption("checkfocusedModelInPartnerStock")) {
                        scheduledTasks.checkfocusedModelInPartnerStock();
                        System.exit(0);
                }

                if (args.containsOption("checkImeiActivation")) {
                        scheduledTasks.checkImeiActivation();
                        System.exit(0);
                }

                if (args.containsOption("checkTecnoImeiActivation")) {

                        LocalDate dateTechno = LocalDate.now();

                        int days = 25;
                        if (args.containsOption("days")) {
                                days = Integer.parseInt(args.getOptionValues("days").get(0));
                        }
                        scheduledTasks.checkTecnoImeiActivation(dateTechno, days);
                        System.exit(0);
                }

                if (args.containsOption("checkItelImeiActivation")) {
                        LocalDate dateItel = LocalDate.now();
                        int days = 25;
                        if (args.containsOption("days")) {
                                days = Integer.parseInt(args.getOptionValues("days").get(0));
                        }
                        scheduledTasks.checkItelImeiActivation(dateItel, days);
                        System.exit(0);
                }

                if (args.containsOption("partnerProblemAlert")) {
                        scheduledTasks.partnerProblemAlert();
                        System.exit(0);
                }
                if (args.containsOption("notify")) {
                        if (args.containsOption("fofoId")) {
                                int fofoId = Integer.parseInt(args.getOptionValues("fofoId").get(0));
                                scheduledTasks.sendDailySalesNotificationToPartner(fofoId);
                        }
                        System.exit(0);
                }
                if (args.containsOption("findMismatchesInIndent")) {
                        runOnceTasks.findMismatchesInIndent();
                        System.exit(0);
                }

                if (args.containsOption("onboardingEventDelays")) {
                        onBoardingRelatedSchelduleTask.onboardingEventDelays();
                        System.exit(0);
                }

                if (args.containsOption("onBoardingCompleteEventEmail")) {
                        onBoardingRelatedSchelduleTask.onBoardingCompleteEventEmail();
                        System.exit(0);
                }

                if (args.containsOption("onBoardingDocumentsPending")) {
                        onBoardingRelatedSchelduleTask.onBoardingDocumentsPending();
                        System.exit(0);
                }
                if (args.containsOption("onBoardingMigration")) {
                        onBoardingRelatedSchelduleTask.onBoardingMigration();
                        System.exit(0);
                }

                if (args.containsOption("advancePaymentPendingAlert")) {
                        onBoardingRelatedSchelduleTask.advancePaymentPendingAlert();
                        System.exit(0);
                }

                if (args.containsOption("fullPaymentPendingAlert")) {
                        onBoardingRelatedSchelduleTask.fullPaymentPendingAlert();
                        System.exit(0);
                }

                if (args.containsOption("advancePaymentPendinglegalAlert")) {
                        onBoardingRelatedSchelduleTask.advancePaymentPendinglegalAlert();
                        System.exit(0);
                }

                if (args.containsOption("markDelhiveryOrderDelivered")) {
                        scheduledTasks.markDelhiveryOrderDelivered();
                        System.exit(0);
                }

                if (args.containsOption("markBlueDartOrderDelivered")) {
                        scheduledTasks.markBlueDartOrderDelivered();
                        System.exit(0);
                }

                if (args.containsOption("mergingdata")) {
                        onBoardingRelatedSchelduleTask.mergingdata();
                        System.exit(0);
                }
                if (args.containsOption("brandingAlert")) {
                        onBoardingRelatedSchelduleTask.brandingAlert();
                        System.exit(0);
                }

                if (args.containsOption("storeTimelinePromoterPending")) {
                        onBoardingRelatedSchelduleTask.storeTimelinePromoterPending();
                        System.exit(0);
                }

                if (args.containsOption("ppl")) {
                        runOnceTasks.printPendingLeads();
                        System.exit(0);
                }

                if (args.containsOption("sweets")) {
                        runOnceTasks.getSweet();
                }
                if (args.containsOption("notifyAll")) {
                        scheduledTasks.sendDailySalesNotificationToPartner(null);
                        System.exit(0);
                }

                if (args.containsOption("monthlyTargetForInternalTeam")) {
                        scheduledTasks.monthlyTargetForInternalTeam();
                        System.exit(0);
                }

                if (args.containsOption("monthlyTargetForPartner")) {
                        scheduledTasks.monthlyTargetForPartner();
                        System.exit(0);
                }

                if (args.containsOption("hygineAlertForPartner")) {
                        scheduledTasks.hygineAlertForPartner();
                        System.exit(0);
                }

                if (args.containsOption("pushDataToSolr")) {
                        scheduledTasks.pushDataToSolr();
                        System.exit(0);
                }

                if (args.containsOption("getBestSeller")) {
                        scheduledTasks.getBestSeller();
                        System.exit(0);
                }

                if (args.containsOption("getPriceDrop")) {
                        scheduledTasks.getPriceDrop();
                        System.exit(0);
                }

                if (args.containsOption("getNewLaunches")) {
                        scheduledTasks.getNewLaunches();
                        System.exit(0);
                }

                if (args.containsOption("getSpecialSupport")) {
                        scheduledTasks.getSpecialSupport();
                        System.exit(0);
                }

                if (args.containsOption("getUpgradeOffer")) {
                        scheduledTasks.getUpgradeOffer();
                        System.exit(0);
                }

                if (args.containsOption("hygineAlertForInternalTeam")) {
                        scheduledTasks.hygineAlertForInternalTeam();
                        System.exit(0);
                }

                if (args.containsOption("OutSchemeReco")) {
                        scheduledTasks.dryRunOutSchemeReco();
                        // runOnceTasks.migrateChallansToInvoices();
                        // reconciliation.dailyReconciliation();
                        System.exit(0);
                }
                if (args.containsOption("dryRunSchemeReco")) {
                        scheduledTasks.dryRunSchemeReco();
                        // runOnceTasks.migrateChallansToInvoices();
                        // reconciliation.dailyReconciliation();
                        System.exit(0);
                }
                if (args.containsOption("OutReco1")) {
                        scheduledTasks.dryRunSchemeOutReco1();
                        System.exit(0);
                }
                if (args.containsOption("once")) {
                        if (args.containsOption("cancelOnceAssist")) {
                                if (args.containsOption("invoiceNumber")) {
                                        String oneAssistInvoiceNumber = args.getOptionValues("invoiceNumber").get(0);
                                        runOnceTasks.cancelOnceAssist(oneAssistInvoiceNumber);
                                }

                        }
                        if (args.containsOption("1")) {
                                if (args.containsOption("test")) {
                    //scheduledTasks.sendPartnerInvestmentDetails(args.getOptionValues("email"));
                    scheduledTasks.test();
                                } else {
                                        System.out.println("Called sendPartnerInvestmentDetails");
                                        scheduledTasks.sendPartnerInvestmentDetails();
                                }
                                System.exit(0);
                        }
                        if (args.containsOption("2")) {
                                if (args.containsOption("test")) {
                                        String[] emails = new String[args.getOptionValues("email").size()];
                                        scheduledTasks.sendAgeingReport(args.getOptionValues("email").toArray(emails));
                                } else {
                                        scheduledTasks.sendAgeingReport();
                                }
                                System.exit(0);
                        }
                        if (args.containsOption("3")) {
                                if (args.getOptionNames().contains("offset")) {
                                        int offset = Integer.parseInt(args.getOptionValues("offset").get(0));
                                        if (args.getOptionNames().contains("days")) {
                                                int durationDays = Integer.parseInt(args.getOptionValues("days").get(0));
                                                scheduledTasks.processScheme(offset, durationDays, args.containsOption("dryRun"));
                                        } else {
                                                scheduledTasks.processScheme(offset, args.containsOption("dryRun"));
                                        }
                                } else if (args.containsOption("catalogid")) {
                                        // scheduledTasks.processSchemeForModel(args.getOptionValues("catalogid").get(0));
                                } else {
                                        scheduledTasks.processScheme(args.containsOption("dryRun"));
                                }
                                System.exit(0);
                        }
                        if (args.containsOption("4")) {
                                scheduledTasks.evaluateExcessSchemeOut();
                        }
                        if (args.containsOption("5")) {
                                int offset = Integer.parseInt(args.getOptionValues("offset").get(0));
                                scheduledTasks.processScheme(offset, args.containsOption("dryRun"));
                                System.exit(0);
                        }
                        if (args.containsOption("cancelOrder")) {
                                List<String> invoiceNumbers = args.getOptionValues("invoiceNumber");
                                runOnceTasks.cancelOrder(invoiceNumbers);
                        }
                        if (args.containsOption("migratePurchase")) {
                                runOnceTasks.migratePurchase();
                        }
                        if (args.containsOption("migratepd")) {
                                scheduledTasks.moveImeisToPriceDropImeis();
                        }
                        if (args.containsOption("walletmismatch")) {
                                scheduledTasks.walletmismatch();
                        }
                        if (args.containsOption("schemewalletmismatch")) {
                                scheduledTasks.schemewalletmismatch();
                        }
                        if (args.containsOption("gst")) {
                                scheduledTasks.gst();
                        }
                        if (args.containsOption("mailDashboardScreenshots")) {
                                runOnceTasks.mailDashboardScreenshots();
                        }
                        if (args.containsOption("notifyLead")) {
                                scheduledTasks.notifyLead();
                                scheduledTasks.notifyVisits();
                        }
                        if (args.containsOption("fixgrn")) {
                                runOnceTasks.fixGrn();
                        }
                        if (args.containsOption("pbfix")) {
                                runOnceTasks.pbfix();
                        }
                        if (args.containsOption("mongom")) {
                                runOnceTasks.mongom();
                        }
                        if (args.containsOption("processPd")) {
                                int priceDropId = Integer.parseInt(args.getOptionValues("processPd").get(0));
                                runOnceTasks.processPd(priceDropId);
                        }
                        if (args.containsOption("samsung")) {
                                if (args.containsOption("ym")) {
                                        int ym = Integer.parseInt(args.getOptionValues("ym").get(0));
                                        runOnceTasks.fetchImeiActivation(ym);
                                }
                                runOnceTasks.fetchImeiActivation(0);
                        }
                        if (args.containsOption("fixdupimeigrn")) {
                                runOnceTasks.fixDupGrns();
                        }
                        if (args.containsOption("cancel")) {
                                runOnceTasks.cancelDn(args.getOptionValues("dn").get(0));
                        }
                        if (args.containsOption("fixScheme")) {
                                runOnceTasks.fixScheme();
                        }
                        if (args.containsOption("syncLeads")) {
                                leadSyncRunner.syncLeads();
                        }
                        if (args.containsOption("testCs")) {
                                int category = Integer.parseInt(args.getOptionValues("category").get(0));
                                EscalationType escalationType = EscalationType.valueOf(args.getOptionValues("escalation").get(0));
                                int fofoId = Integer.parseInt(args.getOptionValues("fofoid").get(0));
                                csService.getAuthUserId(category, escalationType, fofoId);
                        }
                        if (args.containsOption("duporder")) {
                                runOnceTasks.removeDuplicateOrders();
                        }
                        if (args.containsOption("createDummyInvoices")) {
                                runOnceTasks.createDummyInvoices();
                        }

                        if (args.containsOption("createGeofence")) {
                                runOnceTasks.createGeofence();
                        }
                        if (args.containsOption("getAllGeofences")) {
                                runOnceTasks.getAllGeofences();
                        }
                        if (args.containsOption("payMonthlyInvestment")) {
                                investmentRelatedTasks.payMonthlyInvestment();
                        }
                        if (args.containsOption("evaluateActualInvestmentPayout")) {
                                investmentRelatedTasks.evaluateActualInvestmentPayout();
                        }
                        if (args.containsOption("deleteGeofences")) {
                                List<String> geofenceIds = args.getOptionValues("geofenceId");
                                runOnceTasks.deleteGeofences(geofenceIds);
                        }
                        if (args.containsOption("createOffers")) {
                                if (args.containsOption("fileName")) {
                                        String fileName = args.getOptionValues("fileName").get(0);
                                        FileInputStream stream = new FileInputStream(fileName);
                                        runOnceTasks.createOffers(stream);
                                }
                        }
                        if (args.containsOption("schemeout")) {
                                if (args.containsOption("invoices")) {
                                        String invoicesString = args.getOptionValues("invoices").get(0);
                                        List<String> invoices = Arrays.asList(invoicesString.split(","));
                                        scheduledTasks.processSchemeOut(invoices);
                                }
                        }
                        if (args.containsOption("schemein")) {
                                if (args.containsOption("invoices")) {
                                        String invoicesString = args.getOptionValues("invoices").get(0);
                                        List<String> invoices = Arrays.asList(invoicesString.split(","));
                                        scheduledTasks.processSchemeIn(invoices);
                                }
                        }

                        if (args.containsOption("fixScans")) {
                                runOnceTasks.fixScans();
                        }
                        if (args.containsOption("fixPrebookingOrderGrn")) {
                                runOnceTasks.genericCreateCurrentInventorySnapshot();
                        }
                        if (args.containsOption("fixOurSerialized")) {
                                if (args.containsOption("orderIds")) {
                                        String orderIdsString = args.getOptionValues("orderIds").get(0);
                                        List<Integer> orderIds = Arrays.asList(orderIdsString.split(",")).stream()
                                                        .map(x -> Integer.parseInt(x)).collect(Collectors.toList());
                                        // runOnceTasks.fixOurSerialized(orderIds);
                                }
                        }

                        if (args.containsOption("reverseMaa")) {
                                runOnceTasks.reverseMaa();
                        }

                        if (args.containsOption("fixOffer")) {
                                runOnceTasks.fixOffer();
                        }

                        if (args.containsOption("opporeno")) {
                                runOnceTasks.opporeno();
                        }

                        if (args.containsOption("fixorders")) {
                                runOnceTasks.fixOrders();
                        }
                        if (args.containsOption("fixreservations")) {
                                runOnceTasks.fixReservations();
                        }
                        if (args.containsOption("addinvestment")) {
                                runOnceTasks.addInvestment();
                        }
                        if (args.containsOption("brandregion")) {
                                runOnceTasks.brandRegion();
                        }
                        if (args.containsOption("rollOutUpgardedMargins")) {
                                scheduledTasks.rollOutUpgardedMargins();
                        }
                        if (args.containsOption("rollOutUpgardedMarginsNextMonth")) {
                                scheduledTasks.rollOutUpgardedMarginsNextMonth();
                        }
                        if (args.containsOption("checkCancellationMargin")) {
                                scheduledTasks.checkCancellationMargin();
                        }
                        if (args.containsOption("reviewUncontactablePartner")) {
                                scheduledTasks.reviewUncontactablePartner();
                        }
                        if (args.containsOption("sendWelcomeEmail")) {
                                onBoardingRelatedSchelduleTask.sendWelcomeEmail();
                        }

                        if (args.containsOption("partnerOnboardingLegalMigration")) {
                                onBoardingRelatedSchelduleTask.partnerOnboardingLegalMigration();
                        }

                        if (args.containsOption("addKycLegalMigration")) {
                                onBoardingRelatedSchelduleTask.addKycLegalMigration();
                        }

                        if (args.containsOption("testGstPro")) {
                                System.out.println("TestGstProc called");
                                try {
                                        runOnceTasks.updateIrnsToInvoices();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }

                        if (args.containsOption("reverseSchemeCancelInvoice")) {
                                if (args.containsOption("invoice")) {
                                        String invoice = args.getOptionValues("invoice").get(0);
                                        runOnceTasks.reverseSchemes(invoice);
                                }
                        }

                        if (args.containsOption("reverseInvalidActivation")) {
                                if (args.containsOption("inventoryids")) {
                                        String inventoryItemIdsString = args.getOptionValues("inventoryids").get(0);
                                        List<Integer> inventoryItemIds = new ArrayList<>();
                                        for (String inventoryItemIdString : inventoryItemIdsString.split(",")) {
                                                int inventoryItemId = Integer.parseInt(inventoryItemIdString.trim());
                                                inventoryItemIds.add(inventoryItemId);
                                        }
                                        runOnceTasks.reverseInvalidActivation(inventoryItemIds);
                                }
                        }

                        if (args.containsOption("partnerWiseCreditAccount")) {
                                scheduledTasks.partnerWiseCreditAccount();
                        }
                        if (args.containsOption("runme")) {
                                runOnceTasks.runMe();

                        }
                        if (args.containsOption("" + "")) {
                                upgradeOfferService.authenticateUser();

                        }
                        if (args.containsOption("mandiiUser")) {
                                runOnceTasks.mandiiUser(args.getOptionValues("firstName").get(0),
                                                args.getOptionValues("lastName").get(0), args.getOptionValues("pan").get(0),
                                                args.getOptionValues("dob").get(0), args.getOptionValues("aadhaar").get(0),
                                                args.getOptionValues("gender").get(0), args.getOptionValues("father").get(0));

                        }

                        if (args.containsOption("mandiiUsers")) {
                                if (args.containsOption("pan")) {
                                        runOnceTasks.mandiiUsers(args.getOptionValues("pan").get(0));
                                } else {
                                        runOnceTasks.mandiiUsers();
                                }

                        }

                        if (args.containsOption("checkOppoImeiStatus")) {
                                try {
                                        standAlone.checkOppoImeiStatus();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }

                        /*
                         * if (args.containsOption("checkRealmeImeiStatus")) { try {
                         * standAlone.checkRealmeImeiStatus(); } catch (Exception e) {
                         * e.printStackTrace(); } }
                         */

                        if (args.containsOption("amazonPurchase")) {
                                try {
                                        runOnceTasks.amazonPurchase();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }

                        if (args.containsOption("getCaptchaCode")) {
                                try {
                                        captchaService.getCaptchaCode("/home/amit/Desktop/generatingCodes.jpg");
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }

                        if (args.containsOption("testIrnLive")) {
                                try {
                                        runOnceTasks.testIrnLive(args.getOptionValues("invoiceNumber").get(0));
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }

                        if (args.containsOption("createoffercriteria")) {
                                try {
                                        runOnceTasks.createOfferCriteria();
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }

                        if (args.containsOption("fix-price-drops")) {
                                runOnceTasks.fixPriceDrop();

                        }

                        if (args.containsOption("processSchemeByIds")) {
                                List<String> schemeIds = Arrays.asList(args.getOptionValues("ids").get(0).split(","));
                                List<Integer> schemeIdsInt = schemeIds.stream().map(x -> Integer.parseInt(x))
                                                .collect(Collectors.toList());
                                runOnceTasks.processSchemeByIds(schemeIdsInt);

                        }

                        if (args.containsOption("updateSaholicCISTable")) {
                                runOnceTasks.updateSaholicCISTable();

                        }

                        if (args.containsOption("mapbag")) {
                                runOnceTasks.mapBag();
                        }

                        System.exit(0);
                }

                if (args.containsOption("calculateInterestAccured")) {

                        scheduledTasks.calculateInterestAccured();
                        System.exit(0);
                }

                if (args.containsOption("loanSettlement")) {

                        scheduledTasks.loanSettlement();
                        System.exit(0);
                }

                if (args.containsOption("dailyLoanAlert")) {

                        scheduledTasks.dailyLoanAlert();
                        System.exit(0);
                }

                if (args.containsOption("updatePartnerLimit")) {
                        scheduledTasks.updatePartnerLimit();
                        System.exit(0);
                }

                if (args.containsOption("notifyDefaultLoans")) {
                        scheduledTasks.notifyDefaultLoans();
                        System.exit(0);
                }

                if (args.containsOption("fixinsurance")) {
                        runOnceTasks.addMissingWalletDebitsForInsurance();
                        System.exit(0);
                }

                if (args.containsOption("processActivatedImeisForSchemes")) {
                        scheduledTasks.processActivatedImeisForSchemes();
                        System.exit(0);
                }

                if (args.containsOption("notifyLoanDueDateCross")) {
                        scheduledTasks.notifyLoanDueDateCross();
                        System.exit(0);
                }

                if (args.containsOption("alertForDueDate")) {
                        scheduledTasks.alertForDueDate();
                        System.exit(0);
                }

                if (args.containsOption("userMobileNumberOptIn")) {
                        scheduledTasks.userMobileNumberOptIn();
                        System.exit(0);
                }

                if (args.containsOption("fetchParnterStats")) {
                        scheduledTasks.fetchParnterStats();
                        System.exit(0);
                }

                if (args.containsOption("authUserMobileNumberOptIn")) {
                        scheduledTasks.authUserMobileNumberOptIn();
                        System.exit(0);
                }
                if (args.containsOption("morning")) {
                        if (args.containsOption("0")) {
                                scheduledTasks.sendPartnerInvestmentDetails();
                        }
                        if (args.containsOption("1")) {
                                scheduledTasks.sendIndentTertiary();
                        }
                        // 0
                        if (args.containsOption("2")) {
                                scheduledTasks.calculateInterestAccured();
                        }
                        System.out.println("scheduledTasks.calculateInterestAccured()");
                        // 0
                        if (args.containsOption("3")) {
                                scheduledTasks.markDelhiveryOrderDelivered();
                        }
                        System.out.println("scheduledTasks.markDelhiveryOrderDelivered()");
                        // 1
                        if (args.containsOption("4")) {
                                scheduledTasks.processActivatedImeisForSchemes();
                        }
                        System.out.println("scheduledTasks.processActivatedImeisForSchemes()");
                        // 2
                        if (args.containsOption("5")) {
                                scheduledTasks.processActivation();
                        }
                        System.out.println("scheduledTasks.processActivation()");
                        // 4
                        if (args.containsOption("6")) {
                                scheduledTasks.processPriceDrop();
                        }
                        System.out.println("scheduledTasks.processPriceDrop()");
                        // 5
                        if (args.containsOption("7")) {
                                scheduledTasks.loanSettlement();
                        }
                        System.out.println("scheduledTasks.loanSettlement()");
                        // 8
                        if (args.containsOption("8")) {
                                scheduledTasks.reviewUncontactablePartner();
                        }
                        // 9
                        if (args.containsOption("9")) {
                                onBoardingRelatedSchelduleTask.storeTimelinePromoterPending();
                        }
                        // 9
                        if (args.containsOption("10")) {
                                onBoardingRelatedSchelduleTask.advancePaymentPendinglegalAlert();
                        }
                        // sendPartnerInvestment
                        if (args.containsOption("11")) {
                                scheduledTasks.sendPartnerInvestmentDetails();
                        }
                        if (args.containsOption("sendCreditNote")) {
                                LocalDateTime localDateTime = LocalDateTime.now().minusDays(10);
                                YearMonth yearMonth = YearMonth.from(localDateTime);
                                /*
                                 * if
                                 * (localDateTime.toLocalDate().equals(yearMonth.atEndOfMonth().getDayOfMonth())
                                 * && Arrays.asList(20,21,22,23).contains(localDateTime.getHour())) {
                                 * scheduledTasks.sendCreditNote(yearMonth); }
                                 */
                                scheduledTasks.sendCreditNote(yearMonth);
                        }
                        System.exit(0);
                }
        }
}