ProjectChildUtils.java

package com.zhongzhi.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhongzhi.common.constant.*;
import com.zhongzhi.common.exception.HttpException;
import com.zhongzhi.common.utils.Localstorage;
import com.zhongzhi.dao.*;
import com.zhongzhi.dto.project.CreateVocationalProjectDTO;
import com.zhongzhi.model.*;
import com.zhongzhi.service.ProjectChildUtilsService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

@Service
public class ProjectChildUtils implements ProjectChildUtilsService {

    @Autowired
    private MatchDictDAO matchDictDAO;

    @Autowired
    private ProjectDAO  projectDAO;

    @Autowired
    private ProjectOwnershipStructureDAO projectOwnershipStructureDAO;

    @Autowired
    private ProjectMaterialsDAO projectMaterialsDAO;

    @Autowired
    private ProjectMemberDAO projectMemberDAO;

    @Autowired
    private ProjectReviewDAO projectReviewDAO;

    @Autowired
    private ProjectJudgeDAO projectJudgeDAO;

    @Autowired
    private ProjectScheduleRecordDAO projectScheduleRecordDAO;

    @Autowired
    private ProjectReviewPeriodMapper projectReviewPeriodMapper;

    @Autowired
    private StudentDAO studentDAO;

    @Autowired
    private ProjectPatentMapper patentMapper;

    @Autowired
    private ProjectPaperMapper paperMapper;

    @Autowired
    private ProjectAwardMapper awardMapper;

    @Autowired
    private ProjectCopyrightMapper copyrightMapper;

    @Autowired
    private ProjectWorksMapper worksMapper;

    @Autowired
    private ProjectTrademarkMapper trademarkMapper;

    @Autowired
    private MatchCollegeCountDAO matchCollegeCountDAO;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createVocationalProject(StudentDO studentDO ,CreateVocationalProjectDTO createVocationalProjectDTO) {

        MatchDictDO matchDictDO = matchDictDAO.selectOne(new QueryWrapper<MatchDictDO>()
                .lambda()
                .eq(MatchDictDO::getMatchType, ProjectType.VOCATIONAL)
                .eq(MatchDictDO::getStatus, 1));

        if (matchDictDO == null) {
            throw new HttpException(10054);
        }

        if (new Date().before(matchDictDO.getStartTime()) || new Date().after(matchDictDO.getEndTime())) {
            throw new HttpException(10057);
        }

        ProjectDO po = projectDAO.selectOne(new QueryWrapper<ProjectDO>()
                .lambda()
                .eq(ProjectDO::getMatchId, matchDictDO.getId())
                .eq(ProjectDO::getProposerId, studentDO.getId())
                .eq(ProjectDO::getProjectType, ProjectType.VOCATIONAL));
        /**
         * 验证是否存在过项目，决赛开启编辑不需要进行验证，填写中的项目也不需要进行验证
         */
        if (po != null && po.getEditStatus() == 0 && !po.getProjectStatus().equals(ProjectStatus.UN_SUBMITTED)) {
            throw new HttpException(10040);
        }

        ProjectDO projectDO = new ProjectDO();
        BeanUtils.copyProperties(createVocationalProjectDTO, projectDO);
        projectDO.setCollege(studentDO.getCollege());

        /**
         * 第一次创建项目设置基础状态，开启编辑不需要进行设置
         */
        if (po == null) {
            projectDO.setProposerId(studentDO.getId());
            if (matchDictDO != null) {
                projectDO.setMatchId(matchDictDO.getId());
            }
            projectDO.setProjectStatus(ProjectStatus.UN_SUBMITTED);
            projectDO.setProjectSchedule(ProjectSchedule.REGISTER);
            projectDO.setProjectType(ProjectType.VOCATIONAL);
            projectDO.setProjectGroup(studentDO.getEducation());
            projectDO.setProjectAssigned(ProjectAssignStatus.NO_ASSIGNED);
            projectDO.setProjectReview(ProjectReview.TO_REVIEWED);
        }

        if (po == null) {
            projectDAO.insert(projectDO);
        } else {
            projectDO.setId(po.getId());
            projectDAO.updateById(projectDO);
        }

        /**
         * 项目材料
         */
        ProjectMaterialsDO projectMaterialsDO = projectMaterialsDAO.selectOne(new QueryWrapper<ProjectMaterialsDO>()
                .lambda()
                .eq(ProjectMaterialsDO::getProjectId, projectDO.getId()));

        ProjectMaterialsDO materialsDO = new ProjectMaterialsDO();
        materialsDO.setMaterialsName(createVocationalProjectDTO.getMaterialsName());
        materialsDO.setLanguageType(createVocationalProjectDTO.getLanguageType());
        materialsDO.setMaterialsSize(createVocationalProjectDTO.getMaterialsSize());
        materialsDO.setMaterialsType(createVocationalProjectDTO.getMaterialsType());
        materialsDO.setMaterialsUrl(createVocationalProjectDTO.getMaterialsUrl());
        materialsDO.setLanguageType("cn");
        materialsDO.setProjectId(projectDO.getId());
        if (projectMaterialsDO == null) {
            projectMaterialsDAO.insert(materialsDO);
        } else {
            materialsDO.setId(projectMaterialsDO.getId());
            projectMaterialsDAO.updateById(materialsDO);
        }

        /**
         * 项目股权
         */
        if (null != createVocationalProjectDTO.getOwnership() ) {
            List<ProjectOwnershipStructureDO> list = projectOwnershipStructureDAO.selectList(new QueryWrapper<ProjectOwnershipStructureDO>()
                    .lambda()
                    .eq(ProjectOwnershipStructureDO::getProjectId, projectDO.getId()));
            if (list != null) {
                projectOwnershipStructureDAO.delete(new QueryWrapper<ProjectOwnershipStructureDO>()
                        .lambda()
                        .eq(ProjectOwnershipStructureDO::getProjectId,projectDO.getId()));
            }

            for (ProjectOwnershipStructureDO projectOwnershipStructureDO : createVocationalProjectDTO.getOwnership()) {
                projectOwnershipStructureDO.setProjectId(projectDO.getId());
                projectOwnershipStructureDAO.insert(projectOwnershipStructureDO);
            }
        }

        /**
         * 专利
         */
        if (null != createVocationalProjectDTO.getPatent() ) {
            List<ProjectPatentDO> list = patentMapper.selectList(new QueryWrapper<ProjectPatentDO>()
                    .lambda()
                    .eq(ProjectPatentDO::getProjectId, projectDO.getId()));
            if (list != null ) {
                patentMapper.delete(new QueryWrapper<ProjectPatentDO>()
                        .lambda()
                        .eq(ProjectPatentDO::getProjectId,projectDO.getId()));            }

            for (ProjectPatentDO patentDO : createVocationalProjectDTO.getPatent()) {
                patentDO.setProjectId(projectDO.getId());
                patentMapper.insert(patentDO);
            }
        }

        /**
         * 论文
         */
        if (null != createVocationalProjectDTO.getPaper() ) {
            List<ProjectPaperDO> list = paperMapper.selectList(new QueryWrapper<ProjectPaperDO>()
                    .lambda()
                    .eq(ProjectPaperDO::getProjectId, projectDO.getId()));
            if (list != null ) {
                paperMapper.delete(new QueryWrapper<ProjectPaperDO>()
                        .lambda()
                        .eq(ProjectPaperDO::getProjectId,projectDO.getId())) ;           }

            for (ProjectPaperDO projectPaperDO : createVocationalProjectDTO.getPaper()) {
                projectPaperDO.setProjectId(projectDO.getId());
                paperMapper.insert(projectPaperDO);
            }
        }

        /**
         * 奖项
         */
        if (null != createVocationalProjectDTO.getAward() ) {
            List<ProjectAwardDO> list = awardMapper.selectList(new QueryWrapper<ProjectAwardDO>()
                    .lambda()
                    .eq(ProjectAwardDO::getProjectId, projectDO.getId()));
            if (list != null ) {
                awardMapper.delete(new QueryWrapper<ProjectAwardDO>()
                        .lambda()
                        .eq(ProjectAwardDO::getProjectId,projectDO.getId()))  ;          }

            for (ProjectAwardDO projectAwardDO : createVocationalProjectDTO.getAward()) {
                projectAwardDO.setProjectId(projectDO.getId());
                awardMapper.insert(projectAwardDO);
            }
        }

        /**
         * 软件著作权
         */
        if (null != createVocationalProjectDTO.getCopyright() ) {
            List<ProjectCopyrightDO> list = copyrightMapper.selectList(new QueryWrapper<ProjectCopyrightDO>()
                    .lambda()
                    .eq(ProjectCopyrightDO::getProjectId, projectDO.getId()));
            if (list != null ) {
                copyrightMapper.delete(new QueryWrapper<ProjectCopyrightDO>()
                        .lambda()
                        .eq(ProjectCopyrightDO::getProjectId,projectDO.getId()));            }

            for (ProjectCopyrightDO projectCopyrightDO : createVocationalProjectDTO.getCopyright()) {
                projectCopyrightDO.setProjectId(projectDO.getId());
                copyrightMapper.insert(projectCopyrightDO);
            }
        }

        /**
         * 作品著作
         */
        if (null != createVocationalProjectDTO.getWorks() ) {
            List<ProjectWorksDO> list = worksMapper.selectList(new QueryWrapper<ProjectWorksDO>()
                    .lambda()
                    .eq(ProjectWorksDO::getProjectId, projectDO.getId()));
            if (list != null ) {
                worksMapper.delete(new QueryWrapper<ProjectWorksDO>()
                        .lambda()
                        .eq(ProjectWorksDO::getProjectId,projectDO.getId())) ;           }

            for (ProjectWorksDO work : createVocationalProjectDTO.getWorks()) {
                work.setProjectId(projectDO.getId());
                worksMapper.insert(work);
            }
        }

        /**
         * 商标
         */
        if (null != createVocationalProjectDTO.getTrademark()) {
            List<ProjectTrademarkDO> list = trademarkMapper.selectList(new QueryWrapper<ProjectTrademarkDO>()
                    .lambda()
                    .eq(ProjectTrademarkDO::getProjectId, projectDO.getId()));
            if (list != null) {
                trademarkMapper.delete(new QueryWrapper<ProjectTrademarkDO>()
                        .lambda()
                        .eq(ProjectTrademarkDO::getProjectId,projectDO.getId()))  ;          }

            for (ProjectTrademarkDO projectTrademarkDO : createVocationalProjectDTO.getTrademark()) {
                projectTrademarkDO.setProjectId(projectDO.getId());
                trademarkMapper.insert(projectTrademarkDO);
            }
        }
    }


}