chore:权限修改提交

jinpengyong

2023-11-08 31c65cd4f338256b76efebdb2f1f29deb170969f

 screen-api/src/main/java/com/moral/api/service/impl/AllocationServiceImpl.java

@@ -1,22 +1,37 @@
package com.moral.api.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.moral.api.config.Interceptor.UserHelper;
import com.moral.api.entity.*;
import com.moral.api.exception.BusinessException;
import com.moral.api.mapper.AllocationMapper;
import com.moral.api.mapper.ResponsibilityUnitMapper;
import com.moral.api.mapper.SysDictDataMapper;
import com.moral.api.mapper.SysDictTypeMapper;
import com.moral.api.mapper.UserMapper;
import com.moral.api.pojo.bean.BaseInvalidEntity;
import com.moral.api.pojo.dto.allocation.AllocationUnitViewDto;
import com.moral.api.pojo.enums.*;
import com.moral.api.pojo.ext.allocation.AllocationExt;
import com.moral.api.pojo.ext.allocation.AllocationListExt;
import com.moral.api.pojo.ext.allocation.AllocationPageExt;
import com.moral.api.pojo.query.PageCond;
import com.moral.api.pojo.query.allocation.*;
import com.moral.api.pojo.query.allocationextension.AllocationExtensionAddCond;
import com.moral.api.pojo.query.app.AppAllocationFileCond;
import com.moral.api.pojo.query.app.AppAllocationPageCond;
import com.moral.api.pojo.vo.allocation.AllocationFindVo;
import com.moral.api.pojo.vo.app.AppAllocationFindVo;
import com.moral.api.pojo.vo.user.QxUser;
import com.moral.api.service.AllocationExtensionService;
import com.moral.api.service.ApproveTableService;
import com.moral.api.service.*;
import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
import com.moral.util.DateUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
@@ -25,43 +40,38 @@
import org.springframework.util.ObjectUtils;

import java.util.*;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.moral.api.mapper.AllocationMapper;
import com.moral.api.mapper.ResponsibilityUnitMapper;
import com.moral.api.mapper.SysDictDataMapper;
import com.moral.api.mapper.SysDictTypeMapper;
import com.moral.api.pojo.dto.allocation.AllocationUnitDto;
import com.moral.api.service.AllocationService;
import com.moral.api.service.FileTableService;
import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
import com.moral.util.DateUtils;
import com.moral.util.TokenUtils;
import java.util.stream.Collectors;


@Service
@Slf4j
public class AllocationServiceImpl extends ServiceImpl<AllocationMapper, Allocation> implements AllocationService {

    private final Integer NEW_BUILT = 10;
    @Autowired
    private SysDictTypeMapper sysDictTypeMapper;
    @Autowired
    private SysDictDataMapper sysDictDataMapper;
    @Autowired
    private ResponsibilityUnitMapper responsibilityUnitMapper;
    @Autowired
    private SysDictDataMapper sysDictDataMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private AllocationMapper allocationMapper;
    @Autowired
    private  SysAreaService sysAreaService;
    @Autowired
    private ApproveTableService approveTableService;
    @Autowired
    private FileTableService fileTableService;
    @Autowired
    private AllocationExtensionService allocationExtensionService;
    @Autowired
    private ResponsibilityUnitService responsibilityUnitService;
    @Autowired
    private SysDictTypeService sysDictTypeService;
    @Autowired
    private UserService userService;

    /**
     * 根据字典类型获取字典数据
@@ -89,11 +99,11 @@
        wrapper.eq("is_del",Constants.NOT_DELETE);
        wrapper.eq("state",0);
        wrapper.eq("is_invalid",0);

        //获取用户信息
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
        Object code = userInfo.get("code");
        if (!ObjectUtils.isEmpty(code)){
            wrapper.eq("area_code",code);
        List<Integer> unitList = unitResult();
        if (CollectionUtils.isNotEmpty(unitList)){
            wrapper.in("unit_id",unitList);
        }
        List<ResponsibilityUnit> responsibilityUnits = responsibilityUnitMapper.selectList(wrapper);
        return responsibilityUnits;
@@ -112,60 +122,34 @@
        allocation.setEscalationType(AllocationEscalationTypeEnum.SELF.getValue());
        String dateString = DateUtils.dateToDateString(new Date(), DateUtils.yyyyMMdd_EN);
        Object o = redisTemplate.opsForValue().get(RedisConstants.JBD_DATA);
        int i;
        if (ObjectUtils.isEmpty(o)){
             i = 1;
        }else {
             i = Integer.parseInt(o.toString()) + 1;
        }
        int i = ObjectUtils.isEmpty(o)?1:Integer.parseInt(o.toString()) + 1;
        //单号
        String allocationNum = "JBD" + dateString + String.format("%04d", i);
        String allocationNum = "JBD-" + dateString + String.format("%04d", i);
        allocation.setAllocationNum(allocationNum);
        if(Objects.nonNull(allocationCond.getEscalationUnitId())&&allocationCond.getEscalationUnitId().toString().length()==6) {
        if(Objects.nonNull(allocationCond.getEscalationUnitId())&& escalationType(allocationCond.getEscalationUnitId())) {
            allocation.setEscalationType(AllocationEscalationTypeEnum.CHECK.getValue());
        }
        if(NEW_BUILT.equals(allocationCond.getState())) {
            allocation.setState(AllocationApproveEnum.UNDER_RECTIFICATION.value);
        }
        //获取新建图片
        allocationMapper.insert(allocation);
        //推送数据
        userService.pushOneUser(allocation);
        redisTemplate.opsForValue().set(RedisConstants.JBD_DATA,i);
        if(AllocationApproveEnum.NEW_BUILT.value.equals(allocationCond.getState())) {
        if(NEW_BUILT.equals(allocationCond.getState())) {
            //添加流程数据
            ApproveTable approveTable = new ApproveTable();
            approveTable.setRelationId(allocation.getAllocationId());
            approveTable.setState(AllocationApproveEnum.NEW_BUILT.value);
            approveTable.setState(NEW_BUILT);
            approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
            approveTable.setStateName(AllocationApproveEnum.NEW_BUILT.name);
            approveTable.setStateName("新建");
            approveTableService.saveResult(approveTable);
        }
        fileTableService.upDateResult(allocationCond.getFileBaseList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_FOUNDATION.value);
        return allocation.getAllocationId();
    }

    /**
     * 查看表单
     * @param id
     * @return
     */
    @Override
    public AllocationUnitDto check(Integer id) {
        AllocationUnitDto allocationUnitDto = new AllocationUnitDto();
        Allocation allocation = allocationMapper.selectById(id);
        BeanUtils.copyProperties(allocation,allocationUnitDto);
        ResponsibilityUnit responsibilityUnit = responsibilityUnitMapper.selectById(allocation.getUnitId());
        allocationUnitDto.setUnitName(responsibilityUnit.getUnitName());
        allocationUnitDto.setEscalationUnitName(responsibilityUnit.getUnitName());
        Map<String, List<SysDictData>> map = (Map<String, List<SysDictData>>) redisTemplate.opsForValue().get(RedisConstants.DICT_DATA_KEY);
        List<SysDictData> contaminate = map.get("contaminate");
        for (SysDictData sysDictData : contaminate) {
            if (sysDictData.getDataKey().equals(allocation.getPolluteType().toString())){
                allocationUnitDto.setPolluteTypeName(sysDictData.getDataValue());
                break;
            }
        }
        allocationUnitDto.setChangeTypeName(allocation.getChangeType()==0?"限期整改":"立即整改");
        allocationUnitDto.setInvestigationTypeName(allocation.getChangeType()==0?"现场":"无人机");
        //获取图片
        return allocationUnitDto;
    }

    /**
     * 修改交办单
@@ -180,88 +164,340 @@
        }
        //获取用户信息
        Allocation allocation = allocationUpdateCond.convert();
        if(Objects.nonNull(allocationUpdateCond.getEscalationUnitId())&&allocationUpdateCond.getEscalationUnitId().toString().length()==6) {
        if(Objects.nonNull(allocationUpdateCond.getEscalationUnitId())&& escalationType(allocationUpdateCond.getEscalationUnitId())) {
            allocation.setEscalationType(AllocationEscalationTypeEnum.CHECK.getValue());
        }
        if(AllocationApproveEnum.NEW_BUILT.value.equals(allocationUpdateCond.getState())) {
        if(NEW_BUILT.equals(allocationUpdateCond.getState())) {
            //添加流程数据
            ApproveTable approveTable = new ApproveTable();
            approveTable.setRelationId(allocation.getAllocationId());
            approveTable.setState(AllocationApproveEnum.NEW_BUILT.value);
            approveTable.setState(NEW_BUILT);
            approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
            approveTable.setStateName(AllocationApproveEnum.NEW_BUILT.name);
            approveTable.setStateName("新建");
            approveTableService.saveResult(approveTable);
        }
        if(NEW_BUILT.equals(allocationUpdateCond.getState())) {
            allocation.setState(AllocationApproveEnum.UNDER_RECTIFICATION.value);
        }
        fileTableService.upDateResult(allocationUpdateCond.getFileBaseList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_FOUNDATION.value);
        allocationMapper.updateById(allocation);
    }





    /**
     * 根据条件查询
     * 表单总览
     * @param map
     * @return
     */
    @Override
    public List<Allocation> selectAll(Map<String, Object> map) {

        Object unitId = map.get("unitId");
        Object state = map.get("state");
        Object polluteType = map.get("polluteType");
        Object investigationType = map.get("investigationType");
        Object changeType = map.get("changeType");
        Object escalationTime = map.get("escalationTime");
        Object isInvalid = map.get("isInvalid");
//        int page = Integer.parseInt(map.get("page").toString());
//        int size = Integer.parseInt(map.get("size").toString());
    public Map<String, Object> selectUnitView(Map<String, Object> map) {
        QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
        //获取用户信息
        List<Integer> list = this.unitResult();
        if (!ObjectUtils.isEmpty(map.get("unitId"))){
            wrapper.in("unit_id",map.get("unitId").toString());
        }else {
            if (!ObjectUtils.isEmpty(list)){
                Integer integer = list.get(0);
                if (integer==0){
                    return null;
                }else {
                    wrapper.in("unit_id",list);
                }
            }
        }

        //责任主体
        if (!ObjectUtils.isEmpty(unitId)){
            wrapper.eq("unit_id",Integer.parseInt(unitId.toString()));
//        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
//        Object unitId = userInfo.get("unitId");
//        Map<String, Object> orgInfo = (Map<String, Object>) userInfo.get("organization");
//        Integer orgId = (Integer) orgInfo.get("id");
//        if (!ObjectUtils.isEmpty(map.get("unitId"))){
//            wrapper.in("unit_id",map.get("unitId").toString());
//        }else {
//            if (orgId!=24){
//                if (ObjectUtils.isEmpty(unitId)){
//                    return null;
//                }
//                ResponsibilityUnit responsibilityUnit1 = responsibilityUnitMapper.selectById(Integer.parseInt(unitId.toString()));
//                Integer areaCode = responsibilityUnit1.getAreaCode();
//                List<ResponsibilityUnit> responsibilityUnits = responsibilityUnitService.selectUnit(areaCode);
//                if (ObjectUtils.isEmpty(responsibilityUnits)){
//                    List<ResponsibilityUnit> responsibilityUnits1 = responsibilityUnitService.selectAreaUnit(areaCode);
//                    Map<Integer, List<ResponsibilityUnit>> collect = responsibilityUnits1.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
//                    List<Integer> collect1 = collect.keySet().stream().collect(Collectors.toList());
//                    wrapper.in("unit_id",collect1);
//                }else {
//                    Map<Integer, List<ResponsibilityUnit>> collect = responsibilityUnits.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
//                    List<Integer> collect1 = collect.keySet().stream().collect(Collectors.toList());
//                    wrapper.in("unit_id",collect1);
//                }
//            }
//        }

        HashMap<String, Object> rsMap = new HashMap<>();
        ArrayList<Map<String, Object>> polluteArrayList = new ArrayList<>();
        ArrayList<Map<String, Object>> escalationTypeList = new ArrayList<>();
        ArrayList<AllocationUnitViewDto> allocationUnitViewDtos = new ArrayList<>();

        Object number1 = map.get("number");
        String startTime=null;
        String endTime=null;
        if (!ObjectUtils.isEmpty(map.get("startTime")) || !ObjectUtils.isEmpty(map.get("endTime"))){
             startTime = map.get("startTime").toString();
             endTime = map.get("endTime").toString();

        }
        //流程状态
        if (!ObjectUtils.isEmpty(state)){
            wrapper.eq("state",Integer.parseInt(state.toString()));
        if (!ObjectUtils.isEmpty(number1)){
            String s = "-"+number1;
            //获取当前时间
            endTime = DateUtils.getCurDateTime();
            startTime = DateUtils.getDateStringOfMon(Integer.parseInt(s), DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
        }
        //污染分类
        if (!ObjectUtils.isEmpty(polluteType)){
            wrapper.eq("pollute_type",Integer.parseInt(polluteType.toString()));
        }
        //排查方式
        if (!ObjectUtils.isEmpty(investigationType)){
            wrapper.eq("investigation_type",Integer.parseInt(investigationType.toString()));
        }
        //整改类型
        if (!ObjectUtils.isEmpty(changeType)){
            wrapper.eq("change_type",Integer.parseInt(changeType.toString()));
        }
        //是否作废
        if (!ObjectUtils.isEmpty(isInvalid)){
            wrapper.eq("is_invalid",Integer.parseInt(isInvalid.toString()));
        }
        if (!ObjectUtils.isEmpty(escalationTime)){
//            wrapper.eq("is_invalid",Integer.parseInt(isInvalid.toString()));
        }

        wrapper.between("escalation_time",startTime,endTime);
        wrapper.eq("is_del",0);
        wrapper.eq("is_invalid",0);
        List<Allocation> allocations = allocationMapper.selectList(wrapper);
        ArrayList<AllocationUnitDto> rsList = new ArrayList<>();
        for (Allocation allocation : allocations) {
            AllocationUnitDto allocationUnitDto = new AllocationUnitDto();
            BeanUtils.copyProperties(allocation,allocationUnitDto);
            allocation.getEscalationTime();
            Date dateOfDay = DateUtils.getDateOfDay(allocation.getEscalationTime(), allocation.getChangeDay());
            Date date = new Date();
            //获取两个日期的天数
            int days = DateUtils.getDays(dateOfDay, date);
            allocationUnitDto.setChangeDay(days);
            rsList.add(allocationUnitDto);
        if (ObjectUtils.isEmpty(allocations)){
            return null;
        }
        return null;
         int complete=0;
         int unComplete=0;
        for (Allocation allocation : allocations) {
            String state = allocation.getState()+"";
            if (state.equals("40")||state.equals("50")){
                 complete++;
            }else  {
                 unComplete++;
            }
        }
        //根据上报类型分类
        Map<Integer, List<Allocation>> escalationTypeMap = allocations.stream().collect(Collectors.groupingBy(o -> o.getEscalationType()));
        Set<Integer> escalationTypes = escalationTypeMap.keySet();
        for (Integer escalationType : escalationTypes) {
            List<Allocation> allocations1 = escalationTypeMap.get(escalationType);
            String value = AllocationEscalationTypeEnum.SELF.value.toString();
            HashMap<String, Object> typeMap = new HashMap<>();
            if (value.equals(escalationType+"")){
                typeMap.put("name",AllocationEscalationTypeEnum.SELF.name);
            }else {
                typeMap.put("name",AllocationEscalationTypeEnum.CHECK.name);
            }
            typeMap.put("value",allocations1.size());
            escalationTypeList.add(typeMap);
        }
        //根据污染类型分类
        SysDictType sysDictType = sysDictTypeService.slectFind(Constants.WU_RAN_LEI_XING);
        Map<Integer, List<Allocation>> polluteTypeMap = allocations.stream().collect(Collectors.groupingBy(o -> o.getPolluteType()));
        Set<Integer> polluteTypes = polluteTypeMap.keySet();
        for (Integer polluteType : polluteTypes) {
            HashMap<String, Object> typeMap = new HashMap<>();
            List<Allocation> allocations1 = polluteTypeMap.get(polluteType);
            QueryWrapper<SysDictData> sysDictDataQueryWrapper = new QueryWrapper<>();
            sysDictDataQueryWrapper.eq("dict_type_id",sysDictType.getId());
            sysDictDataQueryWrapper.eq("dataKey",polluteType);
            SysDictData sysDictData = sysDictDataMapper.selectOne(sysDictDataQueryWrapper);
            typeMap.put("name",sysDictData.getDataValue());
            typeMap.put("value",allocations1.size());
            polluteArrayList.add(typeMap);
        }
        //根据责任单位分类
        Map<Integer, List<Allocation>> unitMap = allocations.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
        Set<Integer> unitList = unitMap.keySet();
        //逾期次数
        int overdue=0;
        for (Integer integer : unitList) {
            //获取城市
            ResponsibilityUnit responsibilityUnit = responsibilityUnitMapper.selectById(integer);
            SysArea areaByCode = sysAreaService.getAreaByCode(responsibilityUnit.getAreaCode());
            AllocationUnitViewDto allocationUnitViewDto = new AllocationUnitViewDto();
            List<Allocation> allocations1 = unitMap.get(integer);
            //加分
            int marks=0;
            //减分
            int deduction=0;
            int number=0;
            for (Allocation allocation : allocations1) {
                String state = allocation.getState()+"";
                Integer changeType = allocation.getChangeType();
                String value = ChangeEnum.DEADLINE.value.toString();
                if (value.equals(changeType+"")){
                    Date dateOfDay = DateUtils.getDateOfDay(allocation.getEscalationTime(), allocation.getChangeDay());
                    Date date = new Date();
                    boolean timeBefor = DateUtils.isTimeBefor(date, dateOfDay);
                    if (timeBefor && !state.equals("40") && !state.equals("50") && !state.equals("9")){
                        //逾期次数
                        overdue++;
                    }
                }
                if (state.equals("40")||state.equals("50")){
                    if (allocation.getCheckScore()>0){
                        marks = marks + allocation.getCheckScore();
                    }else {
                        deduction = deduction + allocation.getCheckScore();
                    }
                    number++;
                }
            }
            int total = allocations1.size();
            allocationUnitViewDto.setDeduction(deduction);
            allocationUnitViewDto.setMarks(marks);
            allocationUnitViewDto.setTotal(total);
            allocationUnitViewDto.setTotalPoints(marks+deduction);
            allocationUnitViewDto.setNumber(number);
            String rate = (number * 100 /total)+"%";
            allocationUnitViewDto.setRate(rate);
            allocationUnitViewDto.setUnNumber(total-number);
            allocationUnitViewDto.setUnitName(areaByCode.getAreaName());
            allocationUnitViewDtos.add(allocationUnitViewDto);
        }
        rsMap.put("unitView",allocationUnitViewDtos);
        //总数
        rsMap.put("total",allocations.size());
        //已完成
        rsMap.put("complete",complete);
        //进行中
        rsMap.put("unComplete",unComplete);
        //预期
        rsMap.put("overdue",overdue);
        //污染类型
        rsMap.put("polluteType",polluteArrayList);
        //上报类型
        rsMap.put("escalationType",escalationTypeList);
        return rsMap;
    }


    /**
     * 导出
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> unitExel(Map<String, Object> map) {
        QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
        //获取用户信息
        List<Integer> list = this.unitResult();
        if (!ObjectUtils.isEmpty(map.get("unitId"))){
            wrapper.in("unit_id",map.get("unitId").toString());
        }else {
            if (!ObjectUtils.isEmpty(list)){
                Integer integer = list.get(0);
                if (integer==0){
                    return null;
                }else {
                    wrapper.in("unit_id",list);
                }
            }
        }
//        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
//        Object unitId = userInfo.get("unitId");
//        Map<String, Object> orgInfo = (Map<String, Object>) userInfo.get("organization");
//        Integer orgId = (Integer) orgInfo.get("id");
//
//        if (ObjectUtils.isEmpty(unitId)){
//            return null;
//        }
//        if (orgId!=24){
//            ResponsibilityUnit responsibilityUnit1 = responsibilityUnitMapper.selectById(Integer.parseInt(unitId.toString()));
//            Integer areaCode = responsibilityUnit1.getAreaCode();
//            List<ResponsibilityUnit> responsibilityUnits = responsibilityUnitService.selectUnit(areaCode);
//            if (ObjectUtils.isEmpty(responsibilityUnits)){
//                List<ResponsibilityUnit> responsibilityUnits1 = responsibilityUnitService.selectAreaUnit(areaCode);
//                Map<Integer, List<ResponsibilityUnit>> collect = responsibilityUnits1.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
//                List<Integer> collect1 = collect.keySet().stream().collect(Collectors.toList());
//                wrapper.in("unit_id",collect1);
//            }else {
//                Map<Integer, List<ResponsibilityUnit>> collect = responsibilityUnits.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
//                List<Integer> collect1 = collect.keySet().stream().collect(Collectors.toList());
//                wrapper.in("unit_id",collect1);
//            }
//        }

        ArrayList<Map<String, Object>> rsMap = new ArrayList<>();
        Object number1 = map.get("number");
        String startTime=null;
        String endTime=null;
        if (!ObjectUtils.isEmpty(map.get("startTime")) || !ObjectUtils.isEmpty(map.get("endTime"))){
            startTime = map.get("startTime").toString();
            endTime = map.get("endTime").toString();

        }
        if (!ObjectUtils.isEmpty(number1)){
            String s = "-"+number1;
            //获取当前时间
            endTime = DateUtils.getCurDateTime();
            startTime = DateUtils.getDateStringOfMon(Integer.parseInt(s), DateUtils.yyyy_MM_dd_HH_mm_ss_EN);

        }
        wrapper.between("escalation_time",startTime,endTime);
        wrapper.eq("is_del",0);
        wrapper.eq("is_invalid",0);
        List<Allocation> allocations = allocationMapper.selectList(wrapper);
        if (ObjectUtils.isEmpty(allocations)){
            return null;
        }
        //根据责任单位分类
        Map<Integer, List<Allocation>> unitMap = allocations.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
        Set<Integer> unitList = unitMap.keySet();
        for (Integer integer : unitList) {
//            HashMap<String, Object> map1 = new HashMap<>();
            LinkedHashMap<String, Object> map1 = new LinkedHashMap<>();
            //获取城市
            ResponsibilityUnit responsibilityUnit = responsibilityUnitMapper.selectById(integer);
            SysArea areaByCode = sysAreaService.getAreaByCode(responsibilityUnit.getAreaCode());
            List<Allocation> allocations1 = unitMap.get(integer);
            //加分
            int marks=0;
            //减分
            int deduction=0;
            int number=0;
            for (Allocation allocation : allocations1) {
                String state = allocation.getState()+"";
                if (state.equals("40")||state.equals("50")){
                    if (allocation.getCheckScore()>0){
                        marks = marks + allocation.getCheckScore();
                    }else {
                        deduction = deduction + allocation.getCheckScore();
                    }
                    number++;
                }
            }
            int total = allocations1.size();
            String rate = (number * 100 /total)+"%";

            map1.put("责任单位",areaByCode.getAreaName());
            map1.put("总工单",total);
            map1.put("完成数",number);
            map1.put("未完成数",total-number);
            map1.put("完成率",rate);
            map1.put("扣分",deduction);
            map1.put("加分",marks);
            map1.put("总得分",marks+deduction);
            rsMap.add(map1);
        }
        return rsMap;
    }

    @Override
    public Page<AllocationPageExt> extPage(AllocationPageCond allocationPageCond) {
        return this.baseMapper.extPage(allocationPageCond.getPage().convertPage(), allocationPageCond);
        List<Integer> unitList = unitResult();
        Integer codeId =  unitAreaCode();
        allocationPageCond.setUnitList(unitList);
        Page<AllocationPageExt> page =  this.baseMapper.extPage(allocationPageCond.getPage().convertPage(), allocationPageCond);
        if(CollectionUtils.isNotEmpty(page.getRecords())){
            page.getRecords().forEach(it->{
                if((CollectionUtils.isEmpty(unitList)&&codeId.equals(1))||codeId.equals(2)){
                    it.setIsApprove(1);
                }else {
                    it.setIsApprove(0);
                }
            });
        }
        return page;
    }

    @Override
@@ -270,7 +506,7 @@
        allocationExt.setFileBaseList(fileTableService.list(id,FileTableEnum.ALLOCATION_FOUNDATION.value));
        allocationExt.setFileChangeList(fileTableService.list(id,FileTableEnum.ALLOCATION_RECTIFICATION.value));
        allocationExt.setFileApproveList(fileTableService.list(id,FileTableEnum.ALLOCATION_APPROVE.value));
        allocationExt.setApproveList(approveTableService.listAll(id,FileTableEnum.ALLOCATION_FOUNDATION.value));
        allocationExt.setApproveList(approveTableService.listAll(id, FileTableEnum.ALLOCATION_FOUNDATION.value));
        return allocationExt;
    }

@@ -283,8 +519,8 @@
    @Transactional
    public void changeAllocation(AllocationChangeCond changeCond) {
        AllocationExt allocationExt = oneAllocation(changeCond.getAllocationId());
        if(!AllocationApproveEnum.NEW_BUILT.value.equals(allocationExt.getState())) {
            throw new BusinessException("新建状态，才能提交整改！");
        if(!AllocationApproveEnum.UNDER_RECTIFICATION.value.equals(allocationExt.getState())) {
            throw new BusinessException("整改状态，才能提交审批！");
        }
        Allocation allocation = new Allocation();
        allocation.setAllocationId(changeCond.getAllocationId());
@@ -294,6 +530,9 @@
        allocation.setState(changeCond.getState());
        allocation.setChangeTime(new Date());
        this.updateById(allocation);
        //推送数据
        Allocation allocation1 = this.getById(changeCond.getAllocationId());
        userService.pushOneUser(allocation1);
        //添加流程数据
        ApproveTable approveTable = new ApproveTable();
        approveTable.setRelationId(allocation.getAllocationId());
@@ -301,19 +540,20 @@
        approveTable.setStateName(AllocationApproveEnum.UNDER_RECTIFICATION.name);
        approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
        approveTableService.saveResult(approveTable);
        fileTableService.upDateResult(changeCond.getFileChangeList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_FOUNDATION.value);
        fileTableService.upDateResult(changeCond.getFileChangeList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_RECTIFICATION.value);
    }

    @Override
    @Transactional
    public void checkAllocation(AllocationCheckCond checkCond) {
        AllocationExt allocationExt = oneAllocation(checkCond.getAllocationId());
        if(!AllocationApproveEnum.UNDER_RECTIFICATION.value.equals(allocationExt.getState())) {
            throw new BusinessException("整改状态，才能提交审批！");
        if(!AllocationApproveEnum.IN_APPROVAL.value.equals(allocationExt.getState())) {
            throw new BusinessException("审批状态，才能进行审批操作！");
        }
        QxUser qxUser = UserHelper.getCurrentUser();
        Allocation allocation = new Allocation();
        allocation.setCheckScore(checkCond.getCheckScore());
        allocation.setAllocationId(checkCond.getAllocationId());
        allocation.setCheckDescribe(checkCond.getCheckDescribe());
        allocation.setCheckName(qxUser.getUserName());
        allocation.setCheckTime(new Date());
@@ -331,7 +571,7 @@
        }
        approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
        approveTableService.saveResult(approveTable);
        fileTableService.upDateResult(checkCond.getFileApproveList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_FOUNDATION.value);
        fileTableService.upDateResult(checkCond.getFileApproveList(),checkCond.getAllocationId(), FileTableEnum.ALLOCATION_APPROVE.value);
    }

    @Override
@@ -370,7 +610,7 @@
        if( !AllocationApproveEnum.UNDER_RECTIFICATION.value.equals(allocationExt.getState())) {
            type = true;
        }
        if(!ChangeEnum.DEADLINE.value.equals(allocationExt.getState())){
        if(!ChangeEnum.DEADLINE.value.equals(allocationExt.getChangeType())){
            type = true;
        }
        if(type){
@@ -378,8 +618,304 @@
        }
        AllocationExtension allocationExtension = allocationExtensionAddCond.convert();
        allocationExtension.setState(AllocationExtensionApproveEnum.APPLYING.value);
        allocationExtension.setExtensionOldNum(allocationExt.getChangeDay());
        allocationExtensionService.save(allocationExtension);
        fileTableService.upDateResult(allocationExtensionAddCond.getFileList(),allocationExtension.getId(), FileTableEnum.ALLOCATION_EXTENSION.value);
        return true;
    }

    @Override
    public List<AllocationFindVo> selectSmallRoutine(Integer state,String startTime,String endTime) {
        ArrayList<AllocationFindVo> allocationFindVos = new ArrayList<>();
        LambdaQueryWrapper<Allocation> wrapper = new LambdaQueryWrapper<>();
        //获取用户信息
        List<Integer> list = unitResult();
        if (!ObjectUtils.isEmpty(list)){
            wrapper.in(Allocation::getUnitId,list);
        }
        Integer integer = unitAreaCode();
        // 管理员
        if (integer==1){
            if (state==3){
                wrapper.in(Allocation::getState,AllocationApproveEnum.PASS.value,AllocationApproveEnum.REFUSE.value);
            }else if (state==1){
                wrapper.in(Allocation::getState,AllocationApproveEnum.UNDER_RECTIFICATION.value,AllocationApproveEnum.DRAFT.value,AllocationApproveEnum.IN_APPROVAL.value);
            }else {
                wrapper.eq(Allocation::getState,0);
            }
        }else if(integer == 0) {
            if (state==3){
                wrapper.in(Allocation::getState,AllocationApproveEnum.PASS.value,AllocationApproveEnum.REFUSE.value);
            }else if (state==2){
                wrapper.eq(Allocation::getState,AllocationApproveEnum.IN_APPROVAL.value);
            }else if (state==1){
                wrapper.in(Allocation::getState,AllocationApproveEnum.UNDER_RECTIFICATION.value,AllocationApproveEnum.DRAFT.value);
            }
        }else if(integer == 2){
            if (state==3){
                wrapper.in(Allocation::getState,AllocationApproveEnum.PASS.value,AllocationApproveEnum.REFUSE.value);
            }else if (state==2){
                wrapper.in(Allocation::getState,AllocationApproveEnum.UNDER_RECTIFICATION.value,AllocationApproveEnum.DRAFT.value);
            }else if (state==1){
                wrapper.eq(Allocation::getState,AllocationApproveEnum.IN_APPROVAL.value);
            }
        }
        if (!ObjectUtils.isEmpty(startTime) && !ObjectUtils.isEmpty(endTime)){
            wrapper.between(Allocation::getEscalationTime,startTime,endTime);
        }
        wrapper.eq(Allocation::getIsDel,0).eq(Allocation::getIsInvalid,0);
        wrapper.orderByDesc(Allocation::getEscalationTime,Allocation::getAllocationId);
        List<Allocation> allocations = allocationMapper.selectList(wrapper);
        for (Allocation allocation : allocations) {
            AllocationFindVo allocationFindVo = new AllocationFindVo();
            BeanUtils.copyProperties(allocation,allocationFindVo);
            Integer state1 = allocationFindVo.getState();
            if ( integer==2){
                if (state1.equals(AllocationApproveEnum.DRAFT.value)||state1.equals(AllocationApproveEnum.UNDER_RECTIFICATION.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.TO_BE_COMPLETED.name);
                }else if (state1.equals(AllocationApproveEnum.IN_APPROVAL.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.TO_BE_PROCESSED.name);
                }else if (state1.equals(AllocationApproveEnum.PASS.value)||state1.equals(AllocationApproveEnum.REFUSE.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.COMPLETED.name);
                }
            }else if(integer==1){
                if (state1.equals(AllocationApproveEnum.DRAFT.value)||state1.equals(AllocationApproveEnum.UNDER_RECTIFICATION.value)||state1.equals(AllocationApproveEnum.IN_APPROVAL.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.TO_BE_PROCESSED.name);
                }else if (state1.equals(AllocationApproveEnum.PASS.value)||state1.equals(AllocationApproveEnum.REFUSE.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.COMPLETED.name);
                }
            }else if(integer==0) {
                if (state1.equals(AllocationApproveEnum.DRAFT.value)||state1.equals(AllocationApproveEnum.UNDER_RECTIFICATION.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.TO_BE_PROCESSED.name);
                }else if (state1.equals(AllocationApproveEnum.IN_APPROVAL.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.TO_BE_COMPLETED.name);
                }else if (state1.equals(AllocationApproveEnum.PASS.value)||state1.equals(AllocationApproveEnum.REFUSE.value)){
                    allocationFindVo.setStateName(AppAllocationStateEnum.COMPLETED.name);
                }
            }
            allocationFindVos.add(allocationFindVo);
        }
        return allocationFindVos;
    }

    @Override
    public Page<AllocationPageExt> pageApp(AppAllocationPageCond allocationPageCond) {
        List<Integer> listUnit = unitResult();
        Integer integer = unitAreaCode();
        allocationPageCond.setUnitList(listUnit);
        allocationPageCond.setStateList(stateAllocationList(allocationPageCond.getState(),integer));
        Page<AllocationPageExt> extAppPage = this.baseMapper.extAppPage(allocationPageCond.getPage().convertPage(),allocationPageCond);
        extAppPage.getRecords().forEach(it->{
            Integer state = it.getState();
            if (state.equals(AllocationApproveEnum.DRAFT.value)||state.equals(AllocationApproveEnum.UNDER_RECTIFICATION.value)){
                if(integer==0||integer==1){
                    it.setStateName(AppAllocationStateEnum.TO_BE_PROCESSED.name);
                }else if(integer==2){
                    it.setStateName(AppAllocationStateEnum.TO_BE_COMPLETED.name);
                }
            }else if(state.equals(AllocationApproveEnum.IN_APPROVAL.value)){
                if(integer==2||integer==1){
                    it.setStateName(AppAllocationStateEnum.TO_BE_PROCESSED.name);
                }else if(integer==0){
                    it.setStateName(AppAllocationStateEnum.TO_BE_COMPLETED.name);
                }
            }else{
                it.setStateName(AppAllocationStateEnum.COMPLETED.name);
            }
        });

        return extAppPage;
    }

    @Override
    @Transactional
    public boolean saveFile(AppAllocationFileCond appAllocationFileCond) {
        fileTableService.upDateResult(Arrays.asList(appAllocationFileCond.getFile()),appAllocationFileCond.getUserId(), FileTableEnum.APP_ALLOCATION.value);
        return true;
    }

    private List<Integer> stateAllocationList(Integer type, Integer integer){
        List<Integer> integerList = new ArrayList<>();
        // type 0 全部 1待办 2待处理 3 已完成
        if(integer.equals(0)){
            if(type.equals(1)){
                integerList.add(AllocationApproveEnum.UNDER_RECTIFICATION.value);
                integerList.add(AllocationApproveEnum.DRAFT.value);
            }else if(type.equals(2)){
                integerList.add(AllocationApproveEnum.IN_APPROVAL.value);
            }
        }else if(integer.equals(2)){
            if(type.equals(1)){
                integerList.add(AllocationApproveEnum.IN_APPROVAL.value);
            }else if(type.equals(2)){
                integerList.add(AllocationApproveEnum.UNDER_RECTIFICATION.value);
                integerList.add(AllocationApproveEnum.DRAFT.value);
            }
        }else if(integer.equals(1)){
            if(type.equals(1)){
                integerList.add(AllocationApproveEnum.IN_APPROVAL.value);
                integerList.add(AllocationApproveEnum.UNDER_RECTIFICATION.value);
                integerList.add(AllocationApproveEnum.DRAFT.value);
            }else if(type.equals(2)){
                integerList.add(0);
            }
        }
        if(type.equals(3)){
            integerList.add(AllocationApproveEnum.PASS.value);
            integerList.add(AllocationApproveEnum.REFUSE.value);
        }
        return integerList;
    }

    /**
     * 小程序整改
     *
     * @param changeCond
     */
    @Override
    @Transactional
    public void changeSmallRoutine(AllocationChangeCond changeCond) {
        Integer integer = unitAreaCode();
        if (integer==2){
            throw new BusinessException("此账户只能审核，不能整改！");
        }
        AllocationExt allocationExt = oneAllocation(changeCond.getAllocationId());
        if(!AllocationApproveEnum.UNDER_RECTIFICATION.value.equals(allocationExt.getState())) {
            throw new BusinessException("整改状态，才能提交审批！");
        }
        Allocation allocation = new Allocation();
        allocation.setAllocationId(changeCond.getAllocationId());
        allocation.setIsChange(changeCond.getIsChange());
        allocation.setChangeName(changeCond.getChangeName());
        allocation.setChangeDescribe(changeCond.getChangeDescribe());
        allocation.setState(changeCond.getState());
        allocation.setChangeTime(new Date());
        this.updateById(allocation);
        //添加流程数据
        ApproveTable approveTable = new ApproveTable();
        approveTable.setRelationId(allocation.getAllocationId());
        approveTable.setState(AllocationApproveEnum.UNDER_RECTIFICATION.value);
        approveTable.setStateName(AllocationApproveEnum.UNDER_RECTIFICATION.name);
        approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
        approveTableService.saveResult(approveTable);
        fileTableService.upDateResult(changeCond.getFileChangeList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_RECTIFICATION.value);
    }

    /**
     * 小程序审批
     *
     * @param checkCond
     */
    @Override
    @Transactional
    public void checkSmallRoutine(AllocationCheckCond checkCond) {
        Integer integer = unitAreaCode();
        if (integer==0){
            throw new BusinessException("此账户只能整改，不能审批！");
        }
        AllocationExt allocationExt = oneAllocation(checkCond.getAllocationId());
        if(!AllocationApproveEnum.IN_APPROVAL.value.equals(allocationExt.getState())) {
            throw new BusinessException("审批状态，才能进行审批操作！");
        }
        QxUser qxUser = UserHelper.getCurrentUser();
        Allocation allocation = new Allocation();
        allocation.setCheckScore(checkCond.getCheckScore());
        allocation.setAllocationId(checkCond.getAllocationId());
        allocation.setCheckDescribe(checkCond.getCheckDescribe());
        allocation.setCheckName(qxUser.getUserName());
        allocation.setCheckTime(new Date());
        allocation.setState(checkCond.getState());
        this.updateById(allocation);
        //添加流程数据
        ApproveTable approveTable = new ApproveTable();
        approveTable.setRelationId(allocation.getAllocationId());
        if(AllocationApproveEnum.PASS.value.equals(checkCond.getState())){
            approveTable.setState(AllocationApproveEnum.PASS.value);
            approveTable.setStateName(AllocationApproveEnum.PASS.name);
        }else {
            approveTable.setState(AllocationApproveEnum.REFUSE.value);
            approveTable.setStateName(AllocationApproveEnum.REFUSE.name);
        }
        approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
        approveTableService.saveResult(approveTable);
        fileTableService.upDateResult(checkCond.getFileApproveList(),checkCond.getAllocationId(), FileTableEnum.ALLOCATION_APPROVE.value);
    }

    @Override
    public Integer authority(String allocationNum,Integer userId) {
        //获取用户信息
        QxUser user = UserHelper.getCurrentUser();
        //获取交办单信息
        LambdaQueryWrapper<Allocation> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Allocation::getAllocationNum,allocationNum);
        wrapper.eq(Allocation::getIsDel,0);
        wrapper.eq(Allocation::getIsInvalid,0);
        Allocation allocation = allocationMapper.selectOne(wrapper);

        List<Integer> userList = responsibilityUnitMapper.selectCodeList(SysDictTypeEnum.SYS_JBD.getValue(),user.getUserId());
        if(CollectionUtils.isNotEmpty(userList)){
            //可以看，可以填
            return 1;
        }
        if(Objects.nonNull(user.getUnitId())&&user.getUnitId()!=0){
            String code = responsibilityUnitMapper.selectAreaCode(user.getUnitId());
            if (code.length() > 6 && allocation.getUnitId().equals(user.getUnitId())) {
                if (allocation.getState().equals(AllocationApproveEnum.UNDER_RECTIFICATION.value)){
                    return 1;
                }else{
                    return 2;
                }

            } else if (code.length() <= 6){
                if (allocation.getState().equals(AllocationApproveEnum.IN_APPROVAL.value)){
                    return 1;
                }else{
                    return 2;
                }
            }
        }
        //不能看，不能填
        return 3;
    }

    @Override
    public List<Integer>  unitResult() {
        QxUser user = UserHelper.getCurrentUser();
        Integer unitId = Objects.nonNull(user.getUnitId())?user.getUnitId():0;
        List<Integer> userList = responsibilityUnitMapper.selectCodeList(SysDictTypeEnum.SYS_JBD.getValue(),user.getUserId());
        if(CollectionUtils.isNotEmpty(userList)){
            return new ArrayList<>();
        }
        userList = responsibilityUnitMapper.selectResultList(unitId);
        if(CollectionUtils.isNotEmpty(userList)){
            return userList;
        }
        return Arrays.asList(0);
    }

    @Override
    public Integer unitAreaCode() {
        QxUser user = UserHelper.getCurrentUser();
        List<Integer> userList = responsibilityUnitMapper.selectCodeList(SysDictTypeEnum.SYS_JBD.getValue(),user.getUserId());
        if(CollectionUtils.isNotEmpty(userList)){
            return 1;
        }
        if(Objects.nonNull(user.getUnitId())&&user.getUnitId()!=0) {
            String code = responsibilityUnitMapper.selectAreaCode(user.getUnitId());
            if (code.length() > 6) {
                return 0;
            } else {
                return 2;
            }
        }
        return 0;
    }
    private boolean escalationType(Integer id){
        boolean f = false;
        String code = responsibilityUnitMapper.selectAreaCode(id);
        if(code.length() == 6){
            return true;
        }
        return f;
    }
}