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();

    }

}