java-insagent-pc/src/main/java/com/ydtech/modules/partner/utils/TimedTaskUtils.java

package com.ydtech.modules.partner.utils;


import cn.hutool.extra.spring.SpringUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.ydtech.modules.partner.dao.PartnerExpiredCommissionMapper;
import com.ydtech.modules.partner.dao.PartnerPartnerAccountMapper;
import com.ydtech.modules.partner.dao.PartnerPremiumDetailsMapper;
import com.ydtech.modules.partner.dao.PartnerUserMapper;
import com.ydtech.modules.partner.model.*;
import com.ydtech.modules.partner.model.param.PartnerRuleEntity;
import com.ydtech.modules.partner.service.PartnerLiftingRecordService;
import com.ydtech.modules.partner.service.PartnerRuleService;
import com.ydtech.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;


/**
 * 定时任务
 *
 * @author
 */

@Slf4j
@Component
public class TimedTaskUtils {

    @Autowired
    private PartnerLiftingRecordService liftingRecordService;

    @Autowired
    private PartnerPartnerAccountMapper accountMapper;

    @Autowired
    private PartnerUserMapper partnerUserMapper;

    @Autowired
    private PartnerRuleService partnerRuleService;

    @Autowired
    private PartnerExpiredCommissionMapper expiredCommissionMapper;

    @Autowired
    private PartnerPremiumDetailsMapper premiumDetailsMapper;

    @Value("${partner.expireDays}")
    private Integer expireDays;

    /**
     * TODO  每天晚上  记录佣金过期记录
     */
    //@XxlJob("updateOrderDateNoon")
    @Scheduled(cron = "0 0 0 * * *")
    public void updateOrderDateNoon() {
        log.info("记录佣金过期定时任务开始执行:{}", expireDays);
        List<PartnerLiftingRecord> list = liftingRecordService.queryExpireDays(expireDays);
        for (PartnerLiftingRecord record : list) {
            //清空 当前用户抽成账户表
            PartnerPartnerAccount account = accountMapper.selectOne(new LambdaQueryWrapper<>(PartnerPartnerAccount.class)
                    .eq(PartnerPartnerAccount::getUserId, record.getUserId()).eq(PartnerPartnerAccount::getGrade, record.getOriginalLevel()));
            if (null ==  account){
                continue;
            }
            BigDecimal lockCommission = liftingRecordService.queryLockCommission(record.getUserId(), record.getOriginalLevel());
            PartnerExpiredCommission commission = getExpiredCommission(record,lockCommission);
            expiredCommissionMapper.insert(commission);
            if (null != lockCommission){
                account.setExpiredAmount(account.getExpiredAmount().add(lockCommission));
                accountMapper.updateById(account);
            }
            liftingRecordService.updateAuditStatusById(record);
            PartnerUser partnerUser = partnerUserMapper.selectOne(new LambdaQueryWrapper<PartnerUser>().eq(PartnerUser::getUserId, record.getUserId())
                    .eq(PartnerUser::getGrade, record.getOriginalLevel()));
//            partnerUser.setIdentityTime(PartnerDateUtils.addDaysToday(new Date(),0));
//            partnerUserMapper.updateById(partnerUser);
            //更新单据状态
            premiumDetailsMapper.updateAppStatus(record.getOriginalLevel(), record.getUserId(), 2,partnerUser.getIdentityTime());
        }


    }

    private static PartnerExpiredCommission getExpiredCommission(PartnerLiftingRecord record, BigDecimal lockCommission) {
        PartnerExpiredCommission commission = new PartnerExpiredCommission();
        commission.setName(record.getName());
        commission.setMobile(record.getMobile());
        commission.setUserId(record.getUserId());
        commission.setDeptId(record.getDeptId());
        commission.setDeptName(record.getDeptName());
        commission.setGrade(record.getOriginalLevel());
        commission.setGradeAfter(record.getAfterChange());
        commission.setLockCommission(null == lockCommission ? new BigDecimal("0") : lockCommission);
        commission.setDowngradeTime(record.getCreateTime());
        commission.setExpiration(new Date());
        commission.setCreateTime(new Date());
        return commission;
    }


    /**
     * TODO: 更新降级考核时间
     */
    //@XxlJob("checkCommissionExpireTime")
    @Scheduled(cron = "0 0 0 * * *")
    public void checkCommissionExpireTime() {
        // TODO等级规则
        List<PartnerRuleEntity> partnerRuleEntities = partnerRuleService.queryAll();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<PartnerUser> partnerUsers = partnerUserMapper.queryDowngradedData();
        for (PartnerUser partnerUser : partnerUsers) {
            PartnerRuleEntity rule = getRule(String.valueOf(partnerUser.getGrade()), partnerRuleEntities);
            Integer khDays = rule.getKhDays();
            Date upgradeStartTime = getUpgradeStartTime(partnerUser);
            if (null == upgradeStartTime){
                continue;
            }
            System.out.println("开始时间：" + formatter.format(upgradeStartTime));
            //  生成结束时间
            Date upgradeEndTime = PartnerDateUtils.addDays(upgradeStartTime, khDays);
            System.out.println("结束时间：" + formatter.format(upgradeEndTime));
            if (PartnerDateUtils.isSameDay(upgradeEndTime)){
                // TODO考核条件  不满足时需锁定
                ExpiredCommissionUtils commissionUtils = SpringUtil.getBean(ExpiredCommissionUtils.class);
                boolean checked = commissionUtils.checkUpgradeConditions(partnerUser);
                if (!checked){
                    //TODO  不满足
                    commissionUtils.generateLockRecords(partnerUser);
                }
                //TODO    更新考核周期
                partnerUserMapper.updateUpgradeCycleStartTime(partnerUser.getUserId(), PartnerDateUtils.addDaysToday(upgradeEndTime, 1),partnerUser.getGrade());
            }
        }
        update(partnerRuleEntities);
    }


    public void update(List<PartnerRuleEntity> partnerRuleEntities){
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("identity_status", 0);
        queryWrapper.in("grade", 2,3,4);
        queryWrapper.orderByDesc("create_time");
        //queryWrapper.eq("user_id", "99140105M36012");
        List<PartnerUser> partnerUsers = partnerUserMapper.selectList(queryWrapper);

        for (PartnerUser filteredUser : partnerUsers) {
            PartnerRuleEntity rule = getRule(String.valueOf(filteredUser.getGrade()), partnerRuleEntities);
            Date upgradeStartTime = getUpgradeStartTime(filteredUser);
            if (null == upgradeStartTime){
                continue;
            }
            //TODO    更新考核周期
            updateUpgradeCycleTime(filteredUser,rule, upgradeStartTime);
        }

    }

    private Date getUpgradeStartTime(PartnerUser filteredUser){
        Date upgradeStartTime = partnerUserMapper.selectUpgradeStartTime(filteredUser.getUserId(), filteredUser.getGrade());
        if (upgradeStartTime == null) {
            partnerUserMapper.updateUpgradeStartTime(filteredUser.getUserId(), filteredUser.getGrade());
        }
        return partnerUserMapper.selectUpgradeStartTime(filteredUser.getUserId(), filteredUser.getGrade());
    }

    public  void updateUpgradeCycleTime(PartnerUser partnerUser,PartnerRuleEntity rule,Date upgradeTime) {
        Integer khDays = rule.getKhDays();
        boolean today = false;
        while (!PartnerDateUtils.isWithinDays(upgradeTime, khDays)) {
            upgradeTime = PartnerDateUtils.addDaysToday(upgradeTime, khDays);
            today = true;
        }
        if (today){
            partnerUserMapper.updateUpgradeCycleStartTime(partnerUser.getUserId(), upgradeTime,partnerUser.getGrade());
        }
    }

    public PartnerRuleEntity getRule(String grade,List<PartnerRuleEntity> partnerRuleEntities) {
        return partnerRuleEntities.stream().filter(partnerRuleEntity -> StringUtils.equals(partnerRuleEntity.getGrade(), grade)).findAny().orElse(null);
    }

}