Subversion Repositories SmartDukaan

Rev

Rev 35524 | Blame | Compare with Previous | Last modification | View Log | RSS feed 

package com.smartdukaan.cron;

import com.smartdukaan.cron.migrations.RunOnceTasks;
import com.smartdukaan.cron.scheduled.*;
import com.smartdukaan.cron.scheduled.ambreports.AbmReportSender;
import com.smartdukaan.cron.scheduled.b2b.Listing;
import com.smartdukaan.cron.scheduled.leadsync.LeadSyncRunner;
import com.smartdukaan.cron.scheduled.ordertracking.OrderTrackingService;
import com.smartdukaan.cron.scheduled.purchaseorder.POScheduler;
import com.smartdukaan.cron.scheduled.razorpay.FetchPartnersDisbursementTask;
import com.spice.profitmandi.common.model.InvoicePdfModel;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.util.InvoiceFormatter;
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 com.spice.profitmandi.service.order.OrderService;
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.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Primary;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.ui.velocity.VelocityEngineFactoryBean;

import java.io.FileInputStream;
import java.io.IOException;
import java.time.LocalDate;
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
@EnableAspectJAutoProxy
@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;

    @Autowired
    private Listing listing;

    @Autowired
    OrderTrackingService orderTrackingService;

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

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertyConfigurer1() {
        LOGGER.info("Called Configuration");
        PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();

        // Load shared properties from dao first, then app-specific (app-specific can override)
        Resource sharedResource = new ClassPathResource("/shared-dev.properties");
        Resource appResource = new ClassPathResource("/META-INF/env.properties");

        propertySourcesPlaceholderConfigurer.setLocations(sharedResource, appResource);
        propertySourcesPlaceholderConfigurer.setIgnoreResourceNotFound(true);

        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");

        mailSender.setJavaMailProperties(javaMailProperties);
        return mailSender;
    }

    @Bean
    public JavaMailSender googleMailSender() {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost("smtp.gmail.com");
        mailSender.setPort(465);
        mailSender.setUsername("sdtech@smartdukaan.com");
        mailSender.setPassword("gpdschroalhhirox"); // App Password

        Properties props = mailSender.getJavaMailProperties();
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.ssl.enable", "true");
        props.put("mail.smtp.ssl.trust", "smtp.gmail.com");
        props.put("mail.smtp.socketFactory.port", "465");
        props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        props.put("mail.debug", "true");

        return mailSender;
    }

    @Autowired
    private RunOnceTasks runOnceTasks;

    @Autowired
    private ScheduledTasks scheduledTasks;

    @Autowired
    private ScheduledTasksTest scheduledTasksTest;

    @Autowired
    private FetchPartnersDisbursementTask fetchPartnersDisbursementTask;

    @Autowired
    private Reconciliation reconciliation;

    @Autowired
    private Migrations migrations;

    @Autowired
    CaptchaService captchaService;

    @Autowired
    POScheduler poScheduler;


    @Override
    public void run(ApplicationArguments args) throws Exception {
        //scheduledTasks.test();
        //System.exit();
        LOGGER.info("Called run method");
        if (args.containsOption("removePartialBillingForTransaction")) {
            if (args.containsOption("trId")) {
                int transactionId = Integer.parseInt(args.getOptionValues("trId").get(0));
                scheduledTasks.removePartialBillingForTransaction(transactionId);
            }
            System.exit(0);
        }
        if (args.containsOption("createOpeningStockPartyWise")) {
            scheduledTasks.createOpeningStockPartyWise();
            System.exit(0);
        }
        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("migrateOriginalInventoryItemId")) {
            int batchSize = 10_000;
            if (args.containsOption("batchSize")) {
                try {
                    batchSize = Integer.parseInt(args.getOptionValues("batchSize").get(0));
                } catch (Exception e) {
                    LOGGER.warn("Invalid batchSize provided, defaulting to {}", batchSize);
                }
            }
            LOGGER.info("Starting migration for warehouse.inventoryItem.originalInventoryItemId with batchSize={}", batchSize);
            migrations.migrateWarehouseOriginalInventoryItemId(batchSize);
            LOGGER.info("Migration completed.");
            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("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")) {
            try {
                scheduledTasks.checkfocusedModelInPartnerStock();
            } finally {
                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")) {
            orderTrackingService.markDelhiveryOrderDelivered();
            System.exit(0);
        }

        if (args.containsOption("markBlueDartOrderDelivered")) {
            System.out.println("Marking BlueDart Order Delivered...");
            orderTrackingService.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("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("findAllLiveDemoBrandItemsByBillingDate")) {
            scheduledTasks.findAllLiveDemoBrandItemsByBillingDate();
            System.exit(0);
        }
        if (args.containsOption("findTodayPocoBillingItems")) {
            scheduledTasks.findTodayPocoBillingItems();
            System.exit(0);
        }

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

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

        if (args.containsOption("checkItelImeiActivationNew")) {
            scheduledTasks.checkItelImeiActivationNew(LocalDate.now(), 15);
            System.exit(0);
        }
        if (args.containsOption("once")) {

            if (args.containsOption("autoClosePurchaseOrders")) {
                poScheduler.autoClosePurchaseOrders();
            }
            if (args.containsOption("cancelOnceAssist")) {
                if (args.containsOption("invoiceNumber")) {
                    String oneAssistInvoiceNumber = args.getOptionValues("invoiceNumber").get(0);
                    runOnceTasks.cancelOnceAssist(oneAssistInvoiceNumber);
                }


            }
            if (args.containsOption("cancelOnceAssist")) {
                if (args.containsOption("MemberShipNumber")) {
                    String applicationNo = args.getOptionValues("applicationNo").get(0);
                    String membershipId = args.getOptionValues("membershipId").get(0);
                    runOnceTasks.cancelOnceAssistByMemberShipNumber(applicationNo, membershipId);
                }

            }
            if (args.containsOption("changeFulfillmentWarehouse")) {
                if (args.containsOption("orderId") && args.containsOption("whId")) {
                    List<Integer> orderIds = Arrays.stream(args.getOptionValues("orderId").get(0).split(","))
                            .map(String::trim)
                            .map(Integer::parseInt)
                            .collect(Collectors.toList());

                    int warehouseId = Integer.parseInt(args.getOptionValues("whId").get(0));
                    for (Integer orderId : orderIds) {
                        runOnceTasks.changeFulfillmentWarehouse(orderId, warehouseId);
                    }
                }
                System.exit(0);
            }
            if (args.containsOption("1")) {
                if (args.containsOption("test")) {
                    //scheduledTasks.sendPartnerInvestmentDetails(args.getOptionValues("email"));
                    System.out.println("Calling test method");
                    scheduledTasks.test();
                    System.exit(0);

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

                    if (args.containsOption("approveVendorCatalogPricing")) {
                        scheduledTasks.approveVendorCatalogPricing();
                        System.exit(0);
                    }
                } else if (args.containsOption("test1")) {
                    scheduledTasks.test1();
                } else if (args.containsOption("scheduleTaskTest1")) {

                    scheduledTasksTest.test();
                }else if (args.containsOption("generateBiReport")) {
                    scheduledTasksTest.generateBiReport();
                }else if (args.containsOption("abmSendertest")) {
                    runOnceTasks.setAbmReportSender();
                }
                else if (args.containsOption("fetchPartnerDisburseMentTask")) {
                    if(args.containsOption("fetchDisbursements")){
                        fetchPartnersDisbursementTask.fetchDisbursementsTest();
                    }
                    else if(args.containsOption("creditAmountTest")){
                        fetchPartnersDisbursementTask.creditAmountTest();
                    }
                    else if(args.containsOption("createContactsAndFundsForFranchiseeTest")){
                        fetchPartnersDisbursementTask.createContactsAndFundsForFranchiseeTest();
                    }
                    else if(args.containsOption("rabbitTransactionProducertest")){
                        fetchPartnersDisbursementTask.rabbitTransactionProducertest();
                    }
                    else if(args.containsOption("sendingDisbursementMail")){
                        fetchPartnersDisbursementTask.sendingDisbursementMail();
                    }
                    else {
                        fetchPartnersDisbursementTask.test();
                    }
                }
                else if (args.containsOption("testNew1")) {
                    List<String> loanIdArgs = args.getOptionValues("loanIds");  // ["34833,36536,37151"]
                    List<Integer> loanIds = new ArrayList<>();

                    if (loanIdArgs != null && !loanIdArgs.isEmpty()) {
                        String csv = loanIdArgs.get(0);
                        loanIds = Arrays.stream(csv.split(","))
                                .map(String::trim)
                                .map(Integer::parseInt)
                                .collect(Collectors.toList());
                    }
                    scheduledTasksTest.findLoanTransactionMapingAccordingLoan(loanIds);
                } else if (args.containsOption("testNew2")) {
                    if (args.containsOption("createLoan")) {
                        // Extract each parameter
                        int transactionId = 0;
                        double invoiceAmount = 0.0;
                        String invoiceNumber = "";

                        if (args.containsOption("transactionId")) {
                            transactionId = Integer.parseInt(args.getOptionValues("transactionId").get(0));
                        }

                        if (args.containsOption("invoiceAmount")) {
                            invoiceAmount = Double.parseDouble(args.getOptionValues("invoiceAmount").get(0));
                        }

                        if (args.containsOption("invoiceNumber")) {
                            invoiceNumber = args.getOptionValues("invoiceNumber").get(0);
                        }

                        // Call your method
                        scheduledTasksTest.createLoanForBillingByTransactionIdAndInvoiceNumber(transactionId, invoiceAmount, invoiceNumber);
                    }

                } 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("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(Arrays.asList(175140172, 175140189));
            }
            if (args.containsOption("pushRbmTargets")) {
                scheduledTasks.persistRbmTodayTargets();
            }
            if (args.containsOption("rollOutUpgardedMarginsNextMonth")) {
                System.out.println("In rollOutUpgardedMarginsNextMonth");
                scheduledTasks.rollOutUpgardedMarginsNextMonth(Arrays.asList(175140172, 175140189, 175138897));
            }
            if (args.containsOption("checkCancellationMargin")) {
                scheduledTasks.checkCancellationMargin();
            }
            if (args.containsOption("reviewUncontactablePartner")) {
                scheduledTasks.reviewUncontactablePartner();
            }
            if (args.containsOption("reviewNonSdBuyingBrand")) {
                scheduledTasks.reviewNonSdBuyingBrand();
            }
            if (args.containsOption("sendWelcomeEmail")) {
                onBoardingRelatedSchelduleTask.sendWelcomeEmail();
            }

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

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

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


            if (args.containsOption("pushDataToSolr")) {
                listing.pushDataToSolr();
            }

            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("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("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();
            }

            if (args.containsOption("todayBidPO")) {
                runOnceTasks.processBids(ProfitMandiConstants.BID_CRON_ENUM.TODAY);
            }

            if (args.containsOption("yesterdayBidPO")) {
                runOnceTasks.processBids(ProfitMandiConstants.BID_CRON_ENUM.YESTERDAY);
            }

            if (args.containsOption("biddingConsolidatedMessage")) {
                runOnceTasks.consolidatedBiddingMessage();
            }

            if (args.containsOption("sendMailWhatsAppAfterLoanDueDate")) {
                scheduledTasks.sendMailWhatsAppAfterLoanDueDate();
            }

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

            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("sendTenOrMoreOrderStockReport")) {
            scheduledTasks.send10OrMoreOlderStockReport();
            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")) {
                orderTrackingService.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")) {
                System.out.println("Calling sendCreditNote");
                YearMonth yearMonth = YearMonth.now().minusMonths(1);
                /*
                 * 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);
        }
    }
}