Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.service;

import com.google.common.collect.Maps;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.dao.entity.BrandSalesRewards;
import com.spice.profitmandi.dao.entity.ModelRewardPoints;
import com.spice.profitmandi.dao.entity.SaleRewardHistory;
import com.spice.profitmandi.dao.model.EligibleRewardItemsModel;
import com.spice.profitmandi.dao.repository.ModelRewardPointsRepository;
import com.spice.profitmandi.dao.repository.SaleRewardHistoryRepository;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.TypedQuery;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.*;

@Transactional(rollbackFor = Throwable.class)
@Component
public class SaleRewardServiceImpl implements SaleRewardService {
    private static final Logger logger = LogManager.getLogger(SaleRewardServiceImpl.class);

    @Autowired
    private SaleRewardHistoryRepository saleRewardHistoryRepository;

    @Autowired
    private ModelRewardPointsRepository modelRewardPointsRepository;

    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public void disburseRewardsByEligibility(LocalDate date) {
        ProfitMandiConstants.BRAND_REWARD_REGION_IDS.forEach(regionId -> {
            List<EligibleRewardItemsModel> eligibleRewardItemsModelList = selectBrandItemsByRegionAndDate(regionId,"Oppo", date);

            for (EligibleRewardItemsModel item : eligibleRewardItemsModelList) {
                logger.info("rewardHistories after item: {}", item);
                ModelRewardPoints modelReward = modelRewardPointsRepository.findByCatalogAndRegionId(item.getCatalogId(), regionId);
                logger.info("modelReward after item: {}", modelReward);

                BigDecimal rewardPoints;

                if (modelReward != null) {
                    rewardPoints = BigDecimal.valueOf(modelReward.getPoints());
                } else {
                    rewardPoints = BigDecimal.valueOf(ProfitMandiConstants.getRewardPoint(item.getDp()));
                }
                logger.info("rewardPoints after item: {}", rewardPoints);

                SaleRewardHistory saleRewardHistory = new SaleRewardHistory();
                saleRewardHistory.setCatalogId(item.getCatalogId());
                saleRewardHistory.setFofoId(item.getFofoStoreId());
                saleRewardHistory.setOrderId(item.getOrderId());
                saleRewardHistory.setPointEarned(rewardPoints);
                saleRewardHistory.setImeis(item.getSerialNumber());
                saleRewardHistory.setQty(item.getQuantity());
                saleRewardHistoryRepository.persist(saleRewardHistory);
            }
        });

    }

    @Override
    public Map<String, Object> findByFofoAndRegionId(int fofoId, int regionId) {

        List<SaleRewardHistory> saleRewardHistories = saleRewardHistoryRepository.findByFofoId(fofoId);

        if (saleRewardHistories == null) {
            saleRewardHistories = Collections.emptyList();
        }

        int totalQuantity = saleRewardHistories.stream()
                .map(SaleRewardHistory::getQty)
                .filter(Objects::nonNull)
                .mapToInt(Integer::intValue)
                .sum();

        double totalPoints = saleRewardHistories.stream()
                .map(SaleRewardHistory::getPointEarned)
                .filter(Objects::nonNull)
                .mapToDouble(p -> p.doubleValue())
                .sum();

        List<BrandSalesRewards> brandSalesRewardsList = modelRewardPointsRepository.selectAllByRegionId(regionId);
        BrandSalesRewards reward = null;
        if (regionId == 19) {
            reward = brandSalesRewardsList.stream()
                    .filter(r -> r.getSalesScore() <= (int) Math.floor(totalPoints))
                    .max(Comparator.comparingInt(BrandSalesRewards::getSalesScore))
                    .orElse(null);
        } else {
            reward = brandSalesRewardsList.stream()
                    .filter(r -> totalQuantity >= r.getSalesScore() && totalQuantity <= r.getPerPointBonus())
                    .findFirst()
                    .orElse(null);
        }
        logger.info("reward after item: {}", reward);

        Map<String, Object> map = Maps.newHashMap();
        map.put("quantity",totalQuantity);
        map.put("points",totalPoints);
        if (reward != null) {
            map.put("gift", reward.getRewardName()+" ("+reward.getQty()+") or "+reward.getRewardValue());
        } else {
            map.put("gift", "No Reward");
        }
        return map;
    }

    public List<EligibleRewardItemsModel> selectBrandItemsByRegionAndDate(int regionId, String brand, LocalDate date) {
        Session session = sessionFactory.getCurrentSession();
        final TypedQuery<EligibleRewardItemsModel> typedQuery =
            session.createNamedQuery("FofoOrderItem.selectBrandItemsByRegionAndDate", EligibleRewardItemsModel.class);

        typedQuery.setParameter("brand", brand);
        typedQuery.setParameter("regionId", regionId);
        typedQuery.setParameter("orderStartDate", date.atStartOfDay());
        typedQuery.setParameter("orderEndDate", date.atTime(LocalTime.MAX));
        return typedQuery.getResultList();
    }
}