package com.gkhy.exam.system.service.impl;
|
|
import cn.hutool.core.util.ObjectUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.gkhy.exam.common.api.CommonPage;
|
import com.gkhy.exam.common.api.CommonResult;
|
import com.gkhy.exam.common.exception.ApiException;
|
import com.gkhy.exam.common.utils.PageUtils;
|
import com.gkhy.exam.common.utils.SecurityUtils;
|
import com.gkhy.exam.system.domain.ExpectContent;
|
import com.gkhy.exam.system.domain.ExpectContentMess;
|
import com.gkhy.exam.system.domain.ExpectDiscren;
|
import com.gkhy.exam.system.domain.ExpectEvaluate;
|
import com.gkhy.exam.system.mapper.ExpectContentMapper;
|
import com.gkhy.exam.system.mapper.ExpectDiscrenMapper;
|
import com.gkhy.exam.system.mapper.ExpectEvaluateMapper;
|
import com.gkhy.exam.system.service.ExpectDiscrenService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
@Service
|
public class ExpectDiscrenServiceImpl extends ServiceImpl<ExpectDiscrenMapper, ExpectDiscren> implements ExpectDiscrenService {
|
|
@Autowired
|
private ExpectDiscrenMapper expectDiscrenMapper;
|
|
@Autowired
|
private ExpectContentMapper expectContentMapper;
|
|
@Autowired
|
private ExpectEvaluateMapper expectEvaluateMapper;
|
|
|
@Override
|
public CommonPage selectExpectDiscrenList(ExpectDiscren expectDiscren) {
|
if (!SecurityUtils.adminUser()){
|
if (expectDiscren.getCompanyId()==null){
|
throw new ApiException("非管理员操作，企业id不可为空");
|
}
|
}
|
PageUtils.startPage();
|
List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectDiscrenList(expectDiscren);
|
for (ExpectDiscren discren : expectDiscrens) {
|
List<ExpectContent> expectContents = expectContentMapper.selectByDiscrenId(discren.getId());
|
for (ExpectContent expectContent : expectContents) {
|
List<ExpectContentMess> expectContentMesses = expectContentMapper.selectByContentId(expectContent.getId());
|
expectContent.setExpectContentMesses(expectContentMesses);
|
}
|
discren.setExpectContents(expectContents);
|
}
|
return CommonPage.restPage(expectDiscrens);
|
}
|
|
@Override
|
@Transactional
|
public CommonResult insertExpectDiscren(ExpectDiscren expectDiscren) {
|
List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectCompanyIdAndDeptId(expectDiscren);
|
if (expectDiscrens.size()>0){
|
throw new ApiException("当前企业已有数据，请删除后重试");
|
}
|
expectDiscren.setCreateBy(SecurityUtils.getUsername());
|
expectDiscren.setCreateTime(LocalDateTime.now());
|
expectDiscrenMapper.insert(expectDiscren);
|
List<ExpectContent> expectContents = expectDiscren.getExpectContents();
|
//循环新增相关方需求
|
List<ExpectContentMess> expectContentMesseslist = new ArrayList<>();
|
for (ExpectContent expectContent : expectContents) {
|
|
expectContent.setExpectDiscrenId(expectDiscren.getId());
|
expectContentMapper.insert(expectContent);
|
|
//循环新增相关方需求详细内容
|
List<ExpectContentMess> expectContentMesses = expectContent.getExpectContentMesses();
|
for (ExpectContentMess expectContentMess : expectContentMesses) {
|
expectContentMess.setExpectContentId(expectContent.getId());
|
}
|
expectContentMesseslist.addAll(expectContentMesses);
|
}
|
expectContentMapper.insertContentMess(expectContentMesseslist);
|
|
return CommonResult.success();
|
}
|
|
@Override
|
public CommonResult updateExpectDiscren(ExpectDiscren expectDiscren) {
|
expectDiscren.setUpdateBy(SecurityUtils.getUsername());
|
expectDiscren.setUpdateTime(LocalDateTime.now());
|
expectDiscrenMapper.updateById(expectDiscren);
|
List<ExpectContent> expectContents = expectDiscren.getExpectContents();
|
expectContentMapper.deletedByDiscrenId(expectDiscren.getId());
|
List<ExpectContentMess> expectContentMesses = new ArrayList<>();
|
for (ExpectContent expectContent : expectContents) {
|
expectContent.setId(null);
|
expectContentMapper.insert(expectContent);
|
List<ExpectContentMess> expectContentMesses1 = expectContent.getExpectContentMesses();
|
for (ExpectContentMess expectContentMess : expectContentMesses1) {
|
expectContentMess.setExpectContentId(expectContent.getId());
|
}
|
expectContentMesses.addAll(expectContentMesses1);
|
}
|
expectContentMapper.insertContentMess(expectContentMesses);
|
return CommonResult.success();
|
}
|
|
@Override
|
public CommonResult deletedExpectDiscren(Integer expectDiscrenId) {
|
ExpectDiscren expectDiscren = new ExpectDiscren();
|
expectDiscren.setId(expectDiscrenId);
|
expectDiscren.setUpdateBy(SecurityUtils.getUsername());
|
expectDiscren.setUpdateTime(LocalDateTime.now());
|
expectDiscren.setDelFlag(2);
|
expectDiscrenMapper.updateById(expectDiscren);
|
return CommonResult.success();
|
}
|
|
@Override
|
public CommonResult selectExpectDiscrenListAll(ExpectDiscren expectDiscren) {
|
List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectDiscrenList(expectDiscren);
|
for (ExpectDiscren discren : expectDiscrens) {
|
List<ExpectContent> expectContents = expectContentMapper.selectByDiscrenId(discren.getId());
|
for (ExpectContent expectContent : expectContents) {
|
List<ExpectContentMess> expectContentMesses = expectContentMapper.selectByContentId(expectContent.getId());
|
expectContent.setExpectContentMesses(expectContentMesses);
|
}
|
discren.setExpectContents(expectContents);
|
}
|
return CommonResult.success(expectDiscrens);
|
}
|
|
@Override
|
@Transactional
|
public CommonResult copyExpectDiscren(Long companyId,String sourceYear, String targetYear) {
|
if (companyId==null){
|
companyId = SecurityUtils.getCompanyId();
|
}
|
LambdaQueryWrapper<ExpectDiscren> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.eq(ExpectDiscren::getCompanyId, companyId)
|
.eq(ExpectDiscren::getDelFlag, 1).eq(ExpectDiscren::getYear, targetYear);
|
List<ExpectDiscren> expectDiscrensTarget = expectDiscrenMapper.selectList(queryWrapper);
|
if (ObjectUtil.isNotEmpty(expectDiscrensTarget)){
|
for (ExpectDiscren expectDiscren : expectDiscrensTarget) {
|
deletedExpectDiscren(expectDiscren.getId());
|
LambdaQueryWrapper<ExpectContent> queryWrapperContent = new LambdaQueryWrapper<>();
|
queryWrapperContent.eq(ExpectContent::getExpectDiscrenId, expectDiscren.getId());
|
List<ExpectContent> expectContents = expectContentMapper.selectList(queryWrapperContent);
|
expectContentMapper.deletedByDiscrenId(expectDiscren.getId());
|
if (ObjectUtil.isNotEmpty(expectContents)){
|
expectContentMapper.deletedByConentId(expectDiscren.getId());
|
}
|
|
LambdaUpdateWrapper<ExpectEvaluate> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.set(ExpectEvaluate::getDelFlag, 2).set(ExpectEvaluate::getUpdateBy, SecurityUtils.getUsername())
|
.eq(ExpectEvaluate::getUpdateTime, LocalDateTime.now()).eq(ExpectEvaluate::getExpectDiscrenId, expectDiscren.getId());
|
expectEvaluateMapper.update(new ExpectEvaluate(), updateWrapper);
|
}
|
}
|
|
LambdaQueryWrapper<ExpectDiscren> queryWrapperSource = new LambdaQueryWrapper<>();
|
queryWrapperSource.eq(ExpectDiscren::getCompanyId, companyId)
|
.eq(ExpectDiscren::getDelFlag, 1).eq(ExpectDiscren::getYear, sourceYear);
|
List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectList(queryWrapperSource);
|
if (ObjectUtil.isEmpty(expectDiscrens)){
|
return CommonResult.success("无相关数据");
|
}
|
for (ExpectDiscren expectDiscren : expectDiscrens) {
|
Integer oldId = expectDiscren.getId();
|
expectDiscren.setId(null);
|
expectDiscren.setYear(targetYear);
|
expectDiscren.setCreateBy(SecurityUtils.getUsername());
|
expectDiscren.setCreateTime(LocalDateTime.now());
|
expectDiscren.setUpdateBy(SecurityUtils.getUsername());
|
expectDiscren.setUpdateTime(LocalDateTime.now());
|
expectDiscren.setFictionTime(LocalDateTime.now());
|
expectDiscrenMapper.insert(expectDiscren);
|
List<ExpectContent> expectContents = expectContentMapper.selectByDiscrenId(oldId);
|
if (ObjectUtil.isNotEmpty(expectContents)){
|
for (ExpectContent expectContent : expectContents) {
|
List<ExpectContentMess> expectContentMesses = expectContentMapper.selectByContentId(expectContent.getId());
|
expectContent.setId(null);
|
expectContent.setExpectDiscrenId(expectDiscren.getId());
|
expectContentMapper.insert(expectContent);
|
|
if (ObjectUtil.isNotEmpty(expectContentMesses)){
|
for (ExpectContentMess expectContentMess : expectContentMesses) {
|
expectContentMess.setId(null);
|
expectContentMess.setExpectContentId(expectContent.getId());
|
}
|
expectContentMapper.insertContentMess(expectContentMesses);
|
}
|
|
}
|
}
|
|
LambdaQueryWrapper<ExpectEvaluate> queryWrapper1 = new LambdaQueryWrapper<>();
|
queryWrapper1.eq(ExpectEvaluate::getExpectDiscrenId, oldId).eq(ExpectEvaluate::getDelFlag, 1);
|
List<ExpectEvaluate> expectEvaluates = expectEvaluateMapper.selectList(queryWrapper1);
|
if (ObjectUtil.isNotEmpty(expectEvaluates)){
|
for (ExpectEvaluate expectEvaluate : expectEvaluates) {
|
expectEvaluate.setId(null);
|
expectEvaluate.setExpectDiscrenId(expectDiscren.getId());
|
expectEvaluate.setCreateBy(SecurityUtils.getUsername());
|
expectEvaluate.setCreateTime(LocalDateTime.now());
|
expectEvaluate.setUpdateBy(SecurityUtils.getUsername());
|
expectEvaluate.setUpdateTime(LocalDateTime.now());
|
expectEvaluate.setEvaluateTime(LocalDateTime.now());
|
expectEvaluateMapper.insert(expectEvaluate);
|
}
|
}
|
|
}
|
return CommonResult.success();
|
}
|
}
|
