Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.pricing;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

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

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.dao.entity.fofo.InventoryItem;

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

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

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

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

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

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

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

import com.spice.profitmandi.service.wallet.WalletService;

import in.shop2020.model.v1.order.WalletReferenceType;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import java.text.MessageFormat;

import java.time.LocalDateTime;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

/**

 * Shared unit of work for price-hike deduction. The core {@link #deductPartnerUnits} (no transaction

 * of its own — runs in the caller's) is used by both the GRN hook (inside the GRN transaction) and

 * the on-demand endpoint. The endpoint path additionally uses the REQUIRES_NEW methods here so each

 * retailer is isolated.

 */

@Component

public class PriceHikeWorker {

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

    @Autowired

    private PriceDropRepository priceDropRepository;

    @Autowired

    private PriceDropIMEIRepository priceDropIMEIRepository;

    @Autowired

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private WalletService walletService;

    /**

     * Idempotent create-APPROVED-rows + wallet debit for one retailer's serials against one hike.

     * Runs in the caller's transaction. Serials already recorded for this hike are skipped.

     */

    public void deductPartnerUnits(PriceDrop hike, int retailerId, Map<String, Integer> serialToInventoryItemId)

            throws ProfitMandiBusinessException {

        if (serialToInventoryItemId.isEmpty()) {

            return;

        }

        Set<String> existing = priceDropIMEIRepository.selectByPriceDropId(hike.getId()).stream()

                .filter(x -> x.getPartnerId() == retailerId)

                .map(PriceDropIMEI::getImei).collect(Collectors.toSet());

        Map<String, Integer> fresh = serialToInventoryItemId.entrySet().stream()

                .filter(e -> !existing.contains(e.getKey()))

                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a));

        if (fresh.isEmpty()) {

            return;

        }

        LocalDateTime now = LocalDateTime.now();

        for (Map.Entry<String, Integer> e : fresh.entrySet()) {

            PriceDropIMEI row = new PriceDropIMEI();

            row.setPriceDropId(hike.getId());

            row.setPartnerId(retailerId);

            row.setImei(e.getKey());

            row.setStatus(PriceDropImeiStatus.APPROVED);

            row.setInventoryItemId(e.getValue() == null ? 0 : e.getValue());

            row.setCreditTimestamp(now);

            row.setUpdateTimestamp(now);

            priceDropIMEIRepository.persist(row);

        }

        // amount is negative for a hike, so amount * count reduces the wallet balance (a debit).

        String reason = MessageFormat.format("Price Hike recovery of Rs.{0} per unit. Total {1} item(s)",

                FormattingUtils.formatDecimal(Math.abs(hike.getDropAmount())), fresh.size());

        walletService.addAmountToWallet(retailerId, hike.getId(), WalletReferenceType.PRICE_DROP, reason,

                hike.getAmount() * fresh.size(), hike.getAffectedOn());

        LOGGER.info("Price hike {} — debited retailer {} for {} unit(s)", hike.getId(), retailerId, fresh.size());

    }

    /** Endpoint path: eligible (gap-billed) serials for a hike, grouped by retailer. Own transaction. */

    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true)

    public Map<Integer, List<String>> loadEligibleUnits(int priceDropId) throws ProfitMandiBusinessException {

        PriceDrop pd = priceDropRepository.selectById(priceDropId);

        if (pd == null || pd.getAmount() >= 0) {

            return Collections.emptyMap();

        }

        List<GrnPendingDataModel> billed = orderRepository.selectAllOrdersByBilledDateCatalogId(

                pd.getCatalogItemId(), pd.getAffectedOn(), pd.getCreatedOn());

        return billed.stream()

                .filter(x -> x.getSerialNumber() != null && x.getRetailerId() > 0)

                .collect(Collectors.groupingBy(GrnPendingDataModel::getRetailerId,

                        Collectors.mapping(GrnPendingDataModel::getSerialNumber, Collectors.toList())));

    }

    /** Endpoint path: one retailer, its own transaction, so a single retailer's failure is isolated. */

    @Transactional(propagation = Propagation.REQUIRES_NEW)

    public void deductForRetailer(int priceDropId, int retailerId, List<String> serials)

            throws ProfitMandiBusinessException {

        PriceDrop hike = priceDropRepository.selectById(priceDropId);

        if (hike == null || hike.getAmount() >= 0) {

            return;

        }

        Set<String> serialSet = new HashSet<>(serials);

        Map<String, Integer> serialToInventoryItemId = new HashMap<>();

        for (String serial : serialSet) {

            serialToInventoryItemId.put(serial, 0); // 0 until GRN'd; the DN backfill fills it in later

        }

        // Set the real inventory_item_id for any serial already GRN'd (present in inventory).

        inventoryItemRepository.selectByFofoIdSerialNumbers(retailerId, serialSet, false)

                .forEach(ii -> serialToInventoryItemId.put(ii.getSerialNumber(), ii.getId()));

        deductPartnerUnits(hike, retailerId, serialToInventoryItemId);

    }

}