From 68e22957db996437fa20a9a4aa5ff37c54d4056f Mon Sep 17 00:00:00 2001
From: jinpengyong <jpy123456>
Date: Wed, 27 Sep 2023 15:22:25 +0800
Subject: [PATCH] chore:补充提交
---
screen-api/src/main/java/com/moral/api/service/impl/AllocationServiceImpl.java | 470 ++++++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 389 insertions(+), 81 deletions(-)
diff --git a/screen-api/src/main/java/com/moral/api/service/impl/AllocationServiceImpl.java b/screen-api/src/main/java/com/moral/api/service/impl/AllocationServiceImpl.java
index c96615c..467cc88 100644
--- a/screen-api/src/main/java/com/moral/api/service/impl/AllocationServiceImpl.java
+++ b/screen-api/src/main/java/com/moral/api/service/impl/AllocationServiceImpl.java
@@ -1,6 +1,24 @@
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;
@@ -16,6 +34,7 @@
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
+import java.util.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -27,9 +46,7 @@
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;
@@ -38,6 +55,7 @@
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.ResponsibilityUnitService;
import com.moral.api.service.SysAreaService;
import com.moral.api.service.SysDictDataService;
import com.moral.constant.Constants;
@@ -53,17 +71,23 @@
@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 ApproveTableMapper approveTableMapper;
- @Autowired
private SysAreaService sysAreaService;
+ @Autowired
+ private ApproveTableService approveTableService;
+ @Autowired
+ private FileTableService fileTableService;
+ @Autowired
+ private AllocationExtensionService allocationExtensionService;
+ @Autowired
+ private ResponsibilityUnitService responsibilityUnitService;
/**
* ������������������������������������
@@ -104,53 +128,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();
}
-
/**
* ������������
@@ -175,29 +192,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);
}
@@ -274,30 +298,41 @@
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");
+ 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");
+// Integer unitId= 17;
+ if (ObjectUtils.isEmpty(unitId)){
+ return null;
+ }
- 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(map.get("unitId"))){
+ wrapper.in("unit_id",map.get("unitId").toString());
+ }else {
+ 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)){
- return null;
+ 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);
}
- 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<>();
+// HashMap<String, Object> polluteMap = 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");
@@ -309,12 +344,11 @@
}
if (!ObjectUtils.isEmpty(number1)){
- String s = number1.toString();
+ String s = "-"+number1;
//���������������
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")){
@@ -343,12 +377,27 @@
int complete=0;
int unComplete=0;
for (Allocation allocation : allocations) {
- String state = allocation.getState();
+ 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>> 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);
}
//������������������������
Map<Integer, List<Allocation>> polluteTypeMap = allocations.stream().collect(Collectors.groupingBy(o -> o.getPolluteType()));
@@ -363,7 +412,8 @@
SysDictData sysDictData = sysDictDataMapper.selectOne(sysDictDataQueryWrapper);
typeMap.put("name",sysDictData.getDataValue());
typeMap.put("value",allocations1.size());
- polluteMap.put("polluteType",typeMap);
+// polluteMap.put("polluteType",typeMap);
+ polluteArrayList.add(typeMap);
}
//������������������������
Map<Integer, List<Allocation>> unitMap = allocations.stream().collect(Collectors.groupingBy(o -> o.getUnitId()));
@@ -378,21 +428,23 @@
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++;
+ 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")){
+ //������������
+ overdue++;
+ }
}
if (state.equals("40")||state.equals("50")){
if (allocation.getCheckScore()>0){
@@ -416,11 +468,18 @@
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);
+ //������������
+ rsMap.put("polluteType",polluteArrayList);
+ //������������
+ rsMap.put("escalationType",escalationTypeList);
return rsMap;
}
@@ -432,6 +491,255 @@
*/
@Override
public List<Map<String, Object>> unitExel(Map<String, Object> map) {
+ QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
+ //������������������
+ 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("startTime"))){
+ startTime = map.get("startTime").toString();
+ endTime = map.get("endTime").toString();
+
+ }
+ if (!ObjectUtils.isEmpty(number1)){
+ String s = "-"+number1;
+ //���������������
+ 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;
+ }
+ //������������������������
+ 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) {
+ 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_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;
+ }
+
+ @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);
+ }
}
--
Gitblit v1.8.0