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.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;
|
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.*;
|
|
|
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;
|
|
|
@Service
|
@Slf4j
|
public class AllocationServiceImpl extends ServiceImpl<AllocationMapper, Allocation> implements AllocationService {
|
|
@Autowired
|
private SysDictTypeMapper sysDictTypeMapper;
|
@Autowired
|
private SysDictDataMapper sysDictDataMapper;
|
@Autowired
|
private ResponsibilityUnitMapper responsibilityUnitMapper;
|
@Autowired
|
private RedisTemplate redisTemplate;
|
@Autowired
|
private AllocationMapper allocationMapper;
|
@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);
|
}
|
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;
|
}
|
|
@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(),allocation.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.getState())){
|
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;
|
}
|
}
|
