Subversion Repositories SmartDukaan

import java.util.stream.Collectors;

    /** Cap on how many never-attempted items the alert lists by name. */

    private static final int PENDING_LIST_CAP = 50;

    /**

     * REQUIRED — deliberately NOT REQUIRES_NEW.

     *

     * Every caller is the last statement of a REQUIRES_NEW per-item work method, so this

     * joins that work transaction and the SUCCESS marker commits (or rolls back) with the

     * work it describes. Under REQUIRES_NEW the marker committed on its own, so work that

     * later failed at flush/commit — a constraint violation, a wallet deadlock — was left

     * recorded as a successful payout.

     */

    /**

     * REQUIRES_NEW — the opposite of markItemSuccess, and intentionally so: this is called

     * from the orchestrator's catch block after the work transaction has already rolled

     * back, so the failure record must commit independently of it.

     */

    /**

     * RUNNING batches older than {@code staleHours} — a run that died before finalizing.

     * Returns ids only; the caller must finalize each through the proxy (see

     * BatchScheduledTasks.reapStaleBatches) so REQUIRES_NEW actually applies.

     */

    @Transactional(readOnly = true)

    public List<Integer> selectStaleRunningBatchIds(int staleHours) {

        return cronBatchRepository.selectStaleRunning(LocalDateTime.now().minusHours(staleHours))

                .stream().map(CronBatch::getId).collect(Collectors.toList());

    }

    /**

     * Closes a batch using the item rows as the source of truth.

     *

     * successCount is COUNTED, never derived as (total - failures). Deriving it reported

     * every item that never reported at all — the JVM killed mid-loop, a lost marker write —

     * as a successful payout, and suppressed the alert, because failureCount stayed 0.

     *

     * Items still PENDING were never attempted. That leaves the batch INCOMPLETE (not

     * PARTIAL_FAILURE, which means "attempted and failed") and always raises an email.

     * PENDING rows are left as they are: "never tried" and "tried and failed" are

     * different facts and the retry decision depends on which one it was.

     */

        if (batch == null) {

            LOGGER.warn("finalizeBatch called for unknown batch {}", batchId);

            return null;

        }

        int successCount = (int) cronBatchItemRepository

                .countByBatchIdAndStatus(batchId, CronBatchItemStatus.SUCCESS);

        if (pendingCount > 0) {

            batch.setStatus(CronBatchStatus.INCOMPLETE);

        } else if (failureCount > 0) {

        } else {

            batch.setStatus(CronBatchStatus.COMPLETED);

        }

                batchId, batch.getStatus(), successCount, failureCount, pendingCount);

        return new BatchOutcome(batch.getStatus(), batch.getTotalCount(),

                successCount, failureCount, pendingCount);

    /**

     * Result of a finalize, returned rather than re-read by the caller: finalizeBatch

     * commits in its own session, so a caller that re-reads inside its own transaction

     * gets the stale pre-finalize entity back out of Hibernate's first-level cache.

     */

    public static class BatchOutcome {

        private final CronBatchStatus status;

        private final int totalCount;

        private final int successCount;

        private final int failureCount;

        private final int neverAttemptedCount;

        BatchOutcome(CronBatchStatus status, int totalCount, int successCount,

                     int failureCount, int neverAttemptedCount) {

            this.status = status;

            this.totalCount = totalCount;

            this.successCount = successCount;

            this.failureCount = failureCount;

            this.neverAttemptedCount = neverAttemptedCount;

        }

        public CronBatchStatus getStatus() { return status; }

        public int getTotalCount() { return totalCount; }

        public int getSuccessCount() { return successCount; }

        public int getFailureCount() { return failureCount; }

        public int getNeverAttemptedCount() { return neverAttemptedCount; }

    }

        body.append("Batch id: ").append(batch.getId()).append("\n");

        body.append("Outcome: ").append(batch.getStatus()).append("\n");

        body.append("Never attempted: ").append(pendingCount).append("\n\n");

        if (!failedItems.isEmpty()) {

            for (CronBatchItem item : failedItems) {

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

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

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

                        .append("\n");

            }

            body.append("\n");

        }

        if (pendingCount > 0) {

            body.append("The run did not reach these ").append(pendingCount)

                    .append(" item(s) — they were never attempted and no work was done for them:\n");

                    .selectByBatchIdAndStatus(batch.getId(), CronBatchItemStatus.PENDING);

            for (CronBatchItem item : pendingItems.subList(0, Math.min(pendingItems.size(), PENDING_LIST_CAP))) {

            }

            if (pendingItems.size() > PENDING_LIST_CAP) {

            }

        String subject = pendingCount > 0

                ? String.format("[CRON ALERT] %s — INCOMPLETE, %d of %d never attempted",

                        batch.getJobName(), pendingCount, batch.getTotalCount())