Subversion Repositories SmartDukaan

package com.smartdukaan.cron;

import com.smartdukaan.cron.migrations.RunOnceTasks;

import com.smartdukaan.cron.migrations.InternalGrnTask;

import com.smartdukaan.cron.migrations.MovementBillingTask;

import com.smartdukaan.cron.migrations.MovementPoTask;

import com.smartdukaan.cron.scheduled.*;

import com.smartdukaan.cron.scheduled.b2b.Listing;

import com.smartdukaan.cron.scheduled.beatmiss.BeatMissDetectorRunner;

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.smartdukaan.cron.scheduled.knowlarity.KnowlarityCallMonitorScheduler;

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

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

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.service.shopify.ShopifyProductSyncService;

import com.spice.profitmandi.dao.util.ContentPojoPopulator;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.integrations.icicilombard.IciciLombardService;

import com.spice.profitmandi.service.integrations.icicilombard.model.LastTransactionsResponseModel;

import com.spice.profitmandi.service.integrations.samsung.upgradeoffer.UpgradeOfferService;

import com.spice.profitmandi.service.mail.MailOutboxService;

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.Lazy;

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 com.spice.profitmandi.common.services.AuthenticatedIdentityMailSender;

import com.spice.profitmandi.common.services.MailRecipientFilter;

import com.spice.profitmandi.common.services.RecipientFilteringMailSender;

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.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

@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;

    @Autowired

    BatchScheduledTasks batchScheduledTasks;

    @Autowired

    private BeatMissDetectorRunner beatMissDetectorRunner;

    @Autowired

    private IciciLombardService iciciLombardService;

    public static void main(String[] args) throws Throwable {

        try {

            WebApplicationType webType = WebApplicationType.SERVLET;

            for (String arg : args) {

                if (arg.contains("spring.main.web-application-type=none")) {

                    webType = WebApplicationType.NONE;

                    break;

                }

            }

            new SpringApplicationBuilder(Application.class)

                    .web(webType)

                    .run(args);

        } catch (Throwable t) {

            t.printStackTrace();

        }

    }

    @Bean

    public static PropertySourcesPlaceholderConfigurer propertyConfigurer1() {

        LOGGER.info("Called Configuration");

        PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();

        String activeProfile;

        Properties properties = new Properties();

        try {

            properties.load(Application.class.getClassLoader().getResourceAsStream("META-INF/env.property"));

        } catch (IOException e) {

            LOGGER.error("Error reading env.property, defaulting to dev: " + e);

            properties.put("profile", "dev");

        }

        activeProfile = (String) properties.get("profile");

        Resource appResource;

        Resource sharedResource;

        if ("prod".equals(activeProfile)) {

            appResource = new ClassPathResource("/META-INF/prod.properties");

            sharedResource = new ClassPathResource("/shared-prod.properties");

        } else if ("staging".equals(activeProfile)) {

            appResource = new ClassPathResource("/META-INF/staging.properties");

            sharedResource = new ClassPathResource("/shared-staging.properties");

        } else {

            appResource = new ClassPathResource("/META-INF/dev.properties");

            sharedResource = new ClassPathResource("/shared-dev.properties");

        }

        LOGGER.info("Cron loading profile: " + activeProfile);

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

    }

    /**

     * The default sender. Authenticates as sdtech@smartdukaan.com and rewrites

     * every From to that identity — Workspace binds an authenticated session to

     * one address and rejects any other with

     * "535 Authorization failed: Authenticated user is not authorized to send mail".

     *

     * Also answers to "mailSender" so the many unqualified JavaMailSender

     * injections resolve here rather than needing to be touched.

     */

    @Bean(name = "googleMailSender")

    public JavaMailSender googleMailSender(@Lazy MailRecipientFilter mailRecipientFilter) {

        AuthenticatedIdentityMailSender mailSender = new AuthenticatedIdentityMailSender();

        mailSender.setRecipientFilter(mailRecipientFilter);

        mailSender.setHost("smtp.gmail.com");

        mailSender.setPort(465);

        mailSender.setUsername("sdtech@smartdukaan.com");

        mailSender.setPassword("wbdwyqrcgosrkwdn"); // 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.smtp.connectiontimeout", "30000");

        props.put("mail.smtp.timeout", "120000");

        props.put("mail.smtp.writetimeout", "120000");

        return mailSender;

    }

    /**

     * The default sender.

     *

     * Verified working 2026-08-31: MAIL FROM:<noreply@smartdukaan.com> returns 250

     * over IPv4. It does not authenticate -- Workspace authorises it by allowlisted

     * source IP -- so it may legitimately send as noreply@.

     *

     * googleMailSender is the alternative and its credentials are valid -- verified

     * 2026-08-31, AUTH OK on both 465 and 587. Use it by qualifier where a message

     * must come from the authenticated identity rather than noreply@.

     *

     * SMTP on this host works over IPv4 only, and that is not specific to the relay:

     * over IPv6 the relay answers "550 5.7.1 Invalid credentials for relay" and

     * smtp.gmail.com rejects a valid app password with "535 5.7.8 Username and

     * Password not accepted". The JVM prefers IPv4, which is the only reason mail

     * leaves this box at all. Anything that prefers IPv6 will fail on both paths.

     */

    @Bean(name = {"gmailRelaySender", "mailSender"})

    @Primary

    public JavaMailSender getGmailRelaySender(@Lazy MailRecipientFilter mailRecipientFilter) {

        RecipientFilteringMailSender mailSender = new RecipientFilteringMailSender();

        mailSender.setRecipientFilter(mailRecipientFilter);

        mailSender.setHost("smtp-relay.gmail.com");

        mailSender.setPort(587);

        Properties props = mailSender.getJavaMailProperties();

        props.put("mail.smtp.starttls.enable", "true");

        props.put("mail.smtp.auth", "false");

        props.put("mail.smtp.localhost", "smartdukaan.com");

        props.put("mail.smtp.ssl.protocols", "TLSv1.2");

        props.put("mail.smtp.ssl.trust", "smtp-relay.gmail.com");

        props.put("mail.transport.protocol", "smtp");

        props.put("mail.smtp.connectiontimeout", "30000");

        props.put("mail.smtp.timeout", "120000");

        props.put("mail.smtp.writetimeout", "120000");

        return mailSender;

    }

    @Autowired

    private RunOnceTasks runOnceTasks;

    @Autowired

    private InternalGrnTask internalGrnTask;

    @Autowired

    private MovementBillingTask movementBillingTask;

    @Autowired

    private MovementPoTask movementPoTask;

    @Autowired

    private ScheduledTasks scheduledTasks;

    @Autowired

    private ScheduledTasksTest scheduledTasksTest;

    @Autowired

    private FetchPartnersDisbursementTask fetchPartnersDisbursementTask;

    @Autowired

    private Reconciliation reconciliation;

    @Autowired

    private WarehouseStockReconciliation warehouseStockReconciliation;

    @Autowired

    private PartnerIdentityIntegrityMonitor partnerIdentityIntegrityMonitor;

    @Autowired

    private Migrations migrations;

    @Autowired

    CaptchaService captchaService;

    @Autowired

    POScheduler poScheduler;

    @Autowired

    ShopifyProductSyncService shopifyProductSyncService;

    @Autowired

    KnowlarityCallMonitorScheduler knowlarityCallMonitorScheduler;

    @Autowired

    MailOutboxService mailOutboxService;

    @Autowired

    NotificationService notificationService;

    @Override

    public void run(ApplicationArguments args) throws Exception {

        //scheduledTasks.test();

        //System.exit();

        LOGGER.info("Called run method");

        // Knowlarity Call Monitor - Manual trigger (if 10 AM scheduled start was missed)

        // This just starts the monitor; scheduled healthCheck and stopMonitoring will still work

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

            LOGGER.info("Starting Knowlarity Call Monitor manually...");

            knowlarityCallMonitorScheduler.startMonitoring();

            LOGGER.info("Knowlarity Call Monitor started. Scheduled tasks will handle health checks and 10 PM stop.");

            // No sleep needed - Spring scheduler keeps app running and handles 10 PM stop

        }

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

            runOnceTasks.dailyTrackingReport();

        }

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

            runOnceTasks.poStockApprovalDailyDigest();

            System.exit(0);

        }

        // --rbmRankingForMonth [--month=YYYY-MM]

        // Read-only probe: prints the composite RBM ranking for the given month

        // (default: previous month) to log. No email, no DB writes.

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

            java.time.YearMonth month = java.time.YearMonth.now().minusMonths(1);

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

                try {

                    month = java.time.YearMonth.parse(args.getOptionValues("month").get(0));

                } catch (Exception e) {

                    LOGGER.error("Invalid --month value; expected YYYY-MM: {}", e.getMessage());

                    System.exit(1);

                }

            }

            runOnceTasks.printRbmRankingForMonth(month);

            System.exit(0);

        }

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

            LOGGER.info("Stopping Knowlarity Call Monitor...");

            knowlarityCallMonitorScheduler.stopMonitoring();

        }

        // Knowlarity - Request fresh snapshot manually (when status not updating)

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

            LOGGER.info("Requesting Knowlarity snapshot manually...");

            knowlarityCallMonitorScheduler.healthCheck();

            LOGGER.info("Knowlarity snapshot requested.");

            System.exit(0);

        }

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

            System.out.println("updatePjpAgendaInstances");

            scheduledTasks.updatePjpAgendaInstances();

            System.exit(0);

        }

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

            System.out.println("updatePartnerActivationTypeByMonthlySale");

            scheduledTasks.updatePartnerActivationTypeByMonthlySale();

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

            if (!args.containsOption("pos") || !args.containsOption("email") || !args.containsOption("provider")) {

                LOGGER.error("autoBillMovement needs --pos=PO1,PO2, --email=<operator> and --provider=<logistics"

                        + " provider id>; add --live to bill (default is a dry run)");

                System.exit(1);

            }

            List<String> poNumbers = new ArrayList<>();

            for (String value : args.getOptionValues("pos")) {

                for (String poNumber : value.split(",")) {

                    if (!poNumber.trim().isEmpty()) {

                        poNumbers.add(poNumber.trim());

                    }

                }

            }

            movementBillingTask.billMovements(poNumbers, args.getOptionValues("email").get(0),

                    Integer.parseInt(args.getOptionValues("provider").get(0)), args.containsOption("live"));

            System.exit(0);

        }

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

            if (!args.containsOption("file") || !args.containsOption("warehouse") || !args.containsOption("supplier")

                    || !args.containsOption("email")) {

                LOGGER.error("autoCreateMovementPO needs --file=<xlsx>, --warehouse=<destination>, --supplier=<internal"

                        + " supplier> and --email=<operator>; add --live to raise (default is a dry run), --bill"

                        + " --provider=<logistics provider id> to dry-run billing of the raised POs");

                System.exit(1);

            }

            boolean bill = args.containsOption("bill");

            if (bill && !args.containsOption("provider")) {

                LOGGER.error("autoCreateMovementPO --bill needs --provider=<logistics provider id>");

                System.exit(1);

            }

            try {

                movementPoTask.createMovementPo(args.getOptionValues("file").get(0),

                        Integer.parseInt(args.getOptionValues("warehouse").get(0)),

                        Integer.parseInt(args.getOptionValues("supplier").get(0)), args.getOptionValues("email").get(0),

                        args.containsOption("live"), bill,

                        bill ? Integer.parseInt(args.getOptionValues("provider").get(0)) : 0);

            } catch (Exception e) {

                LOGGER.error("autoCreateMovementPO FAILED - nothing raised: {}", e.getMessage(), e);

                System.exit(1);

            }

            System.exit(0);

        }

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

            if (!args.containsOption("invoices") || !args.containsOption("email")) {

                LOGGER.error("autoGrnInternal needs --invoices=A,B and --email=<operator>");

                System.exit(1);

            }

            List<String> invoiceNumbers = new ArrayList<>();

            for (String value : args.getOptionValues("invoices")) {

                for (String invoiceNumber : value.split(",")) {

                    if (!invoiceNumber.trim().isEmpty()) {

                        invoiceNumbers.add(invoiceNumber.trim());

                    }

                }

            }

            String operatorEmail = args.getOptionValues("email").get(0);

            boolean dryRun = args.containsOption("dryRun");

            internalGrnTask.grnInternalInvoices(invoiceNumbers, operatorEmail, dryRun);

            System.exit(0);

        }

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

            if (!args.containsOption("invoices")) {

                LOGGER.error("reverseGrnInternal needs --invoices=A,B");

                System.exit(1);

            }

            List<String> invoiceNumbers = new ArrayList<>();

            for (String value : args.getOptionValues("invoices")) {

                for (String invoiceNumber : value.split(",")) {

                    if (!invoiceNumber.trim().isEmpty()) {

                        invoiceNumbers.add(invoiceNumber.trim());

                    }

                }

            }

            internalGrnTask.reverseInternalInvoices(invoiceNumbers, args.containsOption("dryRun"));

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

            ticketRelatedScheduledTask.alertforTicket();

            System.exit(0);

        }

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

            ticketRelatedScheduledTask.escalateTicket();

            ;

            System.exit(0);

        }

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

            System.out.println("Fetching ICICI CD balance manually");

            try {

                LastTransactionsResponseModel response = iciciLombardService.getLastTwentyFiveTransactions(null);

                System.out.println("Response: " + response);

                if (response != null

                        && response.getTransactionsDetails() != null

                        && !response.getTransactionsDetails().isEmpty()) {

                    LastTransactionsResponseModel.TransactionDetail latest = response.getTransactionsDetails().get(0);

                    System.out.println("Current available balance = " + latest.getAvailableBalance()

                            + " (as of " + latest.getEffectiveDate() + " — status: " + latest.getStatus() + ")");

                    System.out.println("Last 25 transactions:");

                    response.getTransactionsDetails().forEach(t -> System.out.println("  " + t));

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

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

            warehouseStockReconciliation.reconcile();

            System.exit(0);

        }

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

            partnerIdentityIntegrityMonitor.monitor();

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

            System.out.println("Processing pending mails...");

            mailOutboxService.processPendingMails();

            System.exit(0);

        }

        // Dispatch any notification_schedule rows whose scheduled_timestamp <= now.

        // Same code path as the hourly cron in NotificationDispatchScheduler, but callable

        // on demand from dev / staging where the isProd gate normally blocks the cron.

        // Usage: --dispatchScheduledNotifications [--batch=200]

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

            int batch = 200;

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

                try { batch = Integer.parseInt(args.getOptionValues("batch").get(0)); }

                catch (Exception ignored) { }

            }

            System.out.println("Dispatching due scheduled notifications (batch=" + batch + ")...");

            int attempted = notificationService.dispatchDueScheduled(batch);

            System.out.println("Attempted: " + attempted + " row(s)");

            System.exit(0);

        }

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

            // Redirected to TicketRelatedScheduledTask which handles auto-close as part of escalateTicket

            ticketRelatedScheduledTask.escalateTicket();

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

        }

        // One tick's worth (50 imeis), not a full pass -- the backlog is cleared by the

        // scheduled 5-minute ticks. Useful for checking the endpoint by hand.

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

            scheduledTasks.checkCarlcareImeiActivation();

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

                    try {

                        scheduledTasks.test();

                    } catch (Throwable e) {

                        throw new RuntimeException(e);

                    }

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

                    shopifyProductSyncService.syncByWarehouse(ProfitMandiConstants.WAREHOUSE_NAME_MAP.get("UP-WEST/NOIDA"));

                }

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

                String duplicateInvoice = args.getOptionValues("duplicateInvoice").get(0);

                String activeInvoice = args.getOptionValues("activeInvoice").get(0);

                runOnceTasks.postCreditNoteForDuplicateInvoice(duplicateInvoice, activeInvoice);

            }

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

                runOnceTasks.fixDupGrns();

            }

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

                boolean recreatePri = args.containsOption("recreatePri");

                runOnceTasks.cancelDn(args.getOptionValues("dn").get(0), recreatePri);

            }

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

                investmentRelatedTasks.payMonthlyInvestment();

            }

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

                investmentRelatedTasks.evaluateActualInvestmentPayout();

            }

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

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