复制功能

heheng

5 days ago 3134991a6c9315421ff3d4b3b4f1bd76bb5dbdc9

 multi-system/src/main/java/com/gkhy/exam/system/service/impl/ExpectDiscrenServiceImpl.java

@@ -1,5 +1,8 @@
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;
@@ -9,8 +12,10 @@
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;
@@ -28,6 +33,9 @@

    @Autowired
    private ExpectContentMapper expectContentMapper;

    @Autowired
    private ExpectEvaluateMapper expectEvaluateMapper;


    @Override
@@ -125,4 +133,88 @@
        }
        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();
    }
}