tutuxiang_mimiback/src/main/java/com/izouma/awesomeadmin/service/impl/ActivityInfoServiceImpl.java

package com.izouma.awesomeadmin.service.impl;

import com.izouma.awesomeadmin.constant.AppConstant;
import com.izouma.awesomeadmin.dao.*;
import com.izouma.awesomeadmin.dto.Page;
import com.izouma.awesomeadmin.model.*;
import com.izouma.awesomeadmin.service.ActivityInfoService;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * service接口实现类
 */
@Service
public class ActivityInfoServiceImpl implements ActivityInfoService {

    private static Logger logger = Logger.getLogger(ActivityInfoServiceImpl.class);

    @Autowired
    private ActivityInfoMapper activityInfoMapper;

    @Autowired
    private UserInfoMapper userInfoMapper;

    @Autowired
    private MemberPointMapper memberPointMapper;

    @Autowired
    private ActivityLogMapper activityLogMapper;

    @Autowired
    private RechargeRecordMapper rechargeRecordMapper;

    @Override
    public List<ActivityInfo> getActivityInfoList(ActivityInfo record) {

        logger.info("getActivityInfoList");
        try {

            return activityInfoMapper.queryAllActivityInfo(record);
        } catch (Exception e) {
            logger.error("getActivityInfoList", e);
        }

        return null;
    }

    @Override
    public List<ActivityInfo> getActivityInfoByPage(Page page, ActivityInfo record) {

        logger.info("getActivityInfoByPage");
        try {

            Map<String, Object> parameter = new HashMap<String, Object>();
            parameter.put("record", record);
            parameter.put(AppConstant.PAGE, page);

            return activityInfoMapper.queryActivityInfoByPage(parameter);
        } catch (Exception e) {
            logger.error("getActivityInfoByPage", e);
        }

        return null;
    }

    @Override
    public ActivityInfo getActivityInfoById(String id) {

        logger.info("getActivityInfoyId");
        try {

            return activityInfoMapper.selectByPrimaryKey(Integer.valueOf(id));
        } catch (Exception e) {
            logger.error("getActivityInfoById", e);
        }

        return null;
    }

    @Override
    public ActivityInfo getActivityInfo(ActivityInfo record) {

        logger.info("getActivityInfo");
        try {

            return activityInfoMapper.queryActivityInfo(record);
        } catch (Exception e) {
            logger.error("getActivityInfo", e);
        }

        return null;
    }

    @Override
    public ActivityInfo getUsedActivityInfo(ActivityInfo record) {

        logger.info("getUsedActivityInfo");
        try {

            return activityInfoMapper.queryUsedActivityInfo(record);
        } catch (Exception e) {
            logger.error("getUsedActivityInfo", e);
        }

        return null;
    }

    @Override
    public List<ActivityInfo> getUsedManJianActivityInfo(ActivityInfo record) {

        logger.info("getUsedManJianActivityInfo");
        try {

            return activityInfoMapper.queryUsedManJianActivityInfo(record);
        } catch (Exception e) {
            logger.error("getUsedManJianActivityInfo", e);
        }

        return null;
    }

    @Override
    public boolean createActivityInfo(ActivityInfo record) {

        logger.info("createActivityInfo");
        try {

            int updates = activityInfoMapper.insertSelective(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("createActivityInfo", e);
        }

        return false;
    }

    @Override
    public boolean deleteActivityInfo(ActivityInfo record) {

        logger.info("deleteActivityInfo");
        try {

            int updates = activityInfoMapper.delete(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("deleteActivityInfo", e);
        }

        return false;
    }

    @Override
    public boolean updateActivityInfo(ActivityInfo record) {

        logger.info("updateActivityInfo");
        try {

            int updates = activityInfoMapper.updateByPrimaryKeySelective(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("updateActivityInfo", e);
        }

        return false;
    }


    @Override
    public boolean consumptionSongMoney(UserOrder userOrder) {

        logger.info("consumptionSongMoney");

        try {

            ActivityInfo activityInfo = new ActivityInfo();
            activityInfo.setTypeId(4);
            activityInfo = activityInfoMapper.queryUsedActivityInfo(activityInfo);

            if (activityInfo != null) {

                //最小赠送条件
                int minValue = Integer.valueOf(activityInfo.getMinValue());


                //赠送比率  消费 * rate = 反积分
                double rate = Double.valueOf(activityInfo.getRatio());

                //消费金额  余额和现金
                int consumptionMoney = userOrder.getCash().add(userOrder.getCoin()).intValue();

                //反积分份数
                int pointTimes = (int) Math.floor(consumptionMoney * 1.0 / minValue);

                //积分数
                int point = (int) Math.floor(minValue * rate / 100) * pointTimes;

                if (consumptionMoney >= minValue && point > 0) {//如果消费金额大于要求，可用赠送积分


                    MemberPoint memberPoint = new MemberPoint();
                    memberPoint.setMoney(String.valueOf(point));
                    memberPoint.setUserId(String.valueOf(userOrder.getUserId()));
                    memberPoint.setOrderId(String.valueOf(userOrder.getId()));


                    int userId = Integer.valueOf(userOrder.getUserId());
                    UserInfo userInfo = userInfoMapper.selectByPrimaryKey(userId);

                    if (userInfo != null) {

                        UserInfo updateUser = new UserInfo();
                        updateUser.setId(userId);

                        double balance = userInfo.getMoneyPoint();
                        double moneyPoint = balance + point;

                        memberPoint.setCreateUser("管理员");
                        memberPoint.setBalance(String.valueOf(moneyPoint));
                        memberPoint.setTypeFlag(AppConstant.CoinType.FAN_HUAN);
                        memberPoint.setRemark("订单消费反：" + point + "积分");
                        memberPointMapper.insertSelective(memberPoint);

                        updateUser.setMoneyPoint(moneyPoint);
                        userInfoMapper.updateByPrimaryKeySelective(updateUser);

                        ActivityLog activityLog = new ActivityLog();
                        activityLog.setActivityId(String.valueOf(activityInfo.getId()));
                        activityLog.setTypeId(String.valueOf(activityInfo.getTypeId()));
                        activityLog.setUserId(String.valueOf(userId));
                        activityLog.setPoint(String.valueOf(point));
                        activityLog.setCoin(String.valueOf(userOrder.getCoin()));
                        activityLog.setCash(String.valueOf(userOrder.getCash()));
                        activityLog.setTotalPrice(String.valueOf(userOrder.getDealPrice()));
                        activityLog.setOrderId(String.valueOf(userOrder.getId()));
                        activityLog.setStoreId(String.valueOf(userOrder.getStoreId()));
                        activityLog.setProductId(String.valueOf(userOrder.getProductId()));
                        activityLog.setCreateUser("消费反积分");

                        activityLogMapper.insertSelective(activityLog);
                    }


                }
            }

            return true;
        } catch (Exception e) {
            logger.error("消费反积分异常", e);
        }

        return false;
    }

    @Override
    public boolean manjianActivityLog(UserOrder userOrder) {

        logger.info("manjianActivityLog");

        try {

            ActivityInfo activityInfo = activityInfoMapper.selectByPrimaryKey(userOrder.getActivityId());

            if (activityInfo != null) {


                ActivityLog activityLog = new ActivityLog();
                activityLog.setActivityId(String.valueOf(activityInfo.getId()));
                activityLog.setTypeId(String.valueOf(activityInfo.getTypeId()));
                activityLog.setUserId(String.valueOf(userOrder.getUserId()));
                activityLog.setTotalPrice(String.valueOf(userOrder.getTotlePrice()));
                activityLog.setOrderId(String.valueOf(userOrder.getId()));
                activityLog.setStoreId(String.valueOf(userOrder.getStoreId()));
                activityLog.setProductId(String.valueOf(userOrder.getProductId()));
                activityLog.setCreateUser("消费满减活动");

                activityLogMapper.insertSelective(activityLog);
            }


            return true;
        } catch (Exception e) {
            logger.error("消费满减log异常", e);
        }

        return false;
    }

    @Override
    public BigDecimal manjianActivity(UserOrder record, BigDecimal orderMoney) {

        logger.info("manjianActivity");

        try {

            ActivityInfo activityInfo = new ActivityInfo();
            activityInfo.setTypeId(6);
            List<ActivityInfo> activityInfoList = activityInfoMapper.queryUsedManJianActivityInfo(activityInfo);

            if (activityInfoList != null) {

                ActivityInfo manjian = new ActivityInfo();

                for (ActivityInfo temp : activityInfoList) {
                    BigDecimal tempMax = BigDecimal.valueOf(Double.valueOf(activityInfo.getMaxValue()));
                    if (orderMoney.compareTo(tempMax) > 0) {
                        manjian = temp;
                    }
                }

                //减免金额
                BigDecimal minValue = BigDecimal.valueOf(Double.valueOf(manjian.getMinValue()));

                BigDecimal maxValue = BigDecimal.valueOf(Double.valueOf(manjian.getMaxValue()));

                if (orderMoney.compareTo(maxValue) > 0) {//如果消费金额大于要求，可用减免

                    record.setActivityId(manjian.getId());
                    return orderMoney.subtract(minValue);

                }
            }

        } catch (Exception e) {
            logger.error("消费满减异常", e);
        }

        return orderMoney;
    }

    @Override
    public boolean rechargeSongMoney(RechargeRecord rechargeRecord) {

        logger.info("rechargeSongMoney");

        try {

            ActivityInfo activityInfo = new ActivityInfo();
            activityInfo.setTypeId(2);
            activityInfo = activityInfoMapper.queryUsedActivityInfo(activityInfo);

            if (activityInfo != null) {

                //最小赠送条件
                int minValue = Integer.valueOf(activityInfo.getMinValue());

                //总赠送数量
                int limitNum = Integer.valueOf(activityInfo.getActivityType().getLimitNum());

                //赠送比率  充值金额* rate = 赠送数量
                double rate = Double.valueOf(activityInfo.getRatio());

                //充值金额
                int rechargeMoney = rechargeRecord.getMoney().intValue();

                int point = (int) Math.floor(rechargeMoney * rate / 100);

                if (rechargeMoney >= minValue) {//如果充值金额大于要求，可用赠送积分

                    ActivityLog checkLimit = new ActivityLog();
                    checkLimit.setTypeId(String.valueOf(activityInfo.getTypeId()));

                    checkLimit = activityLogMapper.queryLimitActivityLog(checkLimit);

                    if (checkLimit != null && checkLimit.getPoint() != null && Integer.valueOf(checkLimit.getPoint()) >= limitNum) {
                        return false;
                    }


                    MemberPoint memberPoint = new MemberPoint();
                    memberPoint.setMoney(String.valueOf(point));
                    memberPoint.setUserId(String.valueOf(rechargeRecord.getUserId()));


                    int userId = Integer.valueOf(rechargeRecord.getUserId());
                    UserInfo userInfo = userInfoMapper.selectByPrimaryKey(userId);

                    if (userInfo != null) {

                        UserInfo updateUser = new UserInfo();
                        updateUser.setId(userId);

                        double balance = userInfo.getMoneyPoint();
                        double moneyPoint = balance + point;

                        memberPoint.setCreateUser("管理员");
                        memberPoint.setBalance(String.valueOf(moneyPoint));
                        memberPoint.setTypeFlag(AppConstant.CoinType.SONG);
                        memberPoint.setRemark("充值" + rechargeMoney + "，赠送：" + point + "积分");
                        memberPointMapper.insertSelective(memberPoint);

                        updateUser.setMoneyPoint(moneyPoint);
                        userInfoMapper.updateByPrimaryKeySelective(updateUser);

                        ActivityLog activityLog = new ActivityLog();
                        activityLog.setActivityId(String.valueOf(activityInfo.getId()));
                        activityLog.setTypeId(String.valueOf(activityInfo.getTypeId()));
                        activityLog.setUserId(String.valueOf(userId));
                        activityLog.setPoint(String.valueOf(point));
                        activityLog.setCoin(String.valueOf(rechargeMoney));
                        activityLog.setCreateUser("充值礼");

                        activityLogMapper.insertSelective(activityLog);
                    }


                }
            }

            return true;
        } catch (Exception e) {
            logger.error("充值赠送积分异常", e);
        }

        return false;
    }

    @Override
    public boolean registerSongMoney(UserInfo record) {

        logger.info("registerSongMoney");
        try {

            ActivityInfo activityInfo = new ActivityInfo();
            activityInfo.setTypeId(1);
            activityInfo = activityInfoMapper.queryUsedActivityInfo(activityInfo);

            if (activityInfo != null) {

                double song = Integer.valueOf(activityInfo.getMinValue());
                if (song > 0) {
                    MemberPoint memberPoint = new MemberPoint();
                    memberPoint.setMoney(String.valueOf(song));
                    memberPoint.setUserId(String.valueOf(record.getId()));
                    double money = song;


                    int userId = Integer.valueOf(record.getId());
                    UserInfo userInfo = userInfoMapper.selectByPrimaryKey(record.getId());

                    UserInfo updateUser = new UserInfo();
                    updateUser.setId(userId);


                    double balance = userInfo.getMoneyPoint();
                    double moneyPoint = balance + money;

                    memberPoint.setCreateUser("管理员");
                    memberPoint.setBalance(String.valueOf(moneyPoint));
                    memberPoint.setTypeFlag(AppConstant.CoinType.SONG);
                    memberPoint.setRemark("新用户注册，后台赠送：" + money + "积分");
                    memberPointMapper.insertSelective(memberPoint);

                    updateUser.setMoneyPoint(moneyPoint);
                    userInfoMapper.updateByPrimaryKeySelective(updateUser);

                    ActivityLog activityLog = new ActivityLog();
                    activityLog.setActivityId(String.valueOf(activityInfo.getId()));
                    activityLog.setTypeId(String.valueOf(activityInfo.getTypeId()));
                    activityLog.setUserId(String.valueOf(record.getId()));
                    activityLog.setPoint(String.valueOf(song));
                    activityLog.setCreateUser("注册礼");

                    activityLogMapper.insertSelective(activityLog);

                }
            }

            return true;
        } catch (Exception e) {
            logger.error("新用户注册赠送积分异常", e);
        }

        return false;
    }


    @Override
    public boolean zhongchouSongMoney(ActivityInfo record) {

        logger.info("zhongchouSongMoney");
        try {

            ActivityInfo activityInfo = activityInfoMapper.selectByPrimaryKey(record.getId());

            if (activityInfo != null && activityInfo.getUseFlag() != "C" && activityInfo.getTypeId() == 3) {
                int roundNum = Integer.valueOf(activityInfo.getMinValue());
                double rate = Double.valueOf(activityInfo.getRatio()) / 100;

                RechargeRecord param = new RechargeRecord();

                param.setBeginTime(activityInfo.getBeginTime());
                param.setEndTime(activityInfo.getEndTime());

                List<RechargeRecord> rechargeRecordList = rechargeRecordMapper.queryActivityRechargeRecord(param);

                int size = rechargeRecordList.size();

                int maxNum = size - size % roundNum;

                if (maxNum > 0 && maxNum <= size) {

                    for (int i = 1; i <= maxNum; i++) {

                        RechargeRecord rechargeRecord = rechargeRecordList.get(i - 1);

                        int totalCoin = rechargeRecord.getMoney().intValue();

                        int times = (maxNum - i) / roundNum + 1;

                        double song = Math.floor(times * rate * totalCoin);


                        if (song > 0) {

                            int userId = Integer.valueOf(rechargeRecord.getUserId());

                            ActivityLog activityCheck = new ActivityLog();
                            activityCheck.setUserId(String.valueOf(userId));
                            activityCheck.setActivityId(String.valueOf(activityInfo.getId()));

                            activityCheck = activityLogMapper.queryActivityLog(activityCheck);

                            if (activityCheck == null) {

                                MemberPoint memberPoint = new MemberPoint();
                                memberPoint.setMoney(String.valueOf(song));
                                memberPoint.setUserId(String.valueOf(userId));
                                double money = song;


                                UserInfo userInfo = userInfoMapper.selectByPrimaryKey(userId);

                                UserInfo updateUser = new UserInfo();
                                updateUser.setId(userId);


                                double balance = userInfo.getMoneyPoint();
                                double moneyPoint = balance + money;

                                memberPoint.setCreateUser("管理员");
                                memberPoint.setBalance(String.valueOf(moneyPoint));
                                memberPoint.setTypeFlag(AppConstant.CoinType.SONG);
                                memberPoint.setRemark("众筹奖励，后台赠送：" + money + "积分");
                                memberPointMapper.insertSelective(memberPoint);

                                updateUser.setMoneyPoint(moneyPoint);
                                userInfoMapper.updateByPrimaryKeySelective(updateUser);

                                ActivityLog activityLog = new ActivityLog();
                                activityLog.setActivityId(String.valueOf(activityInfo.getId()));
                                activityLog.setTypeId(String.valueOf(activityInfo.getTypeId()));
                                activityLog.setUserId(String.valueOf(userId));
                                activityLog.setPoint(String.valueOf(song));
                                activityLog.setRemark("第" + i + "位，总人数" + size + "位，获得" + times + "次众筹礼");
                                activityLog.setCreateUser("众筹礼");

                                activityLogMapper.insertSelective(activityLog);


                            }


                        }


                    }

                }

                activityInfo.setUseFlag("C");//结算完成

                activityInfoMapper.updateByPrimaryKeySelective(activityInfo);
            }

            return true;
        } catch (Exception e) {
            logger.error("新用户注册赠送积分异常", e);
        }

        return false;
    }
}