package com.doumee.service.business.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DateUtil;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.*;
import com.doumee.dao.business.dto.*;
import com.doumee.dao.business.join.MultifileJoinMapper;
import com.doumee.dao.business.join.SettleClaimsJoinMapper;
import com.doumee.dao.business.join.SettleClaimsLogJoinMapper;
import com.doumee.dao.business.model.*;
import com.doumee.dao.business.vo.CompensationVO;
import com.doumee.dao.business.vo.RiskConfigVO;
import com.doumee.dao.business.vo.SettleClaimsMoneyVO;
import com.doumee.dao.business.vo.SettleParentStatusVO;
import com.doumee.dao.business.vo.dataBoard.DataListVO;
import com.doumee.dao.business.vo.dataBoard.SettleClaimsDataVO;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.SettleClaimsLogService;
import com.doumee.service.business.SettleClaimsService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.service.system.impl.SystemDictDataServiceImpl;
import com.github.xiaoymin.knife4j.core.util.CollectionUtils;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 理赔申请表Service实现
 * @author 江蹄蹄
 * @date 2024/01/16 10:03
 */
@Service
public class SettleClaimsServiceImpl implements SettleClaimsService {

    @Autowired
    private SettleClaimsMapper settleClaimsMapper;
    @Autowired
    private SettleClaimsExtMapper settleClaimsExtMapper;

    @Autowired
    private SettleClaimsLogMapper settleClaimsLogMapper;
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private MultifileJoinMapper multifileJoinMapper;

    @Autowired
    private SettleClaimsJoinMapper settleClaimsJoinMapper;

    @Autowired
    private SettleClaimsLogJoinMapper settleClaimsLogJoinMapper;

    @Autowired
    private NoticesMapper noticesMapper;

    @Autowired
    private InsuranceApplyMapper insuranceApplyMapper;

    @Autowired
    private SolutionsMapper solutionsMapper;

    @Autowired
    private SolutionsBaseMapper solutionsBaseMapper;

    @Autowired
    private ApplyDetailMapper applyDetailMapper;

    /**
     * 删除附件
     * @return
     */
    @Override
    public  Integer delFile(Integer id,Integer fileId){
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        return   multifileJoinMapper.update(null,new UpdateWrapper<Multifile>().lambda()
                .set(Multifile::getIsdeleted,Constants.ONE)
                .set(Multifile::getEditDate,new Date())
                .set(Multifile::getEditor,user.getId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .eq(Multifile::getObjId,id)
                .eq(Multifile::getId,fileId)
                .in(Multifile::getObjType,Arrays.asList(new Integer[]{
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey(),
                        Constants.MultiFile.LP_JACL_FILE.getKey(),
                })));
    }
    @Override
    public      Integer back(SettleClaims  param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }

        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }

        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        update.setStatus(Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey());
        settleClaimsMapper.updateById(update);


        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,model.getId()));

        Notices notices = new Notices(noticeObjectType,Constants.ONE,model.getId(),model.getInformantName(),
                model.getCompanyId(), Constants.NoticeType.FOUR);
        noticesMapper.insert(notices);


        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_RETURN;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 资料确认
     * @param param
     * @return
     */
    @Override
    public      Integer confirm(SettleClaims  param){
        if(param.getId() == null ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }

        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        update.setStatus(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey());
        settleClaimsMapper.updateById(update);


        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,model.getId()));

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_CONFIRM_INFORMATION;
        String info =applyLogType.getInfo();
//        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 理赔备注标签
     * @param param
     * @return
     */
    @Override
    public       Integer remark(SettleClaims param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
     /*   if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
*/
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo("添加备注标签");
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_REMARK;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", param.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 理赔结案提交
     * @param param
     * @return
     */
    @Override
    public    Integer doneCommit(SettleClaims param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //受理中和已确认资料可以进行理赔处理
        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
              ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }

        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setStatus(Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey());
        update.setId(model.getId());
        update.setYlClaimAccount(Constants.formatBigdecimal(param.getYlClaimAccount()));
        update.setSwClaimAccount(Constants.formatBigdecimal(param.getSwClaimAccount()));
        update.setWgClaimAccount(Constants.formatBigdecimal(param.getWgClaimAccount()));
        update.setScClaimAccount(Constants.formatBigdecimal(param.getScClaimAccount()));
        update.setClaimAccount(update.getYlClaimAccount().add(update.getSwClaimAccount()).add(update.getScClaimAccount()).add(update.getWgClaimAccount()));
        settleClaimsMapper.updateById(update);

        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,model.getId()));
        Notices notices = new Notices(noticeObjectType,Constants.ONE,model.getId(),model.getInformantName(),
                model.getCompanyId(), Constants.NoticeType.ONE);
        noticesMapper.insert(notices);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_FINISH;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 理赔处理
     * @param param
     * @return
     */
    @Override
    public Integer dealBiz(SettleClaims  param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getCheckInfo()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //受理中和已确认资料可以进行理赔处理
        if( Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey())
              ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo(param.getCheckInfo());
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_LP_DEAL;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getCheckInfo());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }
    /**
     * 添加备案号
     * @param param
     * @return
     */
    @Override
    public Integer addCode(SettleClaims param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getReportNum()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }

        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey()))){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo("添加备案号");
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        update.setStatus(Constants.SettleClaimsStatus.DEAL_ING.getKey());
        update.setReportNum(param.getReportNum());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_ADDCODE;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getReportNum());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public Integer createOrEditSys(SettleClaims settleClaims) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        settleClaims.setOrigin(Constants.ONE);
        if(Objects.isNull(settleClaims)
                || Objects.isNull(settleClaims.getExtData())
                || Objects.isNull(settleClaims.getExtData().getMemberName())
                || Objects.isNull(settleClaims.getExtData().getMemberIdcardType())
                || Objects.isNull(settleClaims.getExtData().getMemberIdcard())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!Constants.equalsObject(settleClaims.getStatus(),Constants.ZERO)
                &&(  Objects.isNull(settleClaims.getExtData().getBxName())
                || Objects.isNull(settleClaims.getExtData().getReportDate())
                || Objects.isNull(settleClaims.getExtData().getBxCode())
                || Objects.isNull(settleClaims.getExtData().getBxEnddate())
                || Objects.isNull(settleClaims.getExtData().getBxOrg())
                || Objects.isNull(settleClaims.getInformantPhone()) )){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!Constants.equalsInteger(loginUserInfo.getType(),Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非平台管理员无法进行该操作");
        }
        Date date =new Date();
        settleClaims.setEditDate(date);
        settleClaims.setEditor(loginUserInfo.getId());

        List<CompensationVO> feeList = settleClaims.getAccountList();
        BigDecimal mainFee = new BigDecimal(0);
        BigDecimal ortherFee = new BigDecimal(0);
        if(feeList!=null && feeList.size()>0){
            for(CompensationVO fee : feeList){
                if(Constants.equalsObject(fee.getType(),Constants.ZERO)){
                    mainFee = mainFee.add(Constants.formatBigdecimal(fee.getFee()));
                }else{
                    ortherFee = ortherFee.add(Constants.formatBigdecimal(fee.getFee()));
                }
            }
            settleClaims.setHpAccountContent(JSONObject.toJSONString(feeList));
            settleClaims.setHpAccount(mainFee);
            settleClaims.setHpOtherAccount(ortherFee);
        }
        if(settleClaims.getId() ==null){
            //如果是新增记录
            dealCreateSysBiz(settleClaims,date,loginUserInfo);
        }else{
            //如果更新
            dealUpdateSysBiz(settleClaims,date,loginUserInfo);
        }
        return  settleClaims.getId();
    }

    private void dealUpdateSysBiz(SettleClaims settleClaims, Date date, LoginUserInfo loginUserInfo) {
        SettleClaims model = settleClaimsMapper.selectById(settleClaims.getId());
        if(model ==null){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        settleClaimsMapper.updateById(settleClaims);
        //删除原来的扩展属性信息，保留最新的
        settleClaimsExtMapper.delete(new UpdateWrapper<SettleClaimsExt>().lambda().eq(SettleClaimsExt::getSettileClaimsId,model.getId()));
        settleClaims.getExtData().setCreator(settleClaims.getCreator());
        settleClaims.getExtData().setCreateDate(date);
        settleClaims.getExtData().setEditor(settleClaims.getCreator());
        settleClaims.getExtData().setEditDate(date);
        settleClaims.getExtData().setIsdeleted(Constants.ZERO);
        settleClaims.getExtData().setSettileClaimsId(settleClaims.getId());
        settleClaimsExtMapper.insert(settleClaims.getExtData());
        //处理附件开始
        multifileJoinMapper.update(null,new UpdateWrapper<Multifile>().lambda()
                .set(Multifile::getIsdeleted,Constants.ONE)
                .eq(Multifile::getObjId,model.getId())
                .in(Multifile::getObjType
                        ,Constants.MultiFile.LP_YGGX_FILE.getKey()
                        ,Constants.MultiFile.LP_ZYCL_FILE.getKey()
                        ,Constants.MultiFile.LP_MZCL_FILE.getKey()
                        ,Constants.MultiFile.LP_OTHER_FILE.getKey()
                        ,Constants.MultiFile.LP_SCZL_FILE.getKey()
                        ,Constants.MultiFile.LP_SGXC_FILE.getKey()
                        ,Constants.MultiFile.LP_DZBD_FILE.getKey()
                )

        );
        dealSysFileListBiz(settleClaims);
    }

    private void dealCreateSysBiz(SettleClaims settleClaims,Date date,LoginUserInfo loginUserInfo) {
        settleClaims.setCreateDate(date);
        settleClaims.setIsdeleted(Constants.ZERO);
        settleClaims.setCreator(loginUserInfo.getId());

        settleClaimsMapper.insert(settleClaims);
        settleClaims.getExtData().setCreator(settleClaims.getCreator());
        settleClaims.getExtData().setCreateDate(date);
        settleClaims.getExtData().setEditor(settleClaims.getCreator());
        settleClaims.getExtData().setEditDate(date);
        settleClaims.getExtData().setIsdeleted(Constants.ZERO);
        settleClaims.getExtData().setSettileClaimsId(settleClaims.getId());
        settleClaimsExtMapper.insert(settleClaims.getExtData());
        //处理附件开始
        dealSysFileListBiz(settleClaims);
    }

    /**
     * 处理附件开始
     * @param settleClaims
     */

    private void dealSysFileListBiz(SettleClaims settleClaims) {
        List<Multifile> relationFileList = settleClaims.getRelationFileList();//员工关系材料
        List<Multifile> hospitalFileList = settleClaims.getHospitalFileList();//住院材料
        List<Multifile> outpatientFileList = settleClaims.getOutpatientFileList();//门诊材料
        List<Multifile> otherFileList = settleClaims.getOtherFileList();//其他材料
        List<Multifile> disabilityFileList = settleClaims.getDisabilityFileList();//伤残材料
        List<Multifile> dzbdFileList = settleClaims.getDzbdFileList();//电子保单
        List<Multifile> reportFileList = settleClaims.getReportFileList();//报案视频
        List<Multifile> insetList = new ArrayList<>();
        insetList.addAll(getMultifileListByObjtype(relationFileList,Constants.MultiFile.LP_YGGX_FILE.getKey(),settleClaims));
        insetList.addAll(getMultifileListByObjtype(hospitalFileList,Constants.MultiFile.LP_ZYCL_FILE.getKey(),settleClaims));
        insetList.addAll(getMultifileListByObjtype(outpatientFileList,Constants.MultiFile.LP_MZCL_FILE.getKey(),settleClaims));
        insetList.addAll(getMultifileListByObjtype(otherFileList,Constants.MultiFile.LP_OTHER_FILE.getKey(),settleClaims));
        insetList.addAll(getMultifileListByObjtype(disabilityFileList,Constants.MultiFile.LP_SCZL_FILE.getKey(),settleClaims));
        insetList.addAll(getMultifileListByObjtype(dzbdFileList,Constants.MultiFile.LP_DZBD_FILE.getKey(),settleClaims));
        insetList.addAll(getMultifileListByObjtype(reportFileList,Constants.MultiFile.LP_SGXC_FILE.getKey(),settleClaims));
        if(CollectionUtils.isNotEmpty(insetList)){
                multifileJoinMapper.insert(insetList);
        }
        //--------------处理附件结束----------------
    }

    private Collection<? extends Multifile> getMultifileListByObjtype(List<Multifile> list, int key,SettleClaims model) {
        List<Multifile> insetList = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(list)){
            int index = 0;
            for (int i = 0; i < list.size(); i++) {
                Multifile multifile = list.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())  ){
                    continue;
                }
                multifile.setId(null);
                multifile.setCreator(model.getEditor());
                multifile.setCreateDate(model.getEditDate());
                multifile.setEditor(model.getEditor());
                multifile.setEditDate(model.getEditDate());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(model.getId());
                multifile.setObjType(key);
                multifile.setSortnum(index++);
                insetList.add(multifile);
            }
        }
        return insetList;
    }

    @Override
    public Integer create(SettleClaims settleClaims) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(settleClaims)
                || Objects.isNull(settleClaims.getMemberId())
                || Objects.isNull(settleClaims.getSolutionId())
                || Objects.isNull(settleClaims.getDuId())
                || Objects.isNull(settleClaims.getWorktypeId())
                || Objects.isNull(settleClaims.getHappenTime())
                || Objects.isNull(settleClaims.getType())
                || Objects.isNull(settleClaims.getInHospital())
                || Objects.isNull(settleClaims.getMedicalInsurance())
                || Objects.isNull(settleClaims.getContent())
                || Objects.isNull(settleClaims.getInformantName())
                || Objects.isNull(settleClaims.getInformantPhone())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        //查询是否存在已提报的数据  根据人员和保险方案进行过滤 是否存在进行中的数据
        if(settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getSolutionId,settleClaims.getSolutionId())
                .eq(SettleClaims::getMemberId,loginUserInfo.getId())
                .in(SettleClaims::getStatus,Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey(),
                        Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())
        )>Constants.ZERO){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"存在提报中的报案数据!");
        }

        settleClaims.setCreateDate(new Date());
        settleClaims.setIsdeleted(Constants.ZERO);
        settleClaims.setCompanyId(loginUserInfo.getCompanyId());
        settleClaims.setStatus(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey());
        settleClaims.setCreator(loginUserInfo.getId());
        settleClaims.setCheckUserId(loginUserInfo.getId());
        settleClaimsMapper.insert(settleClaims);

        List<Multifile> reportVideo = settleClaims.getReportFileList();
        if(CollectionUtils.isNotEmpty(reportVideo)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.ONE);
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }
        //记录日志
        this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.UPLOAD,null,null);
        //存储待办信息
        Constants.NoticeObjectType noticeObjectType = Constants.NoticeObjectType.SETTLE_CLAIMS;
        //删除其他待办
        noticesMapper.delete(new QueryWrapper<Notices>().lambda().eq(Notices::getObjType,noticeObjectType.getKey()).eq(Notices::getObjId,settleClaims.getId()));
        Notices notices = new Notices(noticeObjectType,Constants.ZERO,settleClaims.getId(),settleClaims.getInformantName(),
                settleClaims.getCompanyId(), Constants.NoticeType.ZERO);
        noticesMapper.insert(notices);


        return settleClaims.getId();
    }

    @Override
    public  void exportFiles(Integer id, HttpServletResponse response) {
        try {
            SettleClaims model = settleClaimsMapper.selectById(id);
            if(model == null){
                throw  new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
            SettleClaims update = new SettleClaims();
            update.setEditDate(new Date());
            update.setEditor(loginUserInfo.getId());
            Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_DOWNLOAD;
            String info =applyLogType.getInfo();
            SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
            settleClaimsLogMapper.insert(log);

            List<File> fileList = new ArrayList<>();
            List<Multifile> multifileList = multifileJoinMapper.selectList(new QueryWrapper<Multifile>().lambda()
                    .eq(Multifile::getIsdeleted,Constants.ZERO)
                    .eq(Multifile::getObjId,id)
                    .isNotNull(Multifile::getFileurl)
                    .in(Multifile::getObjType, Arrays.asList(new Integer[]{
                            Constants.MultiFile.LP_YGGX_FILE.getKey(),
                            Constants.MultiFile.LP_MZCL_FILE.getKey(),
                            Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                            Constants.MultiFile.LP_SCZL_FILE.getKey(),
                            Constants.MultiFile.LP_JACL_FILE.getKey(),
                    }))
                    .orderByAsc(Multifile::getCreateDate)
            );
            if(multifileList== null || multifileList.size() == 0){
                throw  new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            String path = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode()+systemDictDataBiz.queryByCode(Constants.OSS,Constants.SETTLE_FILE).getCode();
            Integer sn = 1;
            for(Multifile l : multifileList){
                File f = Constants.getFileByNetFile(path + l.getFileurl(),StringUtils.defaultString(sn + "_" +l.getName(),"未命名"));
                if(f !=null && f.isFile()){
                    fileList.add(f);
                }
                sn = sn +1;
            }
            if(fileList == null || fileList.size() == 0){
                throw  new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            String fileName =  model.getInformantName() +"-理赔资料-" +System.currentTimeMillis();
            String encodeFileName =URLEncoder.encode(fileName, Charset.forName("UTF-8").toString())+".zip";
            response.setHeader("Content-Disposition","attachment;filename=" + encodeFileName);
            response.setContentType("application/octet-stream");
            response.setHeader("eva-opera-type", "download");
            response.setHeader("eva-download-filename", encodeFileName);
            Constants.packFilesToZip(fileList,response.getOutputStream());
        } catch (Exception e) {
            throw new BusinessException(ResponseStatus.EXPORT_EXCEL_ERROR, e);
        }
    }

    @Override
    public SettleClaims getSettleClaimsDetail(Integer id){

        MPJLambdaWrapper<SettleClaims>  queryWrapper =    new MPJLambdaWrapper<SettleClaims>();
        queryWrapper.selectAll(SettleClaims.class)
                .selectAs(Company::getName,SettleClaims::getCompanyName)
                .selectAs(Solutions::getName,SettleClaims::getSolutionName)
                .selectAs(Member::getName,SettleClaims::getMemberName)
                .selectAs(Member::getIdcardNo,SettleClaims::getMemberIdcardNo)
                .selectAs(InsuranceApply::getCode,SettleClaims::getApplyCode)
                .selectAs(Worktype::getName,SettleClaims::getWorktypeName)
                .selectAs(InsuranceApply::getStartTime,SettleClaims::getBaoxianStartTime)
                .selectAs(InsuranceApply::getEndTime,SettleClaims::getBaoxianEndTime)
                .selectAs(DispatchUnit::getName,SettleClaims::getDuName)
                .leftJoin(Company.class,Company::getId,SettleClaims::getCompanyId)
                .leftJoin(Member.class,Member::getId,SettleClaims::getMemberId)
                .leftJoin(DispatchUnit.class,DispatchUnit::getId,SettleClaims::getDuId)
                .leftJoin(Worktype.class,Worktype::getId,SettleClaims::getWorktypeId)
                .leftJoin(InsuranceApply.class,InsuranceApply::getId,SettleClaims::getInsuranceApplyId)
                .leftJoin(Solutions.class,Solutions::getId,SettleClaims::getSolutionId)
                .eq(SettleClaims::getId,id);
        SettleClaims settleClaims = settleClaimsJoinMapper.selectJoinOne(SettleClaims.class,queryWrapper);
        if(settleClaims == null){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        List<Multifile> multifileList = multifileJoinMapper.selectJoinList(Multifile.class,
                new MPJLambdaWrapper<Multifile>()
                .selectAll(Multifile.class)
                .selectAs(SystemUser::getRealname,Multifile::getCreatorName)
                .leftJoin(SystemUser.class,SystemUser::getId,Multifile::getCreator)
                .eq(Multifile::getObjId,id)
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .orderByAsc(Multifile::getCreateDate)
        );
        String rPath = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode();
        String path = rPath+ systemDictDataBiz.queryByCode(Constants.OSS,Constants.SETTLE_FILE).getCode();
        if(multifileList!=null){
            for(Multifile f : multifileList){
                if(f!=null&& StringUtils.isNotBlank(f.getFileurl())){
                    f.setFileurlFull(path+f.getFileurl());
                }
            }
        }
        Multifile baoxiandanFile = multifileJoinMapper.selectOne(new QueryWrapper<Multifile>()
                .lambda().eq(Multifile::getObjId,settleClaims.getInsuranceApplyId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .eq(Multifile::getObjType,Constants.MultiFile.BD_DONE_PDF.getKey())
                .last("limit 1"));
        if(baoxiandanFile!=null&& StringUtils.isNotBlank(baoxiandanFile.getFileurl())){
            path = rPath+ systemDictDataBiz.queryByCode(Constants.OSS,Constants.APPLY_FILE).getCode();
            baoxiandanFile.setFileurlFull(path+baoxiandanFile.getFileurl());
        }
        settleClaims.setBaoxiandanFile(baoxiandanFile);//保险单
        if(CollectionUtils.isNotEmpty(multifileList)){
            settleClaims.setReportFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SGXC_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setRelationFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_YGGX_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setOutpatientFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_MZCL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setHospitalFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_ZYCL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setDisabilityFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SCZL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setCompensationFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_JACL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setOtherFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_OTHER_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setPayFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_PAY_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setDzbdFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_DZBD_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setSupplementFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SUPPLEMENT_FILE.getKey())).collect(Collectors.toList()));
        }

        //查询操作记录
        List<SettleClaimsLog> settleClaimsLogList = settleClaimsLogJoinMapper.selectJoinList(SettleClaimsLog.class,
                new MPJLambdaWrapper<SettleClaimsLog>()
                        .selectAll(SettleClaimsLog.class)
                        .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                        .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                        .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                        .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                        .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                        .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                        .orderByAsc(SettleClaimsLog::getCreateDate)
        );
        settleClaims.setSettleClaimsLogList(settleClaimsLogList);
        SettleClaimsLog lastConfirm = settleClaimsLogMapper.selectOne(new QueryWrapper<SettleClaimsLog>().lambda()
                .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                .eq(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_CONFIRM_INFORMATION.getKey())
                .orderByDesc(SettleClaimsLog::getCreateDate)
                .last(" limit 1")
        );

        Multifile multifile = multifileJoinMapper.selectOne(new QueryWrapper<Multifile>()
                .lambda()
                .eq(Multifile::getObjId,settleClaims.getId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .in(Multifile::getObjType,
                        Constants.MultiFile.LP_SGXC_FILE.getKey(),
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey(),
                        Constants.MultiFile.LP_JACL_FILE.getKey())
                .orderByDesc(Multifile::getCreateDate)
                .last(" limit 1")
        );

        if(!Objects.isNull(lastConfirm)&&!Objects.isNull(multifile)){
            settleClaims.setFinishDate(lastConfirm.getCreateDate().compareTo(multifile.getCreateDate())>=0?lastConfirm.getCreateDate():multifile.getCreateDate());
        }else if(!Objects.isNull(lastConfirm)&&Objects.isNull(multifile)){
            settleClaims.setFinishDate(lastConfirm.getCreateDate());
        }
        List<SettleParentStatusVO> parentStatusVOList = this.getParentStatus(settleClaims);
        settleClaims.setParentStatusVOList(parentStatusVOList);
        settleClaims.setStatusName(Constants.SettleClaimsStatus.getName(settleClaims.getStatus()));

        if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.REJECT_DEAL.getKey())
            || Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.WAIT_DISCUSS_REJECT.getKey())){
            SettleClaimsLog settleClaimsLog = settleClaimsLogJoinMapper.selectJoinOne(SettleClaimsLog.class,
                    new MPJLambdaWrapper<SettleClaimsLog>()
                            .selectAll(SettleClaimsLog.class)
                            .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                            .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                            .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                            .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                            .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                            .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                            .in(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_DISCUSS_REFUSE.getKey(),
                            Constants.SettleClaimsLogType.PLATFORM_REFUSE_ACCEPTANCE.getKey())
                    .orderByDesc(SettleClaimsLog::getCreateDate)
                    .last(" limit 1")
            );
            settleClaims.setRefuseSettleClaimsLog(settleClaimsLog);
        }else if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())){
            SettleClaimsLog settleClaimsLog = settleClaimsLogJoinMapper.selectJoinOne(SettleClaimsLog.class,
                    new MPJLambdaWrapper<SettleClaimsLog>()
                            .selectAll(SettleClaimsLog.class)
                            .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                            .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                            .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                            .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                            .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                            .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                            .in(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_RETURN.getKey())
                            .orderByDesc(SettleClaimsLog::getCreateDate)
                            .last(" limit 1")
            );
            settleClaims.setRefuseSettleClaimsLog(settleClaimsLog);
        }else if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
                &&Constants.equalsInteger(settleClaims.getWaitSupplement(),Constants.ONE)
        ){
            SettleClaimsLog settleClaimsLog = settleClaimsLogJoinMapper.selectJoinOne(SettleClaimsLog.class,
                    new MPJLambdaWrapper<SettleClaimsLog>()
                            .selectAll(SettleClaimsLog.class)
                            .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                            .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                            .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                            .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                            .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                            .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                            .in(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.SUPPLEMENT_DESCRIBE.getKey())
                            .orderByDesc(SettleClaimsLog::getCreateDate)
                            .last(" limit 1")
            );
            settleClaims.setRefuseSettleClaimsLog(settleClaimsLog);
        }else if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.CLOSE_CASE.getKey())){
            SettleClaimsLog settleClaimsLog = settleClaimsLogJoinMapper.selectJoinOne(SettleClaimsLog.class,
                    new MPJLambdaWrapper<SettleClaimsLog>()
                            .selectAll(SettleClaimsLog.class)
                            .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                            .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                            .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                            .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                            .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                            .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                            .in(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_FINISH.getKey())
                            .orderByDesc(SettleClaimsLog::getCreateDate)
                            .last(" limit 1")
            );
            settleClaims.setRefuseSettleClaimsLog(settleClaimsLog);
        }

        if((Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
                || Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey()))
        && Constants.equalsInteger(settleClaims.getWaitSupplement(),Constants.ONE)){
            SettleClaimsLog settleClaimsLog = settleClaimsLogJoinMapper.selectJoinOne(SettleClaimsLog.class,
                    new MPJLambdaWrapper<SettleClaimsLog>()
                            .selectAll(SettleClaimsLog.class)
                            .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                            .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                            .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                            .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                            .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                            .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                            .in(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.SUPPLEMENT_DESCRIBE.getKey())
                            .orderByDesc(SettleClaimsLog::getCreateDate)
                            .last(" limit 1")
            );
            settleClaims.setSupplementSettleClaimsLog(settleClaimsLog);
        }



        return settleClaims;
    }


    @Override
    public SettleClaims getSettleClaimsDetailForSd(Integer id){
        MPJLambdaWrapper<SettleClaims>  queryWrapper =    new MPJLambdaWrapper<SettleClaims>();
        queryWrapper.selectAll(SettleClaims.class)
                .selectAs(SettleClaimsExt::getBxOrg,SettleClaims::getCompanyName)
                .selectAs(SettleClaimsExt::getBxName,SettleClaims::getSolutionName)
                .selectAs(SettleClaimsExt::getMemberName,SettleClaims::getMemberName)
                .selectAs(SettleClaimsExt::getMemberIdcard,SettleClaims::getMemberIdcardNo)
                .selectAs(SettleClaimsExt::getBxStartdate,SettleClaims::getBaoxianStartTime)
                .selectAs(SettleClaimsExt::getBxEnddate,SettleClaims::getBaoxianEndTime)
                .selectAs(SettleClaimsExt::getBxCode,SettleClaims::getApplyCode)
                .innerJoin(SettleClaimsExt.class,SettleClaimsExt::getSettileClaimsId,SettleClaims::getId)
                .eq(SettleClaims::getId,id);
        SettleClaims settleClaims = settleClaimsJoinMapper.selectJoinOne(SettleClaims.class,queryWrapper);
        if(settleClaims == null){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(StringUtils.isNotBlank(settleClaims.getHpAccountContent())){
            settleClaims.setAccountList(JSONArray.parseArray(settleClaims.getHpAccountContent(),CompensationVO.class ));
        }
        List<Multifile> multifileList = multifileJoinMapper.selectJoinList(Multifile.class,
                new MPJLambdaWrapper<Multifile>()
                        .selectAll(Multifile.class)
                        .selectAs(SystemUser::getRealname,Multifile::getCreatorName)
                        .leftJoin(SystemUser.class,SystemUser::getId,Multifile::getCreator)
                        .eq(Multifile::getObjId,id)
                        .eq(Multifile::getIsdeleted,Constants.ZERO)
                        .orderByAsc(Multifile::getCreateDate)
        );
        String rPath = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode();
        String path = rPath+ systemDictDataBiz.queryByCode(Constants.OSS,Constants.SETTLE_FILE).getCode();
        if(multifileList!=null){
            for(Multifile f : multifileList){
                if(f!=null&& StringUtils.isNotBlank(f.getFileurl())){
                    f.setFileurlFull(path+f.getFileurl());
                }
            }
        }
        Multifile baoxiandanFile = multifileJoinMapper.selectOne(new QueryWrapper<Multifile>()
                .lambda().eq(Multifile::getObjId,settleClaims.getInsuranceApplyId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .eq(Multifile::getObjType,Constants.MultiFile.BD_DONE_PDF.getKey())
                .last("limit 1"));
        if(baoxiandanFile!=null&& StringUtils.isNotBlank(baoxiandanFile.getFileurl())){
            path = rPath+ systemDictDataBiz.queryByCode(Constants.OSS,Constants.APPLY_FILE).getCode();
            baoxiandanFile.setFileurlFull(path+baoxiandanFile.getFileurl());
        }
        settleClaims.setBaoxiandanFile(baoxiandanFile);//保险单
        if(CollectionUtils.isNotEmpty(multifileList)){
            settleClaims.setReportFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SGXC_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setRelationFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_YGGX_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setOutpatientFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_MZCL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setHospitalFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_ZYCL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setDisabilityFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_SCZL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setCompensationFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_JACL_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setOtherFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_OTHER_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setPayFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_PAY_FILE.getKey())).collect(Collectors.toList()));

            settleClaims.setDzbdFileList(multifileList.stream().filter(m->m.getObjType().equals(Constants.MultiFile.LP_DZBD_FILE.getKey())).collect(Collectors.toList()));

        }

        //查询操作记录
        List<SettleClaimsLog> settleClaimsLogList = settleClaimsLogJoinMapper.selectJoinList(SettleClaimsLog.class,
                new MPJLambdaWrapper<SettleClaimsLog>()
                        .selectAll(SettleClaimsLog.class)
                        .selectAs(SystemUser::getRealname,SettleClaimsLog::getCreatorName)
                        .selectAs(SystemUser::getType,SettleClaimsLog::getCreatorType)
                        .selectAs(Company::getName,SettleClaimsLog::getCompanyName)
                        .leftJoin(SystemUser.class,SystemUser::getId,SettleClaimsLog::getCreator)
                        .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                        .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                        .orderByAsc(SettleClaimsLog::getCreateDate)
        );
        settleClaims.setSettleClaimsLogList(settleClaimsLogList);
        SettleClaimsLog lastConfirm = settleClaimsLogMapper.selectOne(new QueryWrapper<SettleClaimsLog>().lambda()
                .eq(SettleClaimsLog::getSettleClainmsId,settleClaims.getId())
                .eq(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_CONFIRM_INFORMATION.getKey())
                .orderByDesc(SettleClaimsLog::getCreateDate)
                .last(" limit 1")
        );

        Multifile multifile = multifileJoinMapper.selectOne(new QueryWrapper<Multifile>()
                .lambda()
                .eq(Multifile::getObjId,settleClaims.getId())
                .eq(Multifile::getIsdeleted,Constants.ZERO)
                .in(Multifile::getObjType,
                        Constants.MultiFile.LP_SGXC_FILE.getKey(),
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey(),
                        Constants.MultiFile.LP_JACL_FILE.getKey())
                .orderByDesc(Multifile::getCreateDate)
                .last(" limit 1")
        );

        if(!Objects.isNull(lastConfirm)&&!Objects.isNull(multifile)){
            settleClaims.setFinishDate(lastConfirm.getCreateDate().compareTo(multifile.getCreateDate())>=0?lastConfirm.getCreateDate():multifile.getCreateDate());
        }else if(!Objects.isNull(lastConfirm)&&Objects.isNull(multifile)){
            settleClaims.setFinishDate(lastConfirm.getCreateDate());
        }
        if(Constants.equalsObject(settleClaims.getOrigin(),Constants.ONE)){
            settleClaims.setExtData(settleClaimsExtMapper.selectOne(new LambdaQueryWrapper<SettleClaimsExt>()
                    .eq(SettleClaimsExt::getIsdeleted,Constants.ZERO)
                    .eq(SettleClaimsExt::getSettileClaimsId,settleClaims.getId())
                    .last("limit 1")));
        }
        settleClaims.setExtData(settleClaimsExtMapper.selectOne(new QueryWrapper<SettleClaimsExt>().lambda().eq(SettleClaimsExt::getSettileClaimsId,id).last("limit 1")));
        settleClaims.setStatusName(Constants.SettleClaimsStatus.getName(settleClaims.getStatus()));
        return settleClaims;
    }



    @Override
    public Integer updateForCompany(SettleClaims settleClaims) {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(settleClaims)
                || Objects.isNull(settleClaims.getId())
                || Objects.isNull(settleClaims.getMemberId())
                || Objects.isNull(settleClaims.getSolutionId())
                || Objects.isNull(settleClaims.getDuId())
                || Objects.isNull(settleClaims.getWorktypeId())
                || Objects.isNull(settleClaims.getType())
                || Objects.isNull(settleClaims.getInHospital())
                || Objects.isNull(settleClaims.getMedicalInsurance())
                || Objects.isNull(settleClaims.getInformantName())
                || Objects.isNull(settleClaims.getInformantPhone())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        SettleClaims oldSettleClaims  = settleClaimsMapper.selectById(settleClaims.getId());
        if(Objects.isNull(oldSettleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到修改数据");
        }
        if(!oldSettleClaims.getSolutionId().equals(settleClaims.getSolutionId())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"无法修改方案信息");
        }
        if(!(oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                || oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.DEAL_ING.getKey())
                || oldSettleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前状态无法进行该操作");
        }
        oldSettleClaims.setEditor(loginUserInfo.getId());
        oldSettleClaims.setEditDate(new Date());
        oldSettleClaims.setDuId(settleClaims.getDuId());
        oldSettleClaims.setWorktypeId(settleClaims.getWorktypeId());
        oldSettleClaims.setInHospital(settleClaims.getInHospital());
        oldSettleClaims.setMedicalInsurance(settleClaims.getMedicalInsurance());
        oldSettleClaims.setAreaId(settleClaims.getAreaId());
        oldSettleClaims.setAreaInfo(settleClaims.getAreaInfo());
        oldSettleClaims.setType(settleClaims.getType());
        oldSettleClaims.setInformantName(settleClaims.getInformantName());
        oldSettleClaims.setInformantPhone(settleClaims.getInformantPhone());
        oldSettleClaims.setCheckUserId(loginUserInfo.getId());
        settleClaimsMapper.updateById(oldSettleClaims);
        //记录日志
        Constants.SettleClaimsLogType settleClaimsLogType =  Constants.SettleClaimsLogType.UPDATE_DATA;
        this.saveSettleClaimsLog(settleClaims,settleClaimsLogType,null,null);
        return oldSettleClaims.getId();
    }

    @Override
    public void supplement(SCSupplementDTO scSupplementDTO){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(scSupplementDTO)
                || Objects.isNull(scSupplementDTO.getId())
                || Objects.isNull(scSupplementDTO.getSupplement())
                || Objects.isNull(scSupplementDTO.getObjType())
                || !(scSupplementDTO.getObjType().equals(Constants.ZERO))
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsMapper.selectById(scSupplementDTO.getId());
        if(!(settleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.DEAL_ING.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前状态无法进行该操作");
        }
        settleClaims.setEditor(loginUserInfo.getId());
        settleClaims.setEditDate(new Date());
        settleClaims.setCheckUserId(loginUserInfo.getId());
        settleClaims.setCheckInfo(scSupplementDTO.getSupplement());
        settleClaimsMapper.updateById(settleClaims);

        Constants.SettleClaimsLogType settleClaimsLogType =  Constants.SettleClaimsLogType.SUPPLEMENT;
        String content = settleClaimsLogType.getInfo().replace("${param}", scSupplementDTO.getSupplement());
        this.saveSettleClaimsLog(settleClaims,settleClaimsLogType,content,null);
    }




    @Override
    public void claimsUploadFile(SCSupplementDTO scSupplementDTO){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(Objects.isNull(scSupplementDTO)
                || Objects.isNull(scSupplementDTO.getId())
                || Objects.isNull(scSupplementDTO.getObjType())
                || Objects.isNull(scSupplementDTO.getFileUrl())
                || Objects.isNull(scSupplementDTO.getFileType())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims settleClaims  = settleClaimsMapper.selectById(scSupplementDTO.getId());
        if(!(settleClaims.getStatus().equals(Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.DEAL_ING.getKey())
                || settleClaims.getStatus().equals(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前状态无法进行该操作");
        }
        Multifile multifile = new Multifile();
        if(loginUserInfo.getType().equals(Constants.ONE)){
            multifile.setCompanyId(loginUserInfo.getCompanyId());
        }
        multifile.setCreator(loginUserInfo.getId());
        multifile.setCreateDate(new Date());
        multifile.setIsdeleted(Constants.ZERO);
        multifile.setObjType(scSupplementDTO.getObjType());
        multifile.setObjId(scSupplementDTO.getId());
        multifile.setFileurl(scSupplementDTO.getFileUrl());
        multifile.setName(scSupplementDTO.getFileName());
        multifile.setType(scSupplementDTO.getFileType());
        multifileJoinMapper.insert(multifile);
    }




    public void saveSettleClaimsLog(SettleClaims settleClaims, Constants.SettleClaimsLogType settleClaimsLogType, String content,Constants.SettleClaimsStatus settleClaimsStatus){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal(); 
        SettleClaimsLog settleClaimsLog = new SettleClaimsLog();
        settleClaimsLog.setCreateDate(new Date());
        settleClaimsLog.setCreator(loginUserInfo.getId());
        settleClaimsLog.setIsdeleted(Constants.ZERO);
        settleClaimsLog.setSettleClainmsId(settleClaims.getId());
        settleClaimsLog.setTitle(settleClaimsLogType.getName());
        settleClaimsLog.setContent(content);
        settleClaimsLog.setObjType(settleClaimsLogType.getKey());
        settleClaimsLog.setObjId(settleClaims.getId());
        if(Objects.nonNull(settleClaimsStatus)){
            settleClaimsLog.setParentStatus(settleClaimsStatus.getParentKey());
            settleClaimsLog.setStatus(settleClaimsStatus.getKey());
        }
        settleClaimsLogMapper.insert(settleClaimsLog);
    }

    @Override
    public void deleteById(Integer id) {
        settleClaimsMapper.update(new UpdateWrapper<SettleClaims>().lambda().set(SettleClaims::getIsdeleted,Constants.ONE).eq(SettleClaims::getId,id));
    }

    @Override
    public void delete(SettleClaims settleClaims) {
        UpdateWrapper<SettleClaims> deleteWrapper = new UpdateWrapper<>(settleClaims);
        settleClaimsMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        settleClaimsMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(SettleClaims settleClaims) {
        settleClaimsMapper.updateById(settleClaims);
    }

    @Override
    public void updateByIdInBatch(List<SettleClaims> settleClaimss) {
        if (CollectionUtils.isEmpty(settleClaimss)) {
            return;
        }
        for (SettleClaims settleClaims: settleClaimss) {
            this.updateById(settleClaims);
        }
    }

    @Override
    public SettleClaims findById(Integer id) {

        return settleClaimsMapper.selectById(id);
    }

    @Override
    public SettleClaims findOne(SettleClaims settleClaims) {
        QueryWrapper<SettleClaims> wrapper = new QueryWrapper<>(settleClaims);
        return settleClaimsMapper.selectOne(wrapper);
    }

    @Override
    public List<SettleClaims> findList(SettleClaims settleClaims) {
        QueryWrapper<SettleClaims> wrapper = new QueryWrapper<>(settleClaims);
        return settleClaimsMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<SettleClaims> findPage(PageWrap<SettleClaims> pageWrap) {
        IPage<SettleClaims> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Utils.MP.blankToNull(pageWrap.getModel());
        MPJLambdaWrapper<SettleClaims>  queryWrapper =    new MPJLambdaWrapper<SettleClaims>();
        queryWrapper.selectAll(SettleClaims.class)
                .selectAs(Company::getName,SettleClaims::getCompanyName)
                .selectAs(Solutions::getName,SettleClaims::getSolutionName)
                .selectAs(Member::getName,SettleClaims::getMemberName)
                .selectAs(Member::getIdcardNo,SettleClaims::getMemberIdcardNo)
                .selectAs(Worktype::getName,SettleClaims::getWorktypeName)
                .selectAs(InsuranceApply::getStartTime,SettleClaims::getBaoxianStartTime)
                .selectAs(InsuranceApply::getCode,SettleClaims::getApplyCode)
                .selectAs(DispatchUnit::getName,SettleClaims::getDuName)
                .selectAs(InsuranceApply::getStartTime,SettleClaims::getBaoxianStartTime)
                .selectAs(InsuranceApply::getEndTime,SettleClaims::getBaoxianEndTime)
                .leftJoin(Company.class,Company::getId,SettleClaims::getCompanyId)
                .leftJoin(Member.class,Member::getId,SettleClaims::getMemberId)
                .leftJoin(DispatchUnit.class,DispatchUnit::getId,SettleClaims::getDuId)
                .leftJoin(Worktype.class,Worktype::getId,SettleClaims::getWorktypeId)
                .leftJoin(InsuranceApply.class,InsuranceApply::getId,SettleClaims::getInsuranceApplyId)
                .leftJoin(Solutions.class,Solutions::getId,SettleClaims::getSolutionId);
        queryWrapper.eq(DispatchUnit::getIsdeleted,Constants.ZERO);
        queryWrapper.eq(SettleClaims::getIsdeleted,Constants.ZERO);
        if(Constants.equalsInteger(user.getType(),Constants.ZERO)){
            //只能看权限范围内
            if(user.getCompanyIdList() == null || user.getCompanyIdList().size() == 0){
                queryWrapper. eq(Company::getId,-1);//设置无效访问
            }else {
                queryWrapper. in(Company::getId, user.getCompanyIdList());
            }
            queryWrapper.ne(SettleClaims::getStatus,Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey());
        }{
            //企业用户只看自己的数据
            pageWrap.getModel().setCompanyId(user.getCompanyId());
        }
        queryWrapper.eq(SettleClaims::getIsdeleted,Constants.ZERO);
        queryWrapper.eq(SettleClaims::getOrigin,Constants.ZERO);
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getMemberName()),Member::getName, pageWrap.getModel().getMemberName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getMemberIdcardNo()),Member::getIdcardNo, pageWrap.getModel().getMemberIdcardNo());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getInformantName()),SettleClaims::getInformantName, pageWrap.getModel().getInformantName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getDuName()),DispatchUnit::getName, pageWrap.getModel().getDuName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getCreateDateStr()),SettleClaims::getCreateDate, pageWrap.getModel().getCreateDateStr());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getHappenTime()),SettleClaims::getHappenTime, pageWrap.getModel().getHappenTime());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getDuName()),DispatchUnit::getName, pageWrap.getModel().getDuName());
        queryWrapper.eq(pageWrap.getModel().getBaseSolutionId()!=null,Solutions::getBaseId, pageWrap.getModel().getBaseSolutionId());
        queryWrapper.eq(pageWrap.getModel().getBaseDuId()!=null,DispatchUnit::getBaseId, pageWrap.getModel().getBaseDuId());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getSolutionName()),Solutions::getName, pageWrap.getModel().getSolutionName());
        queryWrapper.eq(pageWrap.getModel().getInHospital()!=null,SettleClaims::getInHospital, pageWrap.getModel().getInHospital());
        queryWrapper.eq(pageWrap.getModel().getStatus()!=null,SettleClaims::getStatus, pageWrap.getModel().getStatus());
        queryWrapper.eq(pageWrap.getModel().getCompanyId()!=null,SettleClaims::getCompanyId, pageWrap.getModel().getCompanyId());
        queryWrapper.eq(pageWrap.getModel().getOrigin()!=null,SettleClaims::getOrigin, pageWrap.getModel().getOrigin());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getCode()),SettleClaims::getCode, pageWrap.getModel().getCode());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getReportNum()),SettleClaims::getReportNum, pageWrap.getModel().getReportNum());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getApplyCode()),InsuranceApply::getCode, pageWrap.getModel().getApplyCode());

        queryWrapper.orderByDesc(SettleClaims::getCreateDate);
        /*for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }*/
        PageData<SettleClaims> pageData = PageData.from(settleClaimsJoinMapper.selectJoinPage(page,SettleClaims.class, queryWrapper));
        for (SettleClaims settleClaims:pageData.getRecords()) {
            settleClaims.setStatusName(Constants.SettleClaimsStatus.getName(settleClaims.getStatus()));

            settleClaims.setPcAccount(Constants.getBigDecimalNoNull(settleClaims.getHpAccount()).add(Constants.getBigDecimalNoNull(settleClaims.getHpOtherAccount())));
        }
        return pageData;
    }


    @Override
    public PageData<SettleClaims> findPageForSd(PageWrap<SettleClaims> pageWrap) {
        IPage<SettleClaims> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Utils.MP.blankToNull(pageWrap.getModel());
        MPJLambdaWrapper<SettleClaims>  queryWrapper = new MPJLambdaWrapper<SettleClaims>();
        queryWrapper.selectAll(SettleClaims.class)
                .selectAs(SettleClaimsExt::getBxOrg,SettleClaims::getCompanyName)
                .selectAs(SettleClaimsExt::getBxName,SettleClaims::getSolutionName)
                .selectAs(SettleClaimsExt::getMemberName,SettleClaims::getMemberName)
                .selectAs(SettleClaimsExt::getMemberIdcard,SettleClaims::getMemberIdcardNo)
                .selectAs(SettleClaimsExt::getBxStartdate,SettleClaims::getBaoxianStartTime)
                .selectAs(SettleClaimsExt::getBxEnddate,SettleClaims::getBaoxianEndTime)
                .selectAs(SettleClaimsExt::getBxCode,SettleClaims::getApplyCode)
                .selectAs(SettleClaimsExt::getReportDate,SettleClaims::getReportDate)
                .innerJoin(SettleClaimsExt.class,SettleClaimsExt::getSettileClaimsId,SettleClaims::getId);
        queryWrapper.eq(SettleClaims::getIsdeleted,Constants.ZERO);
        queryWrapper.eq(SettleClaims::getOrigin,Constants.ONE);
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getReportNum()),SettleClaims::getReportNum, pageWrap.getModel().getReportNum());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getCompanyName()),SettleClaimsExt::getBxOrg, pageWrap.getModel().getCompanyName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getInformantName()),SettleClaims::getInformantName, pageWrap.getModel().getInformantName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getHappenTime()),SettleClaims::getHappenTime, pageWrap.getModel().getHappenTime());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getCreateDateStr()),SettleClaims::getCreateDate, pageWrap.getModel().getCreateDateStr());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getMemberName()),SettleClaimsExt::getMemberName, pageWrap.getModel().getMemberName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getSolutionName()),SettleClaimsExt::getBxName, pageWrap.getModel().getSolutionName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getApplyCode()),SettleClaimsExt::getBxCode, pageWrap.getModel().getApplyCode());
        queryWrapper.eq(pageWrap.getModel().getInHospital()!=null,SettleClaims::getInHospital, pageWrap.getModel().getInHospital());
        queryWrapper.eq(pageWrap.getModel().getStatus()!=null,SettleClaims::getStatus, pageWrap.getModel().getStatus());
        queryWrapper.orderByDesc(SettleClaims::getCreateDate);
        PageData<SettleClaims> pageData = PageData.from(settleClaimsJoinMapper.selectJoinPage(page,SettleClaims.class, queryWrapper));
        for (SettleClaims settleClaims:pageData.getRecords()) {
            if(Objects.nonNull(settleClaims.getStatus())){
                settleClaims.setStatusName(Constants.SettleClaimsStatus.getName(settleClaims.getStatus()));
            }
            settleClaims.setPcAccount(settleClaims.getHpAccount().add(settleClaims.getHpOtherAccount()));
        }
        return pageData;
    }



    @Override
    public long count(SettleClaims settleClaims) {
        QueryWrapper<SettleClaims> wrapper = new QueryWrapper<>(settleClaims);
        return settleClaimsMapper.selectCount(wrapper);
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public Integer saveSettleClaims(SettleClaimsDTO settleClaimsDTO,SystemDictDataServiceImpl systemDictDataService){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业员工无法进行该操作");
        }
        if(Objects.isNull(settleClaimsDTO)
            || Objects.isNull(settleClaimsDTO.getSaveType())
            || Objects.isNull(settleClaimsDTO.getMemberId())
            || StringUtils.isBlank(settleClaimsDTO.getIdcardNo())
            || Objects.isNull(settleClaimsDTO.getInsuranceApplyId())
            || Objects.isNull(settleClaimsDTO.getApplyDetailId())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)){
            if(Objects.isNull(settleClaimsDTO.getSolutionId())
                    ||Objects.isNull(settleClaimsDTO.getWorktypeId())
                    ||Objects.isNull(settleClaimsDTO.getDuId())
                    ||StringUtils.isBlank(settleClaimsDTO.getHappenTime())
                    ||StringUtils.isBlank(settleClaimsDTO.getContent())
                    ||Objects.isNull(settleClaimsDTO.getType())
                    ||Objects.isNull(settleClaimsDTO.getInHospital())
                    ||Objects.isNull(settleClaimsDTO.getHurtType())
                    ||Objects.isNull(settleClaimsDTO.getMedicalInsurance())
                    ||StringUtils.isBlank(settleClaimsDTO.getInformantName())
                    ||StringUtils.isBlank(settleClaimsDTO.getInformantPhone())
                    ||StringUtils.isBlank(settleClaimsDTO.getReceiveUserName())
                    ||StringUtils.isBlank(settleClaimsDTO.getReceiveBank())
                    ||StringUtils.isBlank(settleClaimsDTO.getReceiveAccount())
            ){
                throw new BusinessException(ResponseStatus.BAD_REQUEST);
            }
        }
        SettleClaims settleClaims = new SettleClaims();
        BeanUtils.copyProperties(settleClaimsDTO,settleClaims);
        settleClaims.setReportNumStatus(Constants.ZERO);
        settleClaims.setOrigin(Constants.ZERO);
        if(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)&&StringUtils.isBlank(settleClaims.getCode())){
            Long nextCode = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda().ne(SettleClaims::getStatus,Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())
                    .eq(SettleClaims::getOrigin,Constants.ZERO) .like(SettleClaims::getCreateDate,DateUtil.getDate(new Date(),"yyyy-MM-dd"))
            )+1;
            settleClaims.setCode("YYBLP-"+DateUtil.getDate(new Date(),"yyyyMMdd")+
                    (StringUtils.leftPad(nextCode.toString(),2,"0"))
            );
        }
        if(Objects.nonNull(settleClaims.getId())){
            settleClaims.setEditDate(new Date());
            settleClaims.setEditor(loginUserInfo.getId());
            settleClaims.setStatus(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)?
                    Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey():Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey());
            if(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)){
                //处理风险信息
                this.saveRisk(settleClaims,settleClaimsDTO,systemDictDataService);
            }
            settleClaimsMapper.updateById(settleClaims);
        }else{
            settleClaims.setCreateDate(new Date());
            settleClaims.setIsdeleted(Constants.ZERO);
            settleClaims.setCompanyId(loginUserInfo.getCompanyId());
            settleClaims.setStatus(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)?
                    Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey():Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey());
            if(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)){
                //处理风险信息
                this.saveRisk(settleClaims,settleClaimsDTO,systemDictDataService);
            }
            settleClaims.setCreator(loginUserInfo.getId());
            settleClaims.setCheckUserId(loginUserInfo.getId());
            settleClaimsMapper.insert(settleClaims);
        }
        this.saveFile(settleClaims,settleClaimsDTO,loginUserInfo);
        if(Constants.equalsInteger(settleClaimsDTO.getSaveType(),Constants.ONE)){
            this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.UPLOAD,null,Constants.SettleClaimsStatus.RETURN_ACCEPTANCE);
            if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())){
                this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.PLATFORM_REGISTER,null,Constants.SettleClaimsStatus.CONFIRM_INFORMATION);
            }
        }
        return settleClaims.getId();
    }

    public void saveRisk(SettleClaims settleClaims, SettleClaimsDTO settleClaimsDTO, SystemDictDataServiceImpl systemDictDataService){
        //根据保单信息 查询出主方案
        InsuranceApply insuranceApply = insuranceApplyMapper.selectById(settleClaims.getInsuranceApplyId());
        if(Objects.isNull(insuranceApply)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到保单数据");
        }
        Date happenTime = DateUtil.StringToDate(settleClaims.getHappenTime());
        if(happenTime.getTime() < insuranceApply.getStartTime().getTime() || happenTime.getTime() > insuranceApply.getEndTime().getTime()){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在保单生效范围内");
        }
        Solutions solutions = solutionsMapper.selectById(insuranceApply.getSolutionId());
        if(Objects.isNull(solutions)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到子方案信息");
        }
        SolutionsBase solutionsBase = solutionsBaseMapper.selectById(solutions.getParentId());
        if(Objects.isNull(solutionsBase)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到主方案信息");
        }
        List<Map<String,String>> riskList = new ArrayList<>();
        //查询保单明细数据
        ApplyDetail applyDetail = applyDetailMapper.selectOne(new QueryWrapper<ApplyDetail>().lambda()
                .eq(ApplyDetail::getApplyId,settleClaims.getInsuranceApplyId())
                .eq(ApplyDetail::getId,settleClaimsDTO.getApplyDetailId()).last("limit 1 "));
        //是否开启 新员工报案 0不允许 1允许
        if(Constants.equalsInteger(solutionsBase.getRiskNewUserStatus(),Constants.ONE)
                && Objects.nonNull(solutionsBase.getRiskNewUserUnit())
                && Objects.nonNull(solutionsBase.getRiskNewUserTime())
        ){
            if(happenTime.getTime() > applyDetail.getEndTime().getTime()){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
            }
            Map<String,String> map = new HashMap<>();
            map.put("title","保单已投保未生效");
            Date startDate = applyDetail.getStartTime();
            if(Constants.equalsInteger(solutionsBase.getRiskNewUserUnit(),Constants.ONE)){
                startDate = DateUtil.afterMinutesByDate(-solutionsBase.getRiskNewUserTime()*60,startDate);
            }else if(Constants.equalsInteger(solutionsBase.getRiskNewUserUnit(),Constants.TWO)){
                startDate = DateUtil.afterDayByDate(-solutionsBase.getRiskNewUserTime(),happenTime);
            }else{
                if(happenTime.getTime() < applyDetail.getStartTime().getTime() || happenTime.getTime() > applyDetail.getEndTime().getTime()){
                    throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
                }
            }
            if(happenTime.getTime() < startDate.getTime() ){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
            }else{
                map.put("info","事故发生时间早于保单生效时间"+solutionsBase.getRiskNewUserUnit()+(Constants.equalsInteger(solutionsBase.getRiskNewUserUnit(),Constants.ONE)?"小时内":"天内"));
                riskList.add(map);
            }
        }else{
            if(happenTime.getTime() < applyDetail.getStartTime().getTime() || happenTime.getTime() > applyDetail.getEndTime().getTime()){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"事故发生时间未在人员保障日期范围内");
            }
        }

        //是否开启 延迟报案提醒是否开启 0不允许 1允许
        if(Constants.equalsInteger(solutionsBase.getRiskDelayStatus(),Constants.ONE)){
            Map<String,String> map = new HashMap<>();
            map.put("title","延迟报案提醒");
            //根据配置 查询 延迟报案提醒时间单位 0分钟 1小时 2天
            if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.ZERO)){
                if(DateUtil.getBetweenMin(happenTime,new Date())>solutionsBase.getRiskDelayTime()){
                    map.put("info","报案时间超过案发时间"+solutionsBase.getRiskDelayUnit()+"分钟");
                    riskList.add(map);
                }
            }else if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.ONE)){
                if(DateUtil.getBetweenHours(happenTime,new Date())>solutionsBase.getRiskDelayTime()){
                    map.put("info","报案时间超过案发时间"+solutionsBase.getRiskDelayUnit()+"小时");
                    riskList.add(map);
                }
            }else if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.TWO)){
                if(DateUtil.getBetweenDay(happenTime,new Date())>solutionsBase.getRiskDelayTime()){
                    map.put("info","报案时间超过案发时间"+solutionsBase.getRiskDelayUnit()+"天");
                    riskList.add(map);
                }
            }
        }

        //查询字典值配置信息
        RiskConfigVO riskConfigVO = systemDictDataService.getRiskConfig();
        //多次出险提醒
        if(StringUtils.isNotBlank(riskConfigVO.getRiskTimesOpen()) && StringUtils.equals(riskConfigVO.getRiskTimesOpen(),Constants.ONE+"")
            && StringUtils.isNotBlank(riskConfigVO.getRiskTimesReportTimes())){
            Long cxcs = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getMemberId,settleClaimsDTO.getMemberId())
                    .ne(Objects.nonNull(settleClaims.getId()),SettleClaims::getId,settleClaims.getId())
                    .apply(" HAPPEN_TIME > DATE_SUB(now(), INTERVAL 365 DAY)  ")
            );
            if(cxcs>Integer.valueOf(riskConfigVO.getRiskTimesReportTimes())){
                Map<String,String> map = new HashMap<>();
                map.put("title","疑似多次出险");
                map.put("info","出险人一年内已出险"+cxcs+"次");
                riskList.add(map);
                settleClaims.setRiskTimesCx(Constants.ONE);
            };
        }
        //疑似重复报案
        if(StringUtils.isNotBlank(riskConfigVO.getRiskRepeatReportOpen())
                && StringUtils.equals(riskConfigVO.getRiskRepeatReportOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskRepeatReportTimeUnit())
                && StringUtils.isNotBlank(riskConfigVO.getRiskRepeatReportTime())){
            Long cxcs = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getMemberId,settleClaimsDTO.getMemberId())
                    .ne(Objects.nonNull(settleClaims.getId()),SettleClaims::getId,settleClaims.getId())
                    .apply(riskConfigVO.getRiskRepeatReportTimeUnit().equals("1")," HAPPEN_TIME > DATE_SUB(now(), INTERVAL "+riskConfigVO.getRiskRepeatReportTime()+" HOUR)  ")
                    .apply(riskConfigVO.getRiskRepeatReportTimeUnit().equals("2")," HAPPEN_TIME > DATE_SUB(now(), INTERVAL "+riskConfigVO.getRiskRepeatReportTime()+" DAY)  ")
            );
            if(cxcs > Constants.TWO){
                Map<String,String> map = new HashMap<>();
                map.put("title","疑似重复报案");
                map.put("info","该出险人在"+riskConfigVO.getRiskRepeatReportTime()+(riskConfigVO.getRiskRepeatReportTimeUnit().equals("1")?"小时":"天")+"内已报案"+cxcs+"次");
                riskList.add(map);
                settleClaims.setRiskRepeat(Constants.ONE);
            }
        }


        //索赔次数过多提醒
        if(StringUtils.isNotBlank(riskConfigVO.getRiskClaimTimesOpen())
                && StringUtils.equals(riskConfigVO.getRiskClaimTimesOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskClaimTimes())){
            Long cxcs = settleClaimsMapper.selectCount(new QueryWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getInsuranceApplyId,settleClaimsDTO.getInsuranceApplyId())
                    .ne(Objects.nonNull(settleClaims.getId()),SettleClaims::getId,settleClaims.getId())
                    .apply(" HAPPEN_TIME > DATE_SUB(now(), INTERVAL 365 DAY)  ")
            );
            if(cxcs > Integer.valueOf(riskConfigVO.getRiskClaimTimes())){
                Map<String,String> map = new HashMap<>();
                map.put("title","该保单索赔次数过多");
                map.put("info","累计索赔次数已到达"+cxcs+"次");
                riskList.add(map);
                settleClaims.setRiskTimesSp(Constants.ONE);
            }
        }

        //设计敏感词汇
        if(StringUtils.isNotBlank(riskConfigVO.getRiskSensitiveWordsOpen())
                && StringUtils.equals(riskConfigVO.getRiskSensitiveWordsOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskSensitiveWords())){
            String [] words = riskConfigVO.getRiskSensitiveWords().split(",");
            String sensitiveWord = ""; 
            for (String word:words) {
                if(settleClaims.getContent().indexOf(word)>=Constants.ZERO){
                    if(Constants.equalsInteger(sensitiveWord.length(),Constants.ZERO)){
                        sensitiveWord = word;
                    }else{
                        sensitiveWord = sensitiveWord + "、" + word ;
                    }
                } 
            }
            if(!Constants.equalsInteger(sensitiveWord.length(),Constants.ZERO)){
                Map<String,String> map = new HashMap<>();
                map.put("title","涉及敏感词");
                map.put("info","检测到敏感词："+sensitiveWord);
                riskList.add(map);
                settleClaims.setRiskSensitive(sensitiveWord);
            }
        }
        //疑似新员工出险
        if(StringUtils.isNotBlank(riskConfigVO.getRiskNewMemberOpen())
                && StringUtils.equals(riskConfigVO.getRiskNewMemberOpen(),Constants.ONE+"")
                && StringUtils.isNotBlank(riskConfigVO.getRiskNewMemberTimeUnit())
                && StringUtils.isNotBlank(riskConfigVO.getRiskNewMemberTime())
        ){
            Map<String,String> map = new HashMap<>();
            map.put("title","疑似新员工出险");
            if(riskConfigVO.getRiskNewMemberTimeUnit().equals(Constants.ONE+"")){
                if(DateUtil.afterMinutesByDate(Integer.valueOf(riskConfigVO.getRiskNewMemberTime())*60,insuranceApply.getStartTime()).getTime() < happenTime.getTime()){
                    map.put("info","保险生效时间为"+DateUtil.getFomartDate(insuranceApply.getStartTime(),"yyyy-MM-dd")+"");
                    riskList.add(map);
                    settleClaims.setRiskNewUser(Constants.ONE);
                };

            }else if(Constants.equalsInteger(solutionsBase.getRiskDelayUnit(),Constants.TWO)){
                if(DateUtil.afterDayByDate(Integer.valueOf(riskConfigVO.getRiskNewMemberTime()),insuranceApply.getStartTime()).getTime() < happenTime.getTime()){
                    map.put("info","保险生效时间为"+DateUtil.getFomartDate(insuranceApply.getStartTime(),"yyyy-MM-dd")+"");
                    riskList.add(map);
                    settleClaims.setRiskNewUser(Constants.ONE);
                }
            } 
        }
        settleClaims.setRiskContent(JSONObject.toJSONString(riskList));
        if(riskList.size()>Constants.ZERO){
            settleClaims.setIsRisk(Constants.ONE);
        }else{
            settleClaims.setIsRisk(Constants.ZERO);
            settleClaims.setStatus(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey());
        }
    }

    public void saveFile(SettleClaims settleClaims,SettleClaimsDTO settleClaimsDTO,LoginUserInfo loginUserInfo){
        multifileJoinMapper.delete(new QueryWrapper<Multifile>().lambda()
                .eq(Multifile::getObjId,settleClaims.getId())
                .in(Multifile::getObjType,
                        Constants.MultiFile.LP_SGXC_FILE.getKey(),
                        Constants.MultiFile.LP_YGGX_FILE.getKey(),
                        Constants.MultiFile.LP_MZCL_FILE.getKey(),
                        Constants.MultiFile.LP_ZYCL_FILE.getKey(),
                        Constants.MultiFile.LP_OTHER_FILE.getKey(),
                        Constants.MultiFile.LP_SCZL_FILE.getKey()
                )
        );
        List<Multifile> reportVideo = settleClaimsDTO.getReportFileList();
        if(CollectionUtils.isNotEmpty(reportVideo)){
            for (int i = 0; i < reportVideo.size(); i++) {
                Multifile multifile = reportVideo.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_SGXC_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> relationFileList = settleClaimsDTO.getRelationFileList();
        if(CollectionUtils.isNotEmpty(relationFileList)){
            for (int i = 0; i < relationFileList.size(); i++) {
                Multifile multifile = relationFileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_YGGX_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> outpatientFileList = settleClaimsDTO.getOutpatientFileList();
        if(CollectionUtils.isNotEmpty(outpatientFileList)){
            for (int i = 0; i < outpatientFileList.size(); i++) {
                Multifile multifile = outpatientFileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_MZCL_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> hospitalFileList = settleClaimsDTO.getHospitalFileList();
        if(CollectionUtils.isNotEmpty(hospitalFileList)){
            for (int i = 0; i < hospitalFileList.size(); i++) {
                Multifile multifile = hospitalFileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_ZYCL_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> disabilityFileList = settleClaimsDTO.getDisabilityFileList();
        if(CollectionUtils.isNotEmpty(disabilityFileList)){
            for (int i = 0; i < disabilityFileList.size(); i++) {
                Multifile multifile = disabilityFileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_SCZL_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }

        List<Multifile> otherFileList = settleClaimsDTO.getOtherFileList();
        if(CollectionUtils.isNotEmpty(otherFileList)){
            for (int i = 0; i < otherFileList.size(); i++) {
                Multifile multifile = otherFileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_OTHER_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }
        List<Multifile> supplementFileList = settleClaimsDTO.getSupplementFileList();
        if(CollectionUtils.isNotEmpty(supplementFileList)){
            for (int i = 0; i < supplementFileList.size(); i++) {
                Multifile multifile = supplementFileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setId(null);
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                multifile.setObjType(Constants.MultiFile.LP_SUPPLEMENT_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }
    }

//    public void getRiskSettleDetail(Integer id){
//        settleClaimsJoinMapper.selectJoinOne(SettleClaims.class,new MPJLambdaWrapper<SettleClaims>()
//                .selectAll(SettleClaims.class)
//                .selectAs(DispatchUnit::getName,SettleClaims::getDuName)
//                .selectAs(Worktype::getName,SettleClaims::getWorktypeName)
//                .selectAs(Solutions::getName,SettleClaims::getSolutionName)
//                .selectAs(InsuranceApply::getStartTime,SettleClaims::getBaoxianStartTime)
//                .selectAs(InsuranceApply::getEndTime,SettleClaims::getBaoxianEndTime)
//                .leftJoin(Solutions.class,Solutions::getId,SettleClaims::getSolutionId)
//                .leftJoin(DispatchUnit.class,DispatchUnit::getId,SettleClaims::getDuId)
//                .leftJoin(Worktype.class,Worktype::getId,SettleClaims::getWorktypeId)
//                .leftJoin(InsuranceApply.class,InsuranceApply::getId,SettleClaims::getInsuranceApplyId)
//
//
//                .eq(SettleClaims::getId,id)
//                .last(" limit 1 ")
//        );
//    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void saveSupplementDescribe(SaveSupplementDescribeDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
            || Objects.isNull(dto.getDescribe())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.ACCEPTANCE.getKey(),settleClaims.getStatus())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        if(Constants.equalsInteger(settleClaims.getWaitSupplement(),Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"待企业补充文件，请等待企业补充文件");
        }
        //存储日志
        this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.SUPPLEMENT_DESCRIBE,dto.getDescribe(),null);
        settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate,DateUtil.getCurrDateTime())
                        .set(SettleClaims::getWaitSupplementInfo,dto.getDescribe())
                .set(SettleClaims::getWaitSupplement,Constants.ONE));
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void saveSupplementFile(SaveSupplementDescribeDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || CollectionUtils.isEmpty(dto.getSupplementFileList())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!(loginUserInfo.getType().equals(Constants.ZERO)||loginUserInfo.getType().equals(Constants.ONE))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非平台与企业员工无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(loginUserInfo.getType().equals(Constants.ZERO)){
            if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.ACCEPTANCE.getKey(),settleClaims.getStatus())
                    || Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey(),settleClaims.getStatus())
            )){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
            }
        }else{
            //如果是企业 查询是否是自己企业的数据
            if(!Constants.equalsInteger(settleClaims.getCompanyId(),loginUserInfo.getCompanyId())){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非您企业的数据，您无法进行该操作");
            }
            if(!Constants.equalsInteger(settleClaims.getWaitSupplement(),Constants.ONE)) {
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "当前业务无需进行添加材料");
            }
            if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.ACCEPTANCE.getKey(),settleClaims.getStatus())
                    || Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey(),settleClaims.getStatus())
                    || Constants.equalsInteger(Constants.SettleClaimsStatus.REJECT_DEAL.getKey(),settleClaims.getStatus())
                    || Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_DISCUSS_REJECT.getKey(),settleClaims.getStatus())
            )){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
            }
            settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                            .set(SettleClaims::getWaitSupplement,Constants.ZERO)
                    .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate,DateUtil.getCurrDateTime()).set(SettleClaims::getWaitSupplement,Constants.ZERO));
        }
        multifileJoinMapper.delete(new QueryWrapper<Multifile>().lambda().eq(Multifile::getObjId,dto.getId()).eq(Multifile::getObjType,Constants.MultiFile.LP_OTHER_FILE.getKey()));
        List<Multifile> fileList = dto.getSupplementFileList();
        if(CollectionUtils.isNotEmpty(fileList)){
            for (int i = 0; i < fileList.size(); i++) {
                Multifile multifile = fileList.get(i);
                if(Objects.isNull(multifile.getFileurl())
                        || Objects.isNull(multifile.getType())
                        || StringUtils.isBlank(multifile.getName())
                ){
                    throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                }
                multifile.setCreator(loginUserInfo.getId());
                multifile.setCreateDate(new Date());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(settleClaims.getId());
                //添加材料放入 其他材料业务内
                multifile.setObjType(Constants.MultiFile.LP_SUPPLEMENT_FILE.getKey());
                multifile.setSortnum(i+1);
                multifileJoinMapper.insert(multifile);
            }
        }
        //存储日志
        this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.SUPPLEMENT,null,null);
    }


    /**
     * 撤销报案
     * @param dto
     */
    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void returnSettle(OptSettleClaimsDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业人员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //如果是企业 查询是否是自己企业的数据
        if(!Constants.equalsInteger(settleClaims.getCompanyId(),loginUserInfo.getCompanyId())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非您企业的数据，您无法进行该操作");
        }
//        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey(),settleClaims.getStatus())){
//            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
//        }
        //存储日志
        this.saveSettleClaimsLog(settleClaims,Constants.SettleClaimsLogType.RETURN_SETTLE,null,Constants.SettleClaimsStatus.RETURN);
        settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate,DateUtil.getCurrDateTime()).set(SettleClaims::getStatus,Constants.SettleClaimsStatus.RETURN.getKey()));
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updCaseType(CaseTypeDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || Objects.isNull(dto.getCaseType())
                || !(dto.getCaseType()>=Constants.ONE&&dto.getCaseType()<=Constants.THREE)
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.ACCEPTANCE.getKey(),settleClaims.getStatus())
        || Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey(),settleClaims.getStatus()))
        ){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        //存储日志
        this.saveSettleClaimsLog(settleClaims, Constants.SettleClaimsLogType.UPD_CASE_TYPE,Constants.SettleClaimsLogType.UPD_CASE_TYPE.getInfo(),null);
        settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getId,dto.getId())
                .set(SettleClaims::getEditDate,DateUtil.getCurrDateTime())
                .set(SettleClaims::getEditor,loginUserInfo.getId())
                .set(SettleClaims::getCaseType,dto.getCaseType()));
    }



    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void register(OptSettleClaimsDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || Objects.isNull(dto.getRegisterStatus())
                || !(Constants.equalsInteger(dto.getRegisterStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())||Constants.equalsInteger(dto.getRegisterStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey()))
                || (Constants.equalsInteger(dto.getRegisterStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())&&StringUtils.isBlank(dto.getDescribe()))
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.RETURN_ACCEPTANCE.getKey(),settleClaims.getStatus())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        Constants.SettleClaimsStatus settleClaimsStatus =
                Constants.equalsInteger(dto.getRegisterStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())?Constants.SettleClaimsStatus.CONFIRM_INFORMATION:Constants.SettleClaimsStatus.FINISH_ACCEPTANCE;
        //存储日志
        this.saveSettleClaimsLog(settleClaims, Constants.equalsInteger(dto.getRegisterStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())?Constants.SettleClaimsLogType.PLATFORM_REGISTER:Constants.SettleClaimsLogType.PLATFORM_RETURN,dto.getDescribe(),settleClaimsStatus);
        settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getId,dto.getId())
                .set(SettleClaims::getEditDate, DateUtil.getCurrDateTime())
                .set(SettleClaims::getEditor,loginUserInfo.getId())
                .set(SettleClaims::getStatus,settleClaimsStatus.getKey()));
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public Integer addReportNum(OptSettleClaimsDTO param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getReportNum()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())
            || Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
            ) 
        ){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!user.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        if(Constants.equalsInteger(model.getReportNumStatus(),Constants.TWO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"仅可修改一次报案号");
        }
        if(!(
                (Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
                        &&Constants.equalsInteger(model.getReportNumStatus(),Constants.ONE))
                ||((Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())
                        || Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
                        || Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.WAIT_DISCUSS_AUDIT.getKey()))
                        &&Constants.equalsInteger(model.getReportNumStatus(),Constants.ZERO))
//                        ||(Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.WAIT_DEAL.getKey())
//                        &&Constants.equalsInteger(model.getReportNumStatus(),Constants.ZERO))
        )
        ){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"仅可修改一次报案号");
        }


//        //查询是否有报案号更改记录
//        if(Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
//        && settleClaimsLogMapper.selectCount(new QueryWrapper<SettleClaimsLog>().lambda()
//                        .eq(SettleClaimsLog::getObjType,Constants.SettleClaimsLogType.PLATFORM_ADDCODE.getKey())
//                .eq(SettleClaimsLog::getSettleClainmsId,param.getId()))>=Constants.ONE){
//            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"仅可修改一次报案号");
//        }
//        if(Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())&&StringUtils.isNotBlank(model.getReportNum())){
//            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"已修改报案号，无法再次修改");
//        }
        settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getId,param.getId()).set(SettleClaims::getEditDate,
                        DateUtil.getCurrDateTime()).set(SettleClaims::getReportNum,param.getReportNum()));

        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setReportNumStatus(model.getReportNumStatus()+Constants.ONE);
        update.setId(model.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo("添加备案号");
        update.setCheckUserId(user.getId());
        update.setReportNum(param.getReportNum());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_ADDCODE;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", update.getReportNum());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);

        return  1;
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public  Integer addRemark(OptSettleClaimsDTO  param){
        if(param.getId() == null
                ||StringUtils.isBlank( param.getDescribe()) ){
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims model = settleClaimsMapper.selectById(param.getId());
        if(model == null ||!Constants.equalsInteger(model.getIsdeleted(),Constants.ZERO)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.REJECT_DEAL.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.WAIT_DISCUSS_AUDIT.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.WAIT_DISCUSS_REJECT.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.COMPENSATION.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.CONFIRM_FEE.getKey())
                ||Constants.equalsInteger(model.getStatus(),Constants.SettleClaimsStatus.CLOSE_CASE.getKey())
        )){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该申请当前不支持该操作~");
        }
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(user.getId());
        update.setCheckDate(update.getEditDate());
        update.setCheckInfo("添加备注标签");
        update.setCheckUserId(user.getId());
        update.setId(model.getId());
        settleClaimsMapper.updateById(update);

        Constants.SettleClaimsLogType applyLogType = Constants.SettleClaimsLogType.PLATFORM_REMARK;
        String info =applyLogType.getInfo();
        info = info.replace("${param}", param.getDescribe());
        SettleClaimsLog log = new SettleClaimsLog(update,applyLogType.getName(), info,update.getId(),applyLogType.getKey(), JSONObject.toJSONString(model), JSONObject.toJSONString(update));
        settleClaimsLogMapper.insert(log);
        return  1;

    }






    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void acceptance(AcceptanceSettleClaimsDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || Objects.isNull(dto.getStatus())
                || StringUtils.isBlank(dto.getDescribe())
                || !(dto.getStatus()>=Constants.ZERO||dto.getStatus()<=Constants.THREE)
                || ((Constants.equalsInteger(dto.getStatus(),Constants.THREE) ||Constants.equalsInteger(dto.getStatus(),Constants.TWO)) && StringUtils.isBlank(dto.getSyProblemOpts()) )
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey(),settleClaims.getStatus())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        if(Constants.equalsInteger(dto.getStatus(),Constants.ZERO) || Constants.equalsInteger(dto.getStatus(),Constants.THREE)){
            //受理
            settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate,DateUtil.getCurrDateTime()).set(SettleClaims::getEditor,loginUserInfo.getId())
                    .set(SettleClaims::getStatus,Constants.SettleClaimsStatus.ACCEPTANCE.getKey()));
            //存储日志
            this.saveSettleClaimsLog(settleClaims,
                    Constants.equalsInteger(dto.getStatus(),Constants.ZERO)?Constants.SettleClaimsLogType.PLATFORM_ACCEPTANCE:Constants.SettleClaimsLogType.PLATFORM_DISCUSS,
                    dto.getDescribe(),Constants.SettleClaimsStatus.ACCEPTANCE);
        }else if(Constants.equalsInteger(dto.getStatus(),Constants.ONE)){
            //拒绝受理
            settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate,DateUtil.getCurrDateTime()).set(SettleClaims::getEditor,loginUserInfo.getId())
                    .set(SettleClaims::getStatus,Constants.SettleClaimsStatus.REJECT_DEAL.getKey()));
            //存储日志
            this.saveSettleClaimsLog(settleClaims,
                    Constants.SettleClaimsLogType.PLATFORM_REFUSE_ACCEPTANCE,
                    Constants.SettleClaimsLogType.PLATFORM_REFUSE_ACCEPTANCE.getInfo().replace("{param}",dto.getDescribe()),Constants.SettleClaimsStatus.REJECT_DEAL);
        }else if(Constants.equalsInteger(dto.getStatus(),Constants.TWO)){
            //受理商议审批
            settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                    .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate,DateUtil.getCurrDateTime()).set(SettleClaims::getEditor,loginUserInfo.getId())
                    .set(SettleClaims::getStatus,Constants.SettleClaimsStatus.WAIT_DISCUSS_AUDIT.getKey()));
            //存储日志
            this.saveSettleClaimsLog(settleClaims,
                    Constants.SettleClaimsLogType.PLATFORM_WAIT_DISCUSS,
                    dto.getDescribe(),Constants.SettleClaimsStatus.WAIT_DISCUSS_AUDIT);
        }
    }


    @Override
    public List<CompensationVO> getCompensation(CompensationFeeDTO compensationFeeDTO){
        if(Objects.isNull(compensationFeeDTO)
                || Objects.isNull(compensationFeeDTO.getType())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        SettleClaims settleClaims = null;
        if(Objects.nonNull(compensationFeeDTO.getId())){
            settleClaims = settleClaimsMapper.selectById(compensationFeeDTO.getId());
        }
        List<CompensationVO> modelList = new ArrayList<>();
        if (Objects.nonNull(settleClaims)) {
            if(Constants.equalsInteger(compensationFeeDTO.getType(),Constants.ONE)&&StringUtils.isNotBlank(settleClaims.getAccountContent())){
                modelList = JSONArray.parseArray(settleClaims.getAccountContent(),CompensationVO.class);
            }else if(Constants.equalsInteger(compensationFeeDTO.getType(),Constants.TWO)&&StringUtils.isNotBlank(settleClaims.getHpAccountContent())){
                modelList = JSONArray.parseArray(settleClaims.getHpAccountContent(),CompensationVO.class);
            }
        }
        Constants.compensation [] compensations = Constants.compensation.values();
        List<CompensationVO> list = new ArrayList<>();
        for (Constants.compensation c:compensations) {
            CompensationVO compensationVO = new CompensationVO();
            compensationVO.setType(c.getType());
            compensationVO.setName(c.getName());
            if(CollectionUtils.isNotEmpty(modelList)){
                Optional<CompensationVO> optionalModel =  modelList.stream().filter(i->i.getName().equals(c.getName())).findFirst();
                if(optionalModel.isPresent()){
                    CompensationVO oldModel  = optionalModel.get();
                    compensationVO.setFee(oldModel.getFee());
                    compensationVO.setDescribe(oldModel.getDescribe());
                }
            }
            list.add(compensationVO);
        }
        return list;
    }
    
    
    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void compensation(CompensationDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || StringUtils.isBlank(dto.getCompensationJson())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.ACCEPTANCE.getKey(),settleClaims.getStatus())
                ||Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey(),settleClaims.getStatus()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }

        List<CompensationVO> modelList = JSONArray.parseArray(dto.getCompensationJson(),CompensationVO.class);

        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        update.setYlClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)&&i.getName().equals(Constants.compensation.YL_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setWgClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)&&i.getName().equals(Constants.compensation.WG_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setScClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)&&i.getName().equals(Constants.compensation.SC_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setSwClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)&&i.getName().equals(Constants.compensation.SW_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setOtherAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setAccountContent(dto.getCompensationJson());
        update.setId(settleClaims.getId());
        update.setStatus(Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey());
        settleClaimsMapper.updateById(update);

        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.PLATFORM_LP_DEAL,
                Constants.SettleClaimsLogType.PLATFORM_LP_DEAL.getInfo(),Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION);
    }


    /**
     * 商议审批
     * @param dto
     */
    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void discussAudit(DiscussAuditDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || Objects.isNull(dto.getStatus())
                || !(Constants.equalsInteger(dto.getStatus(),Constants.ZERO)||Constants.equalsInteger(dto.getStatus(),Constants.ONE))
                || (Constants.equalsInteger(dto.getStatus(),Constants.ONE)&&StringUtils.isBlank(dto.getDescribe()))
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_DISCUSS_AUDIT.getKey(),settleClaims.getStatus())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        Constants.SettleClaimsStatus settleClaimsStatus =
                Constants.equalsInteger(dto.getStatus(),Constants.ZERO)?Constants.SettleClaimsStatus.ACCEPTANCE:Constants.SettleClaimsStatus.WAIT_DISCUSS_REJECT;
        //存储日志
        Constants.SettleClaimsLogType settleClaimsLogType = Constants.equalsInteger(dto.getStatus(),Constants.ZERO)
                ?Constants.SettleClaimsLogType.PLATFORM_DISCUSS_PASS:Constants.SettleClaimsLogType.PLATFORM_DISCUSS_REFUSE;
        this.saveSettleClaimsLog(settleClaims, settleClaimsLogType
                ,settleClaimsLogType.getInfo().replace("${param}",dto.getDescribe()),settleClaimsStatus);
        settleClaimsMapper.update(null,new UpdateWrapper<SettleClaims>().lambda()
                .eq(SettleClaims::getId,dto.getId()).set(SettleClaims::getEditDate, DateUtil.getCurrDateTime())
                        .set(SettleClaims::getEditor,loginUserInfo.getId())
                .set(SettleClaims::getStatus,settleClaimsStatus.getKey()));
    }






    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void nuclearCompensation(CompensationDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || StringUtils.isBlank(dto.getCompensationJson())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey(),settleClaims.getStatus())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }


        List<CompensationVO> modelList = JSONArray.parseArray(dto.getCompensationJson(),CompensationVO.class);

        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        update.setHpAccountContent(dto.getCompensationJson());
        update.setHpAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setHpOtherAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setId(settleClaims.getId());
        update.setStatus(Constants.SettleClaimsStatus.COMPENSATION.getKey());
        settleClaimsMapper.updateById(update);

        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.PLATFORM_HP_DEAL,
                Constants.SettleClaimsLogType.PLATFORM_HP_DEAL.getInfo(),Constants.SettleClaimsStatus.COMPENSATION);
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updFee(CompensationDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || StringUtils.isBlank(dto.getCompensationJson())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.COMPENSATION.getKey(),settleClaims.getStatus())
                || Constants.equalsInteger(Constants.SettleClaimsStatus.CONFIRM_FEE.getKey(),settleClaims.getStatus()))
        ){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }

        List<CompensationVO> modelList = JSONArray.parseArray(dto.getCompensationJson(),CompensationVO.class);

        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        if(Constants.equalsInteger(Constants.SettleClaimsStatus.CONFIRM_FEE.getKey(),settleClaims.getStatus())){
            update.setFeeUpdate(Constants.ONE);
        }
        update.setYlClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)&&i.getName().equals(Constants.compensation.YL_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setWgClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)&&i.getName().equals(Constants.compensation.WG_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setScClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)&&i.getName().equals(Constants.compensation.SC_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setSwClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)&&i.getName().equals(Constants.compensation.SW_COMPENSATION.getName())).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
//        update.setClaimAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
//        //处理历史数据
//        List<CompensationVO> oldList =  JSONArray.parseArray(settleClaims.getHpAccountContent(),CompensationVO.class);
//        for (CompensationVO compensationVO:oldList) {
//            if(compensationVO.getName().equals(Constants.compensation.YL_COMPENSATION.getName())){
//                compensationVO.setFee(update.getYlClaimAccount());
//            }else if(compensationVO.getName().equals(Constants.compensation.WG_COMPENSATION.getName())){
//                compensationVO.setFee(update.getWgClaimAccount());
//            }else if(compensationVO.getName().equals(Constants.compensation.SC_COMPENSATION.getName())){
//                compensationVO.setFee(update.getScClaimAccount());
//            }else if(compensationVO.getName().equals(Constants.compensation.SW_COMPENSATION.getName())){
//                compensationVO.setFee(update.getSwClaimAccount());
//            }else{
//              continue;
//            }
//        }
        update.setHpAccountContent(dto.getCompensationJson());
        update.setHpAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setHpOtherAccount(modelList.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)).map(i->i.getFee()).reduce(BigDecimal.ZERO,BigDecimal::add));
        update.setId(settleClaims.getId());
        update.setFeeUpdate(Constants.ONE);
        settleClaimsMapper.updateById(update);

        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.PLATFORM_UPD_FEE,
                dto.getDescribe(),null);
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void confirmFee(Integer id){
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业人员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(id);
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //如果是企业 查询是否是自己企业的数据
        if(!Constants.equalsInteger(settleClaims.getCompanyId(),loginUserInfo.getCompanyId())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非您企业的数据，您无法进行该操作");
        }
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        update.setStatus(Constants.SettleClaimsStatus.CONFIRM_FEE.getKey());
        update.setId(settleClaims.getId());
        settleClaimsMapper.updateById(update);

        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.CONFIRM_FEE,
                Constants.SettleClaimsLogType.CONFIRM_FEE.getInfo(),Constants.SettleClaimsStatus.CONFIRM_FEE);
    }


    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void payCash(PayCashDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || StringUtils.isBlank(dto.getDescribe())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!Constants.equalsInteger(Constants.SettleClaimsStatus.CONFIRM_FEE.getKey(),settleClaims.getStatus())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        update.setStatus(Constants.SettleClaimsStatus.CLOSE_CASE.getKey());
        update.setCheckDate(new Date());
        update.setCheckUserId(loginUserInfo.getId());
        update.setCheckInfo(Constants.SettleClaimsStatus.CLOSE_CASE.name());
        update.setId(settleClaims.getId());
        settleClaimsMapper.updateById(update);

        if(CollectionUtils.isNotEmpty(dto.getMultifileList())){
            List<Multifile> fileList = dto.getMultifileList();
            if(CollectionUtils.isNotEmpty(fileList)){
                for (int i = 0; i < fileList.size(); i++) {
                    Multifile multifile = fileList.get(i);
                    if(Objects.isNull(multifile.getFileurl())
                            || Objects.isNull(multifile.getType())
                            || StringUtils.isBlank(multifile.getName())
                    ){
                        throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"附件内容异常");
                    }
                    multifile.setCreator(loginUserInfo.getId());
                    multifile.setCreateDate(new Date());
                    multifile.setIsdeleted(Constants.ZERO);
                    multifile.setObjId(settleClaims.getId());
                    //添加材料放入 其他材料业务内
                    multifile.setObjType(Constants.MultiFile.LP_PAY_FILE.getKey());
                    multifile.setSortnum(i+1);
                    multifileJoinMapper.insert(multifile);
                }
            }
        }


        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.PLATFORM_FINISH,
                dto.getDescribe(),Constants.SettleClaimsStatus.CLOSE_CASE);
    }



    public List<SettleParentStatusVO> getParentStatus(SettleClaims settleClaims){
        List<SettleParentStatusVO> settleParentStatusVOList = new ArrayList<>();
        List<SettleClaimsLog> settleClaimsLogList = settleClaimsLogMapper
                .selectList(new QueryWrapper<SettleClaimsLog>().lambda().eq(SettleClaimsLog::getObjId,settleClaims.getId())
                        .isNotNull(SettleClaimsLog::getParentStatus)
                        .orderByDesc(SettleClaimsLog::getId));
        //立案退回状态数据
        if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getKey())){
            SettleParentStatusVO settleParentStatusVO = new SettleParentStatusVO();
            settleParentStatusVO.setParentTitle("报案");
            settleParentStatusVO.setStatus(Constants.ONE);
            settleParentStatusVO.setChildTitle(Constants.SettleClaimsStatus.FINISH_ACCEPTANCE.getName());
            Optional<SettleClaimsLog> optionalSettleClaimsLog = settleClaimsLogList.stream()
                    .filter(i->Constants.equalsInteger(i.getObjType(),Constants.SettleClaimsLogType.PLATFORM_RETURN.getKey())).findFirst();
            if(optionalSettleClaimsLog.isPresent()){
                settleParentStatusVO.setOptDate(optionalSettleClaimsLog.get().getCreateDate());
            }
            settleParentStatusVOList.add(settleParentStatusVO);
            return settleParentStatusVOList;
        }
        //暂存状态 无主流程数据
        if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.WAIT_ACCEPTANCE.getKey())){
            return settleParentStatusVOList;
        }
        //商议审批不通过
        if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.WAIT_DISCUSS_REJECT.getKey())){
            SettleParentStatusVO settleParentStatusBAVO = new SettleParentStatusVO();
            settleParentStatusBAVO.setParentTitle("报案");
            settleParentStatusBAVO.setChildTitle("已报案");
            settleParentStatusBAVO.setStatus(Constants.ZERO);
            Optional<SettleClaimsLog> optionalSettleClaimsBALog = settleClaimsLogList.stream()
                    .filter(i->Constants.equalsInteger(i.getParentStatus(),Constants.ONE)).findFirst();
            if(optionalSettleClaimsBALog.isPresent()){
                settleParentStatusBAVO.setOptDate(optionalSettleClaimsBALog.get().getCreateDate());
            }
            settleParentStatusVOList.add(settleParentStatusBAVO);

            SettleParentStatusVO settleParentStatusLAVO = new SettleParentStatusVO();
            settleParentStatusLAVO.setParentTitle("立案");
            settleParentStatusLAVO.setChildTitle("已立案");
            settleParentStatusLAVO.setStatus(Constants.ZERO);
            Optional<SettleClaimsLog> optionalSettleClaimsLALog = settleClaimsLogList.stream()
                    .filter(i->Constants.equalsInteger(i.getParentStatus(),Constants.TWO)).findFirst();
            if(optionalSettleClaimsLALog.isPresent()){
                settleParentStatusLAVO.setOptDate(optionalSettleClaimsBALog.get().getCreateDate());
            }
            settleParentStatusVOList.add(settleParentStatusBAVO);

            SettleParentStatusVO settleParentStatusSLVO = new SettleParentStatusVO();
            settleParentStatusSLVO.setParentTitle("受理");
            settleParentStatusSLVO.setChildTitle("商议拒绝");
            settleParentStatusSLVO.setStatus(Constants.THREE);
            Optional<SettleClaimsLog> optionalSettleClaimsSLLog = settleClaimsLogList.stream()
                    .filter(i->Constants.equalsInteger(i.getParentStatus(),Constants.THREE)).findFirst();
            if(optionalSettleClaimsSLLog.isPresent()){
                settleParentStatusSLVO.setOptDate(optionalSettleClaimsSLLog.get().getCreateDate());
            }
            settleParentStatusVOList.add(settleParentStatusSLVO);

            return settleParentStatusVOList;
        }

        //主动撤销
        if(Constants.equalsInteger(settleClaims.getStatus(),Constants.SettleClaimsStatus.RETURN.getKey())){
            List<SettleClaimsLog> settleClaimsLogs = settleClaimsLogList.stream()
                    .filter(i->i.getParentStatus()<Constants.SettleClaimsStatus.RETURN.getParentKey()).collect(Collectors.toList());
            //获取当前日志最大的父状态
            Optional<Integer> optionalInteger = settleClaimsLogs.stream().map(i->i.getParentStatus()).max(Comparator.comparingInt(o -> o));
            if(optionalInteger.isPresent()){

                for (int i = 1; i <= (optionalInteger.get()<5?optionalInteger.get():5); i++) {
                    SettleParentStatusVO s = new SettleParentStatusVO();
                    Constants.SettleClaimsLogParentStatus  parentStatus = Constants.SettleClaimsLogParentStatus.getAll(i);
                    s.setParentTitle(parentStatus.getName());
                    s.setChildTitle(parentStatus.getInfo());
                    s.setStatus(Constants.ZERO);
                    //如果是等于父状态 则去查询实际的业务状态
                    Optional<SettleClaimsLog> settleClaimsLogOptional = settleClaimsLogList.stream()
                            .filter(j->Constants.equalsInteger(j.getParentStatus(),optionalInteger.get())).findFirst();
                    if(settleClaimsLogOptional.isPresent()){
                        s.setChildTitle(Constants.SettleClaimsLogType.getName(settleClaimsLogOptional.get().getObjType()));
                        s.setOptDate(settleClaimsLogOptional.get().getCreateDate());
                    }
                    settleParentStatusVOList.add(s);

                }
            }
            //添加撤案数据
            SettleParentStatusVO settleParentStatusCHVO = new SettleParentStatusVO();
            settleParentStatusCHVO.setParentTitle("已撤案");
            settleParentStatusCHVO.setChildTitle("企业主动撤案");
            settleParentStatusCHVO.setStatus(Constants.THREE);
            Optional<SettleClaimsLog> optionalSettleClaimsSLLog = settleClaimsLogList.stream()
                    .filter(i->Constants.equalsInteger(i.getObjType(),Constants.SettleClaimsLogType.RETURN_SETTLE.getKey())).findFirst();
            if(optionalSettleClaimsSLLog.isPresent()){
                settleParentStatusCHVO.setOptDate(optionalSettleClaimsSLLog.get().getCreateDate());
            }
            settleParentStatusVOList.add(settleParentStatusCHVO);
            return settleParentStatusVOList;
        }


        List<SettleClaimsLog> settleClaimsLogs = settleClaimsLogList.stream()
                .filter(i->i.getParentStatus()<Constants.SettleClaimsStatus.RETURN.getParentKey()).collect(Collectors.toList());
        Optional<Integer> optionalInteger = settleClaimsLogs.stream().map(i->i.getParentStatus()).max(Comparator.comparingInt(o -> o));
        if(optionalInteger.isPresent()){
            for (int i = 1; i <= 6; i++) {
                SettleParentStatusVO s = new SettleParentStatusVO();
                Constants.SettleClaimsLogParentStatus  parentStatus = Constants.SettleClaimsLogParentStatus.getAll(i);
                s.setParentTitle(parentStatus.getName());
                if(optionalInteger.get()>i){
                    //如果最大的父业务状态 大于 默认的6类数据 则直接显示默认配置
                    s.setChildTitle(parentStatus.getInfo());
                    s.setStatus(Constants.ZERO);
                    int finalI = i;
                    Optional<SettleClaimsLog> optionalSettleClaimsLog = settleClaimsLogList.stream()
                            .filter(j->Constants.equalsInteger(j.getParentStatus(), finalI)).findFirst();
                    if(optionalSettleClaimsLog.isPresent()){
                        s.setOptDate(optionalSettleClaimsLog.get().getCreateDate());
                    }
                }else if(optionalInteger.get()<i){
                    //如果最大的父业务状态 小于 默认的6类数据 则直接显示默认未处理配置
                    s.setChildTitle(parentStatus.getWaitInfo());
                    if(Constants.equalsInteger(i,Constants.SettleClaimsLogParentStatus.LS.getKey())){
//                        //报案审批通过后要显示
                        Optional<SettleClaimsLog> settleClaimsLogOptional = settleClaimsLogList.stream()
                                .filter(j->
                                        Constants.equalsInteger(j.getObjType(),Constants.SettleClaimsLogType.PLATFORM_ACCEPTANCE.getKey())
                                        || Constants.equalsInteger(j.getObjType(),Constants.SettleClaimsLogType.PLATFORM_DISCUSS_PASS.getKey())
                                ).findFirst();
                        if(settleClaimsLogOptional.isPresent()){
                            s.setStatus(Constants.ONE);
                            settleParentStatusVOList.add(s);
                            continue;
                        }
                    }
                    s.setStatus(Constants.TWO);
                }else{
                    //如果是等于父状态 则去查询实际的业务状态
                    if(Constants.equalsInteger(i,optionalInteger.get())){
                        Optional<SettleClaimsLog> settleClaimsLogOptional = settleClaimsLogList.stream()
                                .filter(j->Constants.equalsInteger(j.getParentStatus(),optionalInteger.get())).findFirst();
                        if(settleClaimsLogOptional.isPresent()){
                            s.setChildTitle(Constants.SettleClaimsLogType.getName(settleClaimsLogOptional.get().getObjType()));
                            s.setOptDate(settleClaimsLogOptional.get().getCreateDate());
                        }
                    }
                    s.setStatus(Constants.ONE);
                }
                settleParentStatusVOList.add(s);
            }
        }
        return settleParentStatusVOList;
    }



    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updHurtType(UpdHurtTypeDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || Objects.isNull(dto.getHurtType())
                || !(Constants.equalsInteger(dto.getHurtType(),Constants.ZERO) || Constants.equalsInteger(dto.getHurtType(),Constants.ONE))
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非管理员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.CONFIRM_INFORMATION.getKey(),settleClaims.getStatus())
        || Constants.equalsInteger(Constants.SettleClaimsStatus.ACCEPTANCE.getKey(),settleClaims.getStatus())
        //        || Constants.equalsInteger(Constants.SettleClaimsStatus.WAIT_DEAL.getKey(),settleClaims.getStatus())
        )){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }
        if(!Constants.equalsInteger(settleClaims.getHurtType(),Constants.TWO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"已修改过，无法再次修改");
        }
        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        update.setHurtType(dto.getHurtType());
        update.setId(settleClaims.getId());
        settleClaimsMapper.updateById(update);

        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.UPD_HURT_TYPE,
                Constants.SettleClaimsLogType.UPD_HURT_TYPE.getInfo(),null);
    }



    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updReceiveInfo(UpdReceiveInfoDTO dto){
        if(Objects.isNull(dto)
                || Objects.isNull(dto.getId())
                || StringUtils.isBlank(dto.getReceiveBank())
                || StringUtils.isBlank(dto.getReceiveAccount())
                || StringUtils.isBlank(dto.getReceiveUserName())
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if(!loginUserInfo.getType().equals(Constants.ONE)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非企业人员无法进行该操作");
        }
        SettleClaims settleClaims  = settleClaimsJoinMapper.selectById(dto.getId());
        if(Objects.isNull(settleClaims)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        //如果是企业 查询是否是自己企业的数据
        if(!Constants.equalsInteger(settleClaims.getCompanyId(),loginUserInfo.getCompanyId())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"非您企业的数据，您无法进行该操作");
        }
        if(!(Constants.equalsInteger(Constants.SettleClaimsStatus.COMPENSATION.getKey(),settleClaims.getStatus()) || Constants.equalsInteger(Constants.SettleClaimsStatus.CONFIRM_FEE.getKey(),settleClaims.getStatus()) )
        ){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，业务状态已流转~");
        }

        SettleClaims update = new SettleClaims();
        update.setEditDate(new Date());
        update.setEditor(loginUserInfo.getId());
        update.setReceiveBank(dto.getReceiveBank());
        update.setReceiveAccount(dto.getReceiveAccount());
        update.setReceiveUserName(dto.getReceiveUserName());
        update.setId(settleClaims.getId());
        settleClaimsMapper.updateById(update);

        //存储日志
        this.saveSettleClaimsLog(settleClaims,
                Constants.SettleClaimsLogType.UPD_RECEIVE_INFO,
                Constants.SettleClaimsLogType.UPD_RECEIVE_INFO.getInfo(),null);
    }



    @Override
    public List<String> getDiscussProblemType(){
       String types = systemDictDataBiz.queryByCode(Constants.PROTOCOL,Constants.DISCUSS_PROBLEM_TYPE).getCode();
       if(StringUtils.isNotBlank(types)){
           return Arrays.asList(types.split(","));
       }
       return null;
    }


    @Override
    public SettleClaimsDataVO getSettleClaimsDataVO(){
        SettleClaimsDataVO settleClaimsDataVO = new SettleClaimsDataVO();
        settleClaimsDataVO.setSettleClaimsTotal(Constants.ZERO);
        settleClaimsDataVO.setAverageSettleClaimsTime(BigDecimal.ZERO);
        settleClaimsDataVO.setSettleClaimsTotalFee(BigDecimal.ZERO);
        settleClaimsDataVO.setRefuseRata(BigDecimal.ZERO);
        settleClaimsDataVO.setAcceptanceRata(BigDecimal.ZERO);
        settleClaimsDataVO.setCloseCaseRata(BigDecimal.ZERO);


        List<SettleClaims> settleClaimsList = settleClaimsMapper.selectList(new QueryWrapper<SettleClaims>().lambda().eq(SettleClaims::getIsdeleted,Constants.ZERO));
        if(CollectionUtils.isNotEmpty(settleClaimsList)){
            Integer totalSettleClaimsNum = settleClaimsList.size();
            List<SettleClaims> closeCaseList = settleClaimsList.stream().filter(i->Objects.nonNull(i.getStatus())
                    &&Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.CLOSE_CASE.getKey())).collect(Collectors.toList());
            for (SettleClaims settleClaims:closeCaseList) {
                if(Objects.nonNull(settleClaims.getCheckDate())&&Objects.nonNull(settleClaims.getCreateDate())){
                    settleClaims.setTotalHours(
                            (int)DateUtil.getBetweenHours(settleClaims.getCreateDate(),settleClaims.getCheckDate())
                    );
                }else{
                    settleClaims.setTotalHours(Constants.ZERO);
                }
            }
            Integer closeCaseNum = closeCaseList.size();
            //未包含 立案退回 立案退回可以再次提交的
            Integer refuseNum = settleClaimsList.stream().filter(i->Objects.nonNull(i.getStatus())&&
                    (Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.REJECT_DEAL.getKey())
                            ||Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.WAIT_DISCUSS_REJECT.getKey()))
                    ).collect(Collectors.toList()).size();
            Integer acceptanceNum = settleClaimsList.stream().filter(i->Objects.nonNull(i.getStatus())&&
                    (Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.ACCEPTANCE.getKey())
                            ||Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.WAIT_AUDIT_COMPENSATION.getKey())
                            ||Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.COMPENSATION.getKey())
                            ||Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.CONFIRM_FEE.getKey())
                            ||Constants.equalsInteger(i.getStatus(),Constants.SettleClaimsStatus.CLOSE_CASE.getKey())
                    )
            ).collect(Collectors.toList()).size();
            if(Objects.nonNull(closeCaseNum)&&!Constants.equalsInteger(closeCaseNum,Constants.ZERO)){
                settleClaimsDataVO.setCloseCaseRata(new BigDecimal(closeCaseNum.toString()).divide(new BigDecimal(totalSettleClaimsNum.toString()),4,BigDecimal.ROUND_HALF_UP));
            }
            if(Objects.nonNull(refuseNum)&&!Constants.equalsInteger(refuseNum,Constants.ZERO)){
                settleClaimsDataVO.setRefuseRata(new BigDecimal(refuseNum.toString()).divide(new BigDecimal(totalSettleClaimsNum.toString()),4,BigDecimal.ROUND_HALF_UP));
            }
            if(Objects.nonNull(acceptanceNum)&&!Constants.equalsInteger(acceptanceNum,Constants.ZERO)){
                settleClaimsDataVO.setAcceptanceRata(new BigDecimal(acceptanceNum.toString()).divide(new BigDecimal(totalSettleClaimsNum.toString()),4,BigDecimal.ROUND_HALF_UP));
            }

            List<DataListVO> settleClaimsTotalList = new ArrayList<>();
            List<DataListVO> settleClaimsFeeList = new ArrayList<>();
            List<DataListVO> averageSettleClaimsList = new ArrayList<>();

            for (int i = 5; i >=0 ; i--) {
                //每个月的数据
                String monthData = DateUtil.DateToStr(DateUtil.afterDateByType(new Date(),1,i*-1),"yyyy-MM");
                DataListVO settleClaimsTotal = new DataListVO();
                DataListVO settleClaimsFee = new DataListVO();
                DataListVO averageSettleClaims = new DataListVO();

                settleClaimsTotal.setDataFirst(monthData);
                settleClaimsTotal.setDataSecond(
                        settleClaimsList.stream().filter(j->DateUtil.DateToStr(j.getCreateDate(),"yyyy-MM").equals(monthData)).collect(Collectors.toList()).toString()
                );
 
                settleClaimsFee.setDataFirst(monthData);
                List<SettleClaims> closeCaseMonthList = closeCaseList.stream().filter(j->Objects.nonNull(j.getCheckDate())&&DateUtil.DateToStr(j.getCheckDate(),"yyyy-MM").equals(monthData)).collect(Collectors.toList());
                settleClaimsFee.setDataSecond(closeCaseMonthList.stream().map(j->j.getHpAccount().add(j.getHpOtherAccount())).reduce(BigDecimal.ZERO,BigDecimal::add).toString());

                averageSettleClaims.setDataFirst(monthData);
                Integer sumHours = closeCaseMonthList.stream().map(j->
                        j.getTotalHours()).reduce(Constants.ZERO,Integer::sum);
                averageSettleClaims.setDataSecond(
                        new BigDecimal(sumHours.toString()).divide(new BigDecimal((closeCaseMonthList.size()*24)+"")).toString()
                );
 
                settleClaimsTotalList.add(settleClaimsTotal);
                settleClaimsFeeList.add(settleClaimsFee);
                averageSettleClaimsList.add(averageSettleClaims);

            }
            settleClaimsDataVO.setSettleClaimsFeeList(settleClaimsFeeList);
            settleClaimsDataVO.setAverageSettleClaimsList(averageSettleClaimsList);
            settleClaimsDataVO.setSettleClaimsTotalList(settleClaimsTotalList);

            //总理赔金额
            settleClaimsDataVO.setSettleClaimsTotalFee(closeCaseList.stream().map(i->i.getHpAccount().add(i.getHpOtherAccount())).reduce(BigDecimal.ZERO,BigDecimal::add));

            //总理赔案件数
            settleClaimsDataVO.setSettleClaimsTotal(settleClaimsList.size());
            
            //平均理赔处理时长天数 总计处理时长（单位小时）除以 记录数  换算到天
            settleClaimsDataVO.setAverageSettleClaimsTime(
                    new BigDecimal(closeCaseList.stream().map(i->i.getTotalHours()).reduce(Constants.ZERO,Integer::sum).toString())
                            .divide(new BigDecimal((closeCaseList.size()*24)+"") ,2,BigDecimal.ROUND_HALF_UP)
                            
            );

        }


        return settleClaimsDataVO;

    }










}