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.entity.StoreSalesTarget;
import com.spice.profitmandi.dao.model.EligibleRewardItemsModel;
import com.spice.profitmandi.dao.repository.GenericRepository;
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.LocalDateTime;
import java.util.*;

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

    @Autowired
    private GenericRepository genericRepository;

    @Override
    public void disburseRewardsByEligibility() {
        ProfitMandiConstants.BRAND_REWARD_REGION_IDS.forEach(regionId -> {
            LocalDateTime startDateTime = ProfitMandiConstants.OPPO_SCHEME_START_DATE;
            LocalDateTime endDateTime = (regionId == 19) ? ProfitMandiConstants.OPPO_UK_SCHEME_END_DATE : ProfitMandiConstants.OPPO_HR_SCHEME_END_DATE;
            List<EligibleRewardItemsModel> eligibleRewardItemsModelList = selectBrandItemsByRegionAndDate(regionId,"Oppo", startDateTime, endDateTime);

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

                    BigDecimal rewardPoints = BigDecimal.valueOf(item.getQuantity());;
                    /*if (regionId == 19) {
                        if (modelReward != null) {
                            rewardPoints = BigDecimal.valueOf(modelReward.getPoints());
                        } else {
                            rewardPoints = BigDecimal.valueOf(ProfitMandiConstants.getRewardPoint(item.getDp()));
                        }
                    } else {
                        rewardPoints = BigDecimal.valueOf(item.getQuantity());
                    }*/

                    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());
                    logger.info("saleRewardHistory: {}", saleRewardHistory);
                    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, LocalDateTime startDateTime, LocalDateTime endDateTime) {
        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", startDateTime);
        typedQuery.setParameter("orderEndDate", endDateTime);
        return typedQuery.getResultList();
    }

    public StoreSalesTarget findTargetsByFofoId(int fofoId) {
        return genericRepository.selectByEqual(StoreSalesTarget.class, "fofoId", fofoId);
    }
}