feat:补充提交

cjl

2023-09-26 c0c80bebcc93e90834e06404d6056322e51b02dd

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

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

import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.moral.api.config.Interceptor.UserHelper;
import com.moral.api.entity.*;
import com.moral.api.exception.BusinessException;
import com.moral.api.pojo.bean.BaseInvalidEntity;
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.vo.approvetable.ApproveTableListVo;
import com.moral.api.pojo.vo.user.QxUser;
import com.moral.api.service.AllocationExtensionService;
import com.moral.api.service.ApproveTableService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -10,26 +27,35 @@

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.*;

import javax.swing.text.AbstractDocument;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.moral.api.entity.Allocation;
import com.moral.api.entity.ApproveTable;
import com.moral.api.entity.ResponsibilityUnit;
import com.moral.api.entity.SysArea;
import com.moral.api.entity.SysDictData;
import com.moral.api.entity.SysDictType;
import com.moral.api.mapper.AllocationMapper;
import com.moral.api.mapper.ApproveTableMapper;
import com.moral.api.mapper.ResponsibilityUnitMapper;
import com.moral.api.mapper.SysAreaMapper;
import com.moral.api.mapper.SysDictDataMapper;
import com.moral.api.mapper.SysDictTypeMapper;
import com.moral.api.pojo.dto.allocation.AllocationUnitDto;
import com.moral.api.pojo.dto.allocation.AllocationUnitViewDto;
import com.moral.api.pojo.enums.AllocationApproveEnum;
import com.moral.api.pojo.vo.file.FileVo;
import com.moral.api.service.AllocationService;
import com.moral.api.service.FileTableService;
import com.moral.api.service.SysAreaService;
import com.moral.api.service.SysDictDataService;
import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
import com.moral.util.DateUtils;
@@ -51,7 +77,13 @@
    @Autowired
    private AllocationMapper allocationMapper;
    @Autowired
    private ApproveTableMapper approveTableMapper;
    private  SysAreaService sysAreaService;
    @Autowired
    private ApproveTableService approveTableService;
    @Autowired
    private FileTableService fileTableService;
    @Autowired
    private AllocationExtensionService allocationExtensionService;

    /**
     * 根据字典类型获取字典数据
@@ -92,53 +124,46 @@

    /**
     * 添加交办单
     * @param allocation
     * @param allocationCond
     * @return
     */
    @Override
    @Transactional
    public Integer insertAllocation(Allocation allocation) {
        ApproveTable approveTable = new ApproveTable();
        //获取用户信息
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
    public Integer insertAllocation(AllocationAddCond allocationCond) {
        Allocation allocation = allocationCond.convert();
        allocation.setEscalationType(AllocationEscalationTypeEnum.SELF.getValue());
        String dateString = DateUtils.dateToDateString(new Date(), DateUtils.yyyyMMdd_EN);
        QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
        Object o = redisTemplate.opsForValue().get(RedisConstants.JBD_DATA);
        int i;
        if (ObjectUtils.isEmpty(o)){
            wrapper.last("limit 1");
            Allocation selectOne = allocationMapper.selectOne(wrapper);
            String allocationNum = selectOne.getAllocationNum();
            String num = allocationNum.substring(10);
             i = Integer.parseInt(num)+1;
             i = 1;
        }else {
             i = Integer.parseInt(o.toString()) + 1;
        }
        //单号
        String allocationNum = "JBD" + dateString + String.format("%04d", i);
        String allocationNum = "JBD-" + dateString + String.format("%04d", i);
        allocation.setAllocationNum(allocationNum);
        allocation.setIsDel("0");
        allocation.setIsInvalid("0");
        allocation.setCreateId(Integer.parseInt(userInfo.get("userId").toString()));
        allocation.setCreateTime(new Date());
        allocation.setCreateName(userInfo.get("account").toString());
        allocation.setUpdateId(Integer.parseInt(userInfo.get("userId").toString()));
        allocation.setUpdateTime(new Date());
        allocation.setUpdateName(userInfo.get("account").toString());
        if(Objects.nonNull(allocationCond.getEscalationUnitId())&&allocationCond.getEscalationUnitId().toString().length()==6) {
            allocation.setEscalationType(AllocationEscalationTypeEnum.CHECK.getValue());
        }
        if(AllocationApproveEnum.NEW_BUILT.value.equals(allocationCond.getState())) {
            allocation.setState(AllocationApproveEnum.UNDER_RECTIFICATION.value);
        }
        //获取新建图片
        allocationMapper.insert(allocation);

        redisTemplate.opsForValue().set(RedisConstants.JBD_DATA,i);
        //添加流程数据
        approveTable.setRelationId(allocation.getAllocationId());
        approveTable.setState(Integer.parseInt(allocation.getState()));
        approveTable.setApproveModule(null);
        approveTable.setStateName(null);
        approveTable.setIsDel(0);
        approveTableMapper.insert(approveTable);
        return null;
        if(AllocationApproveEnum.NEW_BUILT.value.equals(allocationCond.getState())) {
            //添加流程数据
            ApproveTable approveTable = new ApproveTable();
            approveTable.setRelationId(allocation.getAllocationId());
            approveTable.setState(AllocationApproveEnum.NEW_BUILT.value);
            approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
            approveTable.setStateName(AllocationApproveEnum.NEW_BUILT.name);
            approveTableService.saveResult(approveTable);
        }
        fileTableService.upDateResult(allocationCond.getFileBaseList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_FOUNDATION.value);
        return allocation.getAllocationId();
    }


    /**
     * 查看表单
@@ -163,29 +188,36 @@
        }
        allocationUnitDto.setChangeTypeName(allocation.getChangeType()==0?"限期整改":"立即整改");
        allocationUnitDto.setInvestigationTypeName(allocation.getChangeType()==0?"现场":"无人机");

        //获取图片
        return allocationUnitDto;
    }

    /**
     * 修改交办单
     * @param allocation
     * @param allocationUpdateCond
     */
    @Override
    public void updateAll(Allocation allocation) {
        //获取用户信息
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
        if (allocation.getState().equals("1")){
            //获取整改图片
            allocation.setChangeTime(new Date());
        }else {
            //获取审核图片
            allocation.setCheckTime(new Date());
    @Transactional
    public void updateAll(AllocationUpdateCond allocationUpdateCond) {
        AllocationExt allocationExt = oneAllocation(allocationUpdateCond.getAllocationId());
        if(!AllocationApproveEnum.DRAFT.value.equals(allocationExt.getState())) {
            throw new BusinessException("新建未提交状态，才能编辑！");
        }
        allocation.setUpdateId(Integer.parseInt(userInfo.get("userId").toString()));
        allocation.setUpdateTime(new Date());
        allocation.setUpdateName(userInfo.get("account").toString());
        //获取用户信息
        Allocation allocation = allocationUpdateCond.convert();
        if(Objects.nonNull(allocationUpdateCond.getEscalationUnitId())&&allocationUpdateCond.getEscalationUnitId().toString().length()==6) {
            allocation.setEscalationType(AllocationEscalationTypeEnum.CHECK.getValue());
        }
        if(AllocationApproveEnum.NEW_BUILT.value.equals(allocationUpdateCond.getState())) {
            //添加流程数据
            ApproveTable approveTable = new ApproveTable();
            approveTable.setRelationId(allocation.getAllocationId());
            approveTable.setState(AllocationApproveEnum.NEW_BUILT.value);
            approveTable.setApproveModule(FileTableEnum.ALLOCATION_FOUNDATION.value);
            approveTable.setStateName(AllocationApproveEnum.NEW_BUILT.name);
            approveTableService.saveResult(approveTable);
        }
        fileTableService.upDateResult(allocationUpdateCond.getFileBaseList(),allocation.getAllocationId(), FileTableEnum.ALLOCATION_FOUNDATION.value);
        allocationMapper.updateById(allocation);
    }

@@ -251,4 +283,297 @@
        }
        return null;
    }


    /**
     * 表单总览
     * @param map
     * @return
     */
    @Override
    public Map<String, Object> selectUnitView(Map<String, Object> map) {
        QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
        //获取用户信息
//        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
//        Object unitId = userInfo.get("unitId");

        Integer unitId= 17;
        if (!ObjectUtils.isEmpty(unitId)){
            ResponsibilityUnit responsibilityUnit1 = responsibilityUnitMapper.selectById(unitId);
            Integer areaCode = responsibilityUnit1.getAreaCode();
            if (areaCode<999999){
                QueryWrapper<ResponsibilityUnit> wrapper1 = new QueryWrapper<>();
                wrapper1.eq("parent_code",areaCode);
                List<ResponsibilityUnit> responsibilityUnits = responsibilityUnitMapper.selectList(wrapper1);
                if (ObjectUtils.isEmpty(responsibilityUnits)){
                    return null;
                }
                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);
            }else {
                wrapper.eq("unit_id",unitId);
            }
        }

        HashMap<String, Object> rsMap = new HashMap<>();
        HashMap<String, Object> polluteMap = new HashMap<>();
        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("startTime"))){
             startTime = map.get("startTime").toString();
             endTime = map.get("endTime").toString();

        }
        if (!ObjectUtils.isEmpty(number1)){
            String s = number1.toString();
            //当前时间的
            endTime = DateUtils.getCurDateTime();
            if (s.equals("-1")){
                //当前时间的
                 startTime = DateUtils.getDateStringOfMon(Integer.parseInt(s), DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
            }
            if (s.equals("-2")){
                //当前时间的
                startTime = DateUtils.getDateStringOfMon(Integer.parseInt(s), DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
            }
            if (s.equals("-3")){
                startTime = DateUtils.getDateStringOfMon(Integer.parseInt(s), DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
            }
            if (s.equals("-6")){
                startTime = DateUtils.getDateStringOfMon(Integer.parseInt(s), DateUtils.yyyy_MM_dd_HH_mm_ss_EN);
            }
            if (s.equals("-12")){
                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;
        }
         int complete=0;
         int unComplete=0;
        for (Allocation allocation : allocations) {
            String state = allocation.getState()+"";
            if (state.equals("40")||state.equals("50")){
                 complete++;
            }else if(state.equals("10")||state.equals("20") ||state.equals("30")) {
                 unComplete++;
            }
        }
        //根据污染类型分类
        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",31);
            sysDictDataQueryWrapper.eq("dataKey",polluteType);
            SysDictData sysDictData = sysDictDataMapper.selectOne(sysDictDataQueryWrapper);
            typeMap.put("name",sysDictData.getDataValue());
            typeMap.put("value",allocations1.size());
            polluteMap.put("polluteType",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) {

                Date dateOfDay = DateUtils.getDateOfDay(allocation.getEscalationTime(), allocation.getChangeDay());
                Date date = new Date();
                String state = allocation.getState()+"";
                boolean timeBefor = DateUtils.isTimeBefor(date, dateOfDay);
                if (timeBefor && !state.equals("40") && !state.equals("50")){
                    //逾期次数
                    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",polluteMap);
        return rsMap;
    }


    /**
     * 导出
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> unitExel(Map<String, Object> map) {
        return null;
    }

    @Override
    public Page<AllocationPageExt> extPage(AllocationPageCond allocationPageCond) {
        return this.baseMapper.extPage(allocationPageCond.getPage().convertPage(), allocationPageCond);
    }

    @Override
    public AllocationExt extOne(Integer id) {
        AllocationExt allocationExt = oneAllocation(id);
        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));
        return allocationExt;
    }

    @Override
    public AllocationExt oneAllocation(Integer id){
        return this.baseMapper.extOne(id);
    }

    @Override
    @Transactional
    public void changeAllocation(AllocationChangeCond changeCond) {
        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_FOUNDATION.value);
    }

    @Override
    @Transactional
    public void checkAllocation(AllocationCheckCond checkCond) {
        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.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_FOUNDATION.value);
    }

    @Override
    @Transactional
    public boolean removeById(Integer id) {
        AllocationExt allocationExt = oneAllocation(id);
        if(!AllocationApproveEnum.DRAFT.value.equals(allocationExt.getState())) {
            throw new BusinessException("新建草稿状态，才能删除！");
        }
        this.baseMapper.deleteById(id);
        return true;
    }

    @Override
    @Transactional
    public boolean invalidResult(Integer id,String invalidReason) {
        AllocationExt allocationExt = oneAllocation(id);
        if( AllocationApproveEnum.IN_APPROVAL.value >= allocationExt.getState() ) {
            throw new BusinessException("审批结束才能作废！");
        }
        LambdaUpdateChainWrapper<Allocation> wrapper =lambdaUpdate();
        wrapper.eq(Allocation::getAllocationId,id).set(Allocation::getInvalidReason,invalidReason).set(BaseInvalidEntity::getIsInvalid, YesOrNo.YES.value);
        return wrapper.update();
    }

    @Override
    public List<AllocationListExt> extList(AllocationListCond allocationListCond) {
        return null;
    }

    @Override
    @Transactional
    public boolean applyFor(AllocationExtensionAddCond allocationExtensionAddCond) {
        AllocationExt allocationExt = oneAllocation(allocationExtensionAddCond.getAllocationId());
        boolean type = false;
        if( !AllocationApproveEnum.UNDER_RECTIFICATION.value.equals(allocationExt.getState())) {
            type = true;
        }
        if(!ChangeEnum.DEADLINE.value.equals(allocationExt.getChangeType())){
            type = true;
        }
        if(type){
            throw new BusinessException("只有限期整改类型，状态为整改中，才能发起延期申请！");
        }
        AllocationExtension allocationExtension = allocationExtensionAddCond.convert();
        allocationExtension.setState(AllocationExtensionApproveEnum.APPLYING.value);
        allocationExtensionService.save(allocationExtension);
        fileTableService.upDateResult(allocationExtensionAddCond.getFileList(),allocationExtension.getId(), FileTableEnum.ALLOCATION_EXTENSION.value);
        return true;
    }
}