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.apache.commons.collections4.CollectionUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.ObjectUtils;
|
|
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 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.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.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;
|
import com.moral.util.TokenUtils;
|
|
|
@Service
|
@Slf4j
|
public class AllocationServiceImpl extends ServiceImpl<AllocationMapper, Allocation> implements AllocationService {
|
|
@Autowired
|
private SysDictTypeMapper sysDictTypeMapper;
|
@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;
|
|
/**
|
* 根据字典类型获取字典数据
|
* @param dictType
|
* @return
|
*/
|
@Override
|
public List<Map<String, Object>> sysDictData(String dictType) {
|
QueryWrapper<SysDictType> typeQueryWrapper = new QueryWrapper<>();
|
typeQueryWrapper.select("id").eq("name", dictType);
|
SysDictType sysDictType = sysDictTypeMapper.selectOne(typeQueryWrapper);
|
QueryWrapper<SysDictData> dataQueryWrapper = new QueryWrapper<>();
|
dataQueryWrapper.select("dataKey", "dataValue").eq("dict_type_id", sysDictType.getId()).eq("is_delete", Constants.NOT_DELETE);
|
return sysDictDataMapper.selectMaps(dataQueryWrapper);
|
}
|
|
/**
|
* 查询责任主体
|
* @return
|
*/
|
@Override
|
public List<ResponsibilityUnit> seleteUnit() {
|
QueryWrapper<ResponsibilityUnit> wrapper = new QueryWrapper<>();
|
wrapper.select("unit_name","unit_id");
|
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<ResponsibilityUnit> responsibilityUnits = responsibilityUnitMapper.selectList(wrapper);
|
return responsibilityUnits;
|
}
|
|
|
/**
|
* 添加交办单
|
* @param allocationCond
|
* @return
|
*/
|
@Override
|
@Transactional
|
public Integer insertAllocation(AllocationAddCond allocationCond) {
|
Allocation allocation = allocationCond.convert();
|
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;
|
}
|
//单号
|
String allocationNum = "JBD-" + dateString + String.format("%04d", i);
|
allocation.setAllocationNum(allocationNum);
|
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);
|
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();
|
}
|
|
/**
|
* 查看表单
|
* @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;
|
}
|
|
/**
|
* 修改交办单
|
* @param allocationUpdateCond
|
*/
|
@Override
|
@Transactional
|
public void updateAll(AllocationUpdateCond allocationUpdateCond) {
|
AllocationExt allocationExt = oneAllocation(allocationUpdateCond.getAllocationId());
|
if(!AllocationApproveEnum.DRAFT.value.equals(allocationExt.getState())) {
|
throw new BusinessException("新建未提交状态，才能编辑！");
|
}
|
//获取用户信息
|
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);
|
}
|
if(AllocationApproveEnum.NEW_BUILT.value.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());
|
QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
|
|
//责任主体
|
if (!ObjectUtils.isEmpty(unitId)){
|
wrapper.eq("unit_id",Integer.parseInt(unitId.toString()));
|
}
|
//流程状态
|
if (!ObjectUtils.isEmpty(state)){
|
wrapper.eq("state",Integer.parseInt(state.toString()));
|
}
|
//污染分类
|
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()));
|
}
|
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);
|
}
|
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) {
|
List<Integer> unitList = unitResult();
|
allocationPageCond.setUnitList(unitList);
|
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_RECTIFICATION.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.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
|
@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;
|
}
|
|
@Override
|
public List<Integer> unitResult() {
|
QxUser user = UserHelper.getCurrentUser();
|
Integer unitId = Objects.nonNull(user.getUnitId())?user.getUnitId():0;
|
List<Integer> userList = responsibilityUnitMapper.selectCodeList("JBD",user.getUserId());
|
if(CollectionUtils.isNotEmpty(userList)){
|
return new ArrayList<>();
|
}
|
userList = responsibilityUnitMapper.selectResultList(unitId);
|
if(CollectionUtils.isNotEmpty(userList)){
|
return userList;
|
}
|
return Arrays.asList(0);
|
}
|
}
|
