hsq / hsq-credit-manager · Files

package com.lhcredit.project.model.basicData.service;

import com.lhcredit.common.utils.text.Convert;
import com.lhcredit.project.model.basicData.domain.BasicData;
import com.lhcredit.project.model.basicData.mapper.BasicDataMapper;
import com.lhcredit.project.model.defaultRate.domain.DefaultRate;
import com.lhcredit.project.model.defaultRate.mapper.DefaultRateMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;

/**
 * 静态池 服务层实现
 *
 * @author lhcredit
 * @date 2019-10-14
 */
@Service
public class BasicDataServiceImpl implements IBasicDataService {
    @Autowired
    private BasicDataMapper basicDataMapper;
    @Autowired
    private DefaultRateMapper defaultRateMapper;
    /**
     * 查询静态池信息
     *
     * @param id 静态池ID
     * @return 静态池信息
     */
    @Override
    public BasicData selectBasicDataById(Long id) {
        return basicDataMapper.selectBasicDataById(id);
    }

    /**
     * 查询静态池列表
     *
     * @param basicData 静态池信息
     * @return 静态池集合
     */
    @Override
    public List<BasicData> selectBasicDataList(BasicData basicData) {
        return basicDataMapper.selectBasicDataList(basicData);
    }

    /**
     * 字段转换
     * @param basicData 静态池信息
     * @return 静态池信息
     */
    @Override
    public BasicData changeModel(BasicData basicData) {
//        //这里写各字段转换逻辑
//        if(basicData!=null){
//            if(StringUtils.isNotEmpty(basicData.getXXX())){
//               basicData.setXXX(basicData.getXXX());
//            }
//        }
        return basicData;
    }

    /**
     * 列表转换
     *
     * @param basicDataList 静态池集合
     * @return 静态池集合
     */
    @Override
    public List<BasicData> changeModel(List<BasicData> basicDataList) {
        List<BasicData> result = new ArrayList<BasicData>();
        if (basicDataList.size() > 0) {
            for (BasicData basicData:basicDataList){
                result.add(changeModel(basicData));
            }
        }
        return result;
    }

    /**
     * 新增静态池
     *
     * @param basicData 静态池信息
     * @return 结果
     */
    @Override
    public int insertBasicData(BasicData basicData) {
        return basicDataMapper.insertBasicData(basicData);
    }

    /**
     * 修改静态池
     *
     * @param basicData 静态池信息
     * @return 结果
     */
    @Override
    public int updateBasicData(BasicData basicData) {
        return basicDataMapper.updateBasicData(basicData);
    }

    /**
     * 删除静态池对象
     *
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteBasicDataByIds(String ids) {
        return basicDataMapper.deleteBasicDataByIds(Convert.toStrArray(ids));
    }

    /**
     * 查询静态池列表
     *
     * @param list 静态池集合
     * @return 静态池集合
     */
    @Override
    public void insertData(List<BasicData> list){
        basicDataMapper.insertData(list);
    }

    /**
     * 查询静态池列表
     *
     * @param basicData 标识
     * @return 静态池集合
     */
    public List<BasicData> getBasicData(BasicData basicData){
        return basicDataMapper.getBasicData(basicData);
    }

    /**
     * 计算累计违约率
     *
     * @param st excel标识
     * @return 静态池集合
     */
    public void getLjwyl(BasicData st){
        //获取excel原始数据
        List<BasicData> list = getBasicData(st);

        //tolList中为原始数据+新增违约率
        List<BasicData> tolList = new LinkedList<BasicData>();

        BigDecimal xzdkje = null;  //新增贷款金额
        BigDecimal ljwyl = null;  //累计违约率
        BigDecimal xzwyl = null;  //新增违约率
        BigDecimal pjxzwyl = null;  //平均新增违约率
        BigDecimal pjljwyl = null;  //平均累计违约率
        BigDecimal qcwcbj = null;  //期初未尝本金
        BigDecimal qcwcbjzb = null;  //期初未尝本金占比
        Map<String,List<BigDecimal>> xzmap= new LinkedHashMap<String,List<BigDecimal>>();//新增违约率转置map
        Map<Integer,BigDecimal> pjxzmap = new LinkedHashMap<>();  //平均新增违约率map
        Map<Integer,BigDecimal> pjljmap = new LinkedHashMap<>();  //平均累计违约率map
        List<BigDecimal> pjxzlist = new LinkedList<>();  //平均新增违约率list
        List<BigDecimal> pjljlist = new LinkedList <>();  //平均累计违约率list
        List<BigDecimal> xzwyllist = new LinkedList<>();  //新增违约率list
        List<BigDecimal> ljwyllist = new LinkedList<>();  //累计违约率list
        int qcCount = st.getQcCount();
        //期次数据截取
        int startCut = 0;
        int endCut = qcCount;

        //新增违约率计算
        //
        for(int a=1;a<=qcCount;a++){
            xzwyllist = new LinkedList<>();
            List<BasicData> zqlist = list.subList(startCut, endCut);
            int qc = zqlist.size();  //每期循环次数
            startCut = endCut;
            endCut = (a+1)*qcCount-(a*(a+1)/2);
            //复位变量值
            pjxzwyl = null;
            xzwyl=null;
            ljwyl=null;
            //循环list
            for(int i=0;i<qc;i++){
                BasicData basicData = zqlist.get(i);
                if(null!=basicData.getXzdk()){
                    xzdkje = basicData.getXzdk();
                }
                if(null==basicData.getTq2()){
                    basicData.setTq2(new BigDecimal(0.00));
                }
                xzwyl = basicData.getTq2().divide(xzdkje,8,BigDecimal.ROUND_HALF_UP);
                basicData.setXzwyl(xzwyl);
                qcwcbj = basicData.getYmbjye().subtract(basicData.getTq2())
                        .subtract(basicData.getTq3())
                        .subtract(basicData.getTq4())
                        .subtract(basicData.getTq5())
                        .subtract(basicData.getTq6())
                        .subtract(basicData.getTq7());
                qcwcbjzb = qcwcbj.divide(xzdkje,8,BigDecimal.ROUND_HALF_UP);
                basicData.setQcwcbjzb(qcwcbjzb);
                if(null==ljwyl){
                    ljwyl = xzwyl;
                }else{
                    ljwyl = ljwyl.add(xzwyl);
                }
                basicData.setLjwyl(ljwyl);
                xzwyllist.add(xzwyl);
                tolList.add(basicData);
                if(i==qcCount){
                    qcCount -= 1;
                }
                if(1==a){
                    pjxzmap.put(i,xzwyl);
                }else{
                    pjljwyl = pjxzmap.get(i);
                    pjxzmap.put(i,pjljwyl.add(xzwyl));
                }
            }
            if(tolList.size()>=100){
                insertData(tolList);
                tolList.clear();
            }
            xzmap.put(String.valueOf(a),xzwyllist);
        }
        if(tolList.size()>0){
            insertData(tolList);
        }

        //平均新增违约率
        BigDecimal bigqc = new BigDecimal(qcCount);
        for(int i=0;i<qcCount;i++){
            BigDecimal times = new BigDecimal(i);
            pjxzlist.add(pjxzmap.get(i).divide(bigqc.subtract(times),8,BigDecimal.ROUND_HALF_UP));
        }

        //平均累计违约率
        ljwyl=null;
        for(BigDecimal xz:pjxzlist){
            if(null==ljwyl){
                ljwyl = xz;
            }else{
                ljwyl = ljwyl.add(xz);
            }
            pjljlist.add(ljwyl);
        }

        ljwyl = null;
        //累计违约率补全
        List<BasicData> tolList1 = new LinkedList<BasicData>();
        int startCut1 = 0;
        int endCut1 = qcCount;
        for(int i=1;i<=qcCount;i++){
            BasicData basicData = new BasicData();
            list = getBasicData(st);
            List<BasicData> zqlist = list.subList(startCut1, endCut1);
            int qc = zqlist.size();  //每期循环次数
            startCut1 = endCut1;
            endCut1 = (i+1)*qcCount-(i*(i+1)/2);
            //第一期无需补充
            if(1==i){
                for(BasicData stData :zqlist){
                    tolList1.add(stData);
                }
                continue;
            }
            //已有期次
            int yyqc = zqlist.size();
            for(int a=0;a<qcCount-yyqc;a++){
                basicData = new BasicData();
                basicData.setQcnum(yyqc+a+1);
                //i-i期平均累计违约率x1/i期平均累计违约率y1 = 第x放款日i-1期累计违约率x2/第x放款日i期累计违约率y2
                BigDecimal x1 = zqlist.get(yyqc+a-1).getLjwyl();
                BigDecimal x2 = pjljlist.get(yyqc-1+0);
                BigDecimal y2 = pjljlist.get(yyqc+0);
                if(x2.compareTo(BigDecimal.ZERO)!=0){
//                    System.out.println(x2);
                    ljwyl = (x1.multiply(y2)).divide(x2,8,BigDecimal.ROUND_HALF_UP);
                }else{
                    ljwyl = new BigDecimal(0);
                }
                System.out.println(ljwyl);
                basicData.setLjwyl(ljwyl);
                basicData.setDkffsj(zqlist.get(0).getDkffsj());
                basicData.setBgyf(zqlist.get(yyqc+a-1).getBgyf());
                basicData.setDelFlag("0");
                basicData.setSign(st.getSign());
                zqlist.add(basicData);
                zqlist = new LinkedList<>(zqlist);
            }
            for(BasicData data :zqlist){
                tolList1.add(data);
            }
//            System.out.println(tolList1.size());
        }


        //违约率补全入库（若分批入库则考虑list中排序问题）
        insertData(tolList1);
        List datalist = new ArrayList();
//        for(StBasicData data:tolList1){
//            datalist.add(data);
//            if(datalist.size()>=100){
//                insertData(datalist);
//                datalist = new ArrayList();
//            }
//        }
//        insertData(datalist);


        //获取excel原始数据
        ljwyl = null;
//        st.setQcnum(qcCount);
//        List<BasicData> bqlist = getBasicData(st);
        //累计违约率延伸
        List<DefaultRate> rateList = defaultRateMapper.selectDefaultRateList(null);
        //累计违约率map
        int bqnum = rateList.size();
        Map<Integer,BigDecimal> rateMap = new HashMap<Integer,BigDecimal>();
        for(DefaultRate rate : rateList){
            rateMap.put(rate.getQc(),rate.getLjwyl());
        }
        //延伸list
        List<BasicData> yslist = new LinkedList<BasicData>();

        if(qcCount>bqnum){
            System.out.println("无需补齐");;
        }else {
            //补齐数量
            for(int i=qcCount;i<bqnum+1;i++){
                st.setQcnum(i);
                List<BasicData> yylist = getBasicData(st);
                List<BasicData> bqlist = new LinkedList<BasicData>();
                for(int a=0;a<qcCount;a++){
                    BasicData basicData = new BasicData();
                    BigDecimal x1 = yylist.get(a).getLjwyl();
                    BigDecimal x2 = rateMap.get(qcCount-1);
                    BigDecimal y2 = rateMap.get(qcCount);
                    ljwyl = (x1.multiply(y2)).divide(x2,8,BigDecimal.ROUND_HALF_UP);
                    basicData.setQcnum(i+1);
                    basicData.setLjwyl(ljwyl);
                    basicData.setSign(st.getSign());
                    basicData.setDelFlag("0");
                    bqlist.add(basicData);
                }
//                System.out.println(bqlist);
                insertData(bqlist);
            }
        }


    }
}