Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.cron;

import com.spice.profitmandi.dao.entity.transaction.CronBatch;

import com.spice.profitmandi.dao.entity.transaction.CronBatchItem;

import com.spice.profitmandi.dao.enumuration.transaction.CronBatchItemStatus;

import com.spice.profitmandi.dao.enumuration.transaction.CronBatchStatus;

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

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

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

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.List;

import java.util.Map;

@Service

public class CronBatchService {

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

    private static final String[] TECHNOLOGY_EMAIL = {"amit.gupta@smartdukaan.com"};

    private static final DateTimeFormatter DTF = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    @Autowired

    private CronBatchRepository cronBatchRepository;

    @Autowired

    private CronBatchItemRepository cronBatchItemRepository;

    @Autowired

    private MailOutboxService mailOutboxService;

    /**

     * Read-only guard used by OfferBatchService before creating a new batch.

     * Returns any RUNNING batch for this offer (sellin or activation job name),

     * or null if none. Wrapped in a read-only tx so callers running outside an

     * existing transaction (e.g. background worker thread) can query safely.

     */

    @Transactional(readOnly = true)

    public CronBatch findRunningForOffer(int offerId) {

        List<CronBatch> running = cronBatchRepository.selectRunningForOffer(offerId);

        return running.isEmpty() ? null : running.get(0);

    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)

    public CronBatch createBatch(String jobName, Map<Integer, String> fofoIdPartnerNameMap) {

        CronBatch batch = new CronBatch(jobName);

        batch.setTotalCount(fofoIdPartnerNameMap.size());

        cronBatchRepository.persist(batch);

        for (Map.Entry<Integer, String> entry : fofoIdPartnerNameMap.entrySet()) {

            CronBatchItem item = new CronBatchItem(batch.getId(), entry.getKey(), entry.getValue());

            cronBatchItemRepository.persist(item);

        }

        LOGGER.info("Created batch {} for job {} with {} items", batch.getId(), jobName, fofoIdPartnerNameMap.size());

        return batch;

    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)

    public void markItemSuccess(int batchId, int fofoId) {

        List<CronBatchItem> items = cronBatchItemRepository.selectByBatchIdAndStatus(batchId, CronBatchItemStatus.PENDING);

        for (CronBatchItem item : items) {

            if (item.getFofoId() == fofoId) {

                item.markSuccess();

                break;

            }

        }

    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)

    public void markItemFailed(int batchId, int fofoId, String errorMessage) {

        List<CronBatchItem> items = cronBatchItemRepository.selectByBatchIdAndStatus(batchId, CronBatchItemStatus.PENDING);

        for (CronBatchItem item : items) {

            if (item.getFofoId() == fofoId) {

                item.markFailed(errorMessage);

                break;

            }

        }

    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)

    public void finalizeBatch(int batchId) {

        CronBatch batch = cronBatchRepository.selectById(batchId);

        List<CronBatchItem> failedItems = cronBatchItemRepository.selectFailedByBatchId(batchId);

        int failureCount = failedItems.size();

        int successCount = batch.getTotalCount() - failureCount;

        batch.setSuccessCount(successCount);

        batch.setFailureCount(failureCount);

        batch.setCompletedAt(LocalDateTime.now());

        batch.setStatus(failureCount == 0 ? CronBatchStatus.COMPLETED : CronBatchStatus.PARTIAL_FAILURE);

        LOGGER.info("Batch {} finalized: {} success, {} failed", batchId, successCount, failureCount);

        if (failureCount > 0) {

            sendFailureEmail(batch, failedItems);

        }

    }

    private void sendFailureEmail(CronBatch batch, List<CronBatchItem> failedItems) {

        StringBuilder body = new StringBuilder();

        body.append("Cron job: ").append(batch.getJobName()).append("\n");

        body.append("Run time: ").append(batch.getStartedAt().format(DTF)).append("\n");

        body.append("Total processed: ").append(batch.getTotalCount()).append("\n");

        body.append("Success: ").append(batch.getSuccessCount()).append("\n");

        body.append("Failures: ").append(batch.getFailureCount()).append("\n\n");

        body.append("Partner failures:\n");

        for (CronBatchItem item : failedItems) {

            body.append("- ").append(item.getPartnerName())

                    .append(" (fofoId: ").append(item.getFofoId()).append(")")

                    .append(" — ").append(item.getErrorMessage())

                    .append("\n");

        }

        String subject = String.format("[CRON ALERT] %s — %d of %d partners failed",

                batch.getJobName(), batch.getFailureCount(), batch.getTotalCount());

        try {

            mailOutboxService.queueMailViaGoogle(TECHNOLOGY_EMAIL, null, subject, body.toString(),

                    "CronBatchService." + batch.getJobName());

        } catch (Exception e) {

            LOGGER.error("Failed to send batch failure email for batch {}: {}", batch.getId(), e.getMessage());

        }

    }

}