blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
fuliqi
2025-01-02 73caf5a7072976021f43a764ed2ad73404f4d040 
 ycl-server/src/main/java/com/ycl/platform/service/impl/TContractServiceImpl.java


@@ -4,6 +4,7 @@


import com.alibaba.excel.read.listener.PageReadListener;


import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;


import com.alibaba.fastjson2.JSON;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;


import com.baomidou.mybatisplus.core.metadata.IPage;


import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


@@ -22,6 +23,7 @@


import com.ycl.system.Result;


import com.ycl.system.page.PageUtil;


import com.ycl.utils.DateUtils;


import com.ycl.utils.SecurityUtils;


import com.ycl.utils.StringUtils;


import enumeration.ContractStatus;


import enumeration.general.RuleDeductCategoryEnum;


@@ -32,14 +34,13 @@


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;


import org.springframework.transaction.interceptor.TransactionAspectSupport;


import org.springframework.util.CollectionUtils;


import org.springframework.web.multipart.MultipartFile;




import java.io.IOException;


import java.net.URLEncoder;


import java.nio.charset.StandardCharsets;


import java.util.ArrayList;


import java.util.Arrays;


import java.util.Date;


import java.util.List;


import java.util.*;


import java.util.stream.Collectors;




/**


@@ -79,69 +80,39 @@




    private List<CalculateRule> getExcelData() {


        ArrayList<CalculateRule> list = new ArrayList<>();


        CalculateRule calculateRule1 = new CalculateRule();


        calculateRule1.setId(1);


        calculateRule1.setRuleName("视频平均在线率");


        calculateRule1.setRuleCondition("≥98%");


        calculateRule1.setMax(98D);


        calculateRule1.setDeductCategory(RuleDeductCategoryEnum.DEDUCT_POINTS);


        calculateRule1.setCalcFraction(0.00);


        list.add(calculateRule1);


        CalculateRule calculateRule2 = new CalculateRule();


        calculateRule2.setRuleName("视频平均在线率");


        calculateRule2.setRuleCondition("95%≤视频平均在线率＜98%");


        calculateRule2.setMax(97D);


        calculateRule2.setMin(95D);


        calculateRule2.setDeductCategory(RuleDeductCategoryEnum.DEDUCT_POINTS);


        calculateRule2.setCalcFraction(5.00);


        list.add(calculateRule2);


        CalculateRule calculateRule3 = new CalculateRule();


        calculateRule3.setRuleName("视频平均在线率");


        calculateRule3.setRuleCondition("90%≤视频平均在线率＜95%");


        calculateRule3.setMax(94D);


        calculateRule3.setMin(90D);


        calculateRule3.setDeductCategory(RuleDeductCategoryEnum.DEDUCT_POINTS);


        calculateRule3.setCalcFraction(10.00);


        list.add(calculateRule3);


        CalculateRule calculateRule33 = new CalculateRule();


        calculateRule33.setRuleName("视频平均在线率");


        calculateRule33.setRuleCondition("＜90%");


        calculateRule33.setMin(89D);


        calculateRule33.setDeductCategory(RuleDeductCategoryEnum.DEDUCT_POINTS);


        calculateRule33.setCalcFraction(10.00);


        list.add(calculateRule33);


        CalculateRule calculateRule4 = new CalculateRule();


        calculateRule4.setId(2);


        calculateRule4.setRuleName("前端感知源治理工作");


        calculateRule4.setRuleCondition("时钟同步（超过±3秒为不合格）");


        calculateRule4.setDeductCategory(RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY);


        calculateRule4.setCalcFraction(0.1);


        list.add(calculateRule4);


        CalculateRule calculateRule7 = new CalculateRule();


        calculateRule7.setRuleName("前端感知源治理工作");


        calculateRule7.setRuleCondition("OSD标识");


        calculateRule7.setDeductCategory(RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY);


        calculateRule7.setCalcFraction(0.1);


        list.add(calculateRule7);


        CalculateRule calculateRule6 = new CalculateRule();


        calculateRule6.setRuleName("前端感知源治理工作");


        calculateRule6.setRuleCondition("一机一档");


        calculateRule6.setDeductCategory(RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY);


        calculateRule6.setCalcFraction(0.1);


        list.add(calculateRule6);


        CalculateRule calculateRule5 = new CalculateRule();


        calculateRule5.setId(3);


        calculateRule5.setRuleName("后台系统的保障");


        calculateRule5.setRuleCondition("单次故障时长若超出72小时不足144小时的，每超出12小时（不足12小时按12小时计）");


        calculateRule5.setMax(144D);


        calculateRule5.setMin(72D);


        calculateRule5.setDeductCategory(RuleDeductCategoryEnum.MULTIPLY_POINTS_AFTER_DIVIDING_QUANTITY);


        calculateRule5.setCalcFraction(2.00);


        calculateRule5.setCalcUnit(12);


        list.add(calculateRule5);


        setTemplateRule(list,1,"设备平均在线率","≥98%",null,98D,RuleDeductCategoryEnum.DEDUCT_POINTS,0.00);


        setTemplateRule(list,null,"设备平均在线率","95%≤设备平均在线率＜98%",97D,95D,RuleDeductCategoryEnum.DEDUCT_POINTS,5.00);


        setTemplateRule(list,null,"设备平均在线率","90%≤设备平均在线率＜95%",94D,90D,RuleDeductCategoryEnum.DEDUCT_POINTS,10.00);


        setTemplateRule(list,null,"设备平均在线率","＜90%",89D,null,RuleDeductCategoryEnum.DEDUCT_POINTS,20.00);




        setTemplateRule(list,2,"前端感知源治理工作","时钟同步",null,25D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);


        setTemplateRule(list,null,"前端感知源治理工作","OSD标识",null,25D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);


        setTemplateRule(list,null,"前端感知源治理工作","一机一档",null,25D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.1);




        setTemplateRule(list,3,"对于前端点位异常情况的处理","镜头故障或污染或树枝遮挡或枪机视角偏移正常角度或补光灯应亮未亮,24小时后未修复的",48D,25D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.5);


        setTemplateRule(list,null,"对于前端点位异常情况的处理","镜头故障或污染或树枝遮挡或枪机视角偏移正常角度或补光灯应亮未亮,48小时后未修复的",null,49D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.0);




        setTemplateRule(list,4,"确保录像完整不定期对所有点位录像完整性抽查","每路视频累计丢失10分钟（含）以内",10D,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.2);


        setTemplateRule(list,null,"确保录像完整不定期对所有点位录像完整性抽查","丢失10-60 分钟（含）",60D,9D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,0.5);


        setTemplateRule(list,null,"确保录像完整不定期对所有点位录像完整性抽查","丢失1 小时-4 小时（含）",240D,59D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.0);


        setTemplateRule(list,null,"确保录像完整不定期对所有点位录像完整性抽查","丢失4 小时-12 小时（含）",720D,539D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,1.5);


        setTemplateRule(list,null,"确保录像完整不定期对所有点位录像完整性抽查","丢失12 小时以上",null,719D,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,2.0);




        setTemplateRule(list,5,"确保图片完整不定期对所有人脸车辆以及智能前端抓拍的图片完整性抽查","发现后台存储不能调取前端设备图片",null,null,RuleDeductCategoryEnum.MULTIPLY_POINTS_BY_QUANTITY,2.0);




        return list;


    }




    private static void setTemplateRule(ArrayList<CalculateRule> list,Integer id,String ruleName,String condition,Double max,Double min,RuleDeductCategoryEnum deductCategoryEnum,Double calcFraction) {


        CalculateRule calculateRule = new CalculateRule();


        calculateRule.setId(id);


        calculateRule.setRuleName(ruleName);


        calculateRule.setRuleCondition(condition);


        calculateRule.setMax(max);


        calculateRule.setMin(min);


        calculateRule.setDeductCategory(deductCategoryEnum);


        calculateRule.setCalcFraction(calcFraction);


        list.add(calculateRule);


    }


    @Override


    @Transactional


    @SneakyThrows


@@ -188,8 +159,60 @@


    }




    @Override


    public AjaxResult importRule(MultipartFile file, TContract tContract) throws IOException {




        // 获取合同Excel规则


        List<CalculateRule> list = new ArrayList<>();


        if(file!=null) {


            EasyExcel.read(file.getInputStream(), CalculateRule.class, new PageReadListener<CalculateRule>(list::addAll)).sheet().doRead();




            // 遍历父子关系


            List<CalculateRule> calculateRulesToSave = new ArrayList<>();


            for (CalculateRule calculateRule : list) {


                // 判断数据完整性


                if (ObjectUtils.isEmpty(calculateRule.getDeductCategory())) {


                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();


                    return AjaxResult.warn("请选择" + calculateRule.getRuleName() + calculateRule.getRuleCondition() + "扣分方式");


                }


                if (RuleDeductCategoryEnum.MULTIPLY_POINTS_AFTER_DIVIDING_QUANTITY.equals(calculateRule.getDeductCategory()) && ObjectUtils.isEmpty(calculateRule.getCalcUnit())) {


                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();


                    return AjaxResult.warn("请填写" + calculateRule.getRuleName() + calculateRule.getRuleCondition() + "除以数量");


                }


                if (ObjectUtils.isEmpty(calculateRule.getCalcFraction())) {


                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();


                    return AjaxResult.warn("请填写" + calculateRule.getRuleName() + calculateRule.getRuleCondition() + "扣分数值");


                }


                // 保存规则


                if (StringUtils.isNotBlank(calculateRule.getRuleName())) {


                    calculateRule.setContractId(tContract.getId().intValue());


                    calculateRule.setCreateTime(DateUtils.getNowDate());


                    calculateRule.setUpdateTime(DateUtils.getNowDate());


                    calculateRulesToSave.add(calculateRule);


                }


            }


            if (!CollectionUtils.isEmpty(calculateRulesToSave)) {


                //删除原规则


                calculateRuleService.remove(new QueryWrapper<CalculateRule>().eq("contract_id", tContract.getId()));


                // 批量保存规则


                calculateRuleService.saveBatch(calculateRulesToSave);


            }


        }


        List<CalculateMoneyRule> moneyRule = JSON.parseArray(tContract.getRuleList(), CalculateMoneyRule.class).stream().peek(


                calculateMoneyRule -> calculateMoneyRule.setContractId(tContract.getId().intValue())


        ).collect(Collectors.toList());


        if (!CollectionUtils.isEmpty(moneyRule)) {


            //删除原规则


            calculateMoneyRuleService.remove(new QueryWrapper<CalculateMoneyRule>().eq("contract_id",tContract.getId()));


            //批量保存考核结果应用规则


            calculateMoneyRuleService.saveBatch(moneyRule);


        }


        return AjaxResult.success("操作成功");


    }




    @Override


    public Result selectAll(ContractQuery query) {


        IPage<ContractVO> page = PageUtil.getPage(query, ContractVO.class);


        query.setUnitId(SecurityUtils.getUnitId());


        baseMapper.getPage(page, query);


        page.getRecords().stream().forEach(contract -> {


            Date now = new Date();