purchase/purchase-system/src/main/java/com/ozs/pm/service/impl/PmDemandServiceImpl.java

package com.ozs.pm.service.impl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ozs.base.domain.*;
import com.ozs.base.domain.vo.BaseExpertVo;
import com.ozs.base.service.*;
import com.ozs.common.core.domain.AjaxResult;
import com.ozs.common.enums.*;
import com.ozs.common.utils.DateUtils;
import com.ozs.common.utils.RandomUtil;
import com.ozs.common.utils.StringUtils;
import com.ozs.common.utils.bean.BeanUtils;
import com.ozs.home.domain.vo.HomeToDoQueryResVo;
import com.ozs.plan.doman.vo.responseVo.PlanQuarterResponseVo;
import com.ozs.plan.service.PlanYearsService;
import com.ozs.pm.doman.*;

import com.ozs.pm.doman.vo.requestVo.*;
import com.ozs.pm.doman.vo.responseVo.*;
import com.ozs.pm.mapper.PmDemandMapper;
import com.ozs.pm.service.*;
import com.ozs.system.domain.SysFileInfo;
import com.ozs.system.domain.SysFileRef;
import com.ozs.system.domain.vo.SysRegionVO;
import com.ozs.system.domain.vo.responseVo.SysDeptResponseVo;
import com.ozs.system.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;


/**
 * 采购需求Service业务层处理
 *
 * @author ruoyi
 * @date 2023-01-16
 */
@Service
public class PmDemandServiceImpl extends ServiceImpl<PmDemandMapper, PmDemand> implements IPmDemandService {

    @Autowired
    private PmDemandMapper pmDemandMapper;
    @Autowired
    private ISysDeptService deptService;

    @Autowired
    private ISysDictDataService dictDataService;
    @Autowired
    private SysFileService fileService;
    @Autowired
    private SysFileRefService sysFileRefService;
    @Autowired
    private IPmFlowChartService iPmFlowChartService;
    @Autowired
    private PmReleaseAnnouncementService pmReleaseAnnouncementService;
    @Autowired
    private BaseExpertService baseExpertService;
    @Autowired
    private PmDemandExpertRefService pmDemandExpertRefService;
    @Autowired
    private PmBidOpeningService pmBidOpeningService;

    @Autowired
    private PmBookBuildingService pmBookBuildingService;

    @Autowired
    private PmBidWinningService pmBidWinningService;
    @Autowired
    private PmBidFailureService pmBidFailureService;
    @Autowired
    private PmBidWinningOpeningRefService pmBidWinningOpeningRefService;
    @Autowired
    private PmContractInfoService pmContractInfoService;

    @Autowired
    private BaseAgencyService baseAgencyService;

    @Autowired
    private PmProjectConstructionService pmProjectConstructionService;

    @Autowired
    private BaseNoticeTypeService baseNoticeTypeService;

    @Autowired
    private BaseNoticeService baseNoticeService;

    @Autowired
    private PlanYearsService planYearsService;

    @Autowired
    private ISysRegionService iSysRegionService;


    /**
     * 查询采购需求
     *
     * @param demandId 采购需求主键
     * @return 采购需求
     */
    @Override
    public PmDemandResVo selectPmDemandByDemandId(Long demandId, String detailType) {
        PmDemand pmDemand = this.getById(demandId);
        if(pmDemand != null){
            PmDemandResVo vo = new PmDemandResVo();
            vo.setDemandId(demandId);
            if("1".equals(detailType)) { //项目计划

                BeanUtils.copyProperties(pmDemand, vo);

                SysDeptResponseVo sysDeptResponseVo = (SysDeptResponseVo) deptService.selectDeptById(vo.getPurchaseDeptId()).get("sysDept");
                if(sysDeptResponseVo != null){
                    vo.setPurchaseDeptName(sysDeptResponseVo.getDeptName());
                }

                String purchaseServicesName = dictDataService.selectDictLabel("purchase_services", vo.getPurchaseServices());
                if(StringUtils.isNotEmpty(purchaseServicesName)){
                    vo.setPurchaseServicesName(purchaseServicesName);
                }

                //采购需求附件
                List<SysFileInfo> demandFileInfos = getSysFileInfoList(vo.getDemandId(),SysFileRefEnum.PM_DEMAND.getType());
                if(!ObjectUtils.isEmpty(demandFileInfos)){
                    vo.setDemandFileInfos(demandFileInfos);
                }

                //项目类型
                for (ProjectTypes value : ProjectTypes.values()) {
                    if (vo.getProjectType() != null && vo.getProjectType().equals(value.getCode())) {
                        vo.setProjectTypeName(value.getInfo());
                        break;
                    }
                }
                //是否为超限额计划
                for (IsExcess value : IsExcess.values()) {
                    if (vo.getIsExcess() != null && vo.getIsExcess().equals(value.getCode())) {
                        vo.setIsExcessName(value.getInfo());
                        break;
                    }
                }

                //采购方式
                for (PlanPurchaseMode value : PlanPurchaseMode.values()) {
                    if (vo.getPurchaseMode() != null && vo.getPurchaseMode().equals(value.getCode())) {
                        vo.setPurchaseModeName(value.getInfo());
                        break;
                    }
                }
                //项目属性
                for (ProjectAttribute value : ProjectAttribute.values()) {
                    if (vo.getProjectAttr() != null && vo.getProjectAttr().equals(value.getCode())) {
                        vo.setProjectAttrName(value.getInfo());
                        break;
                    }
                }
                //预警状态
                for (WarnStatus value : WarnStatus.values()) {
                    if (vo.getWarnStatus() != null && vo.getWarnStatus().equals(value.getCode())) {
                        vo.setWarnStatusName(value.getInfo());
                        break;
                    }
                }

                //项目状态
                for (PmProjectStatus value : PmProjectStatus.values()) {
                    if (vo.getProjectStatus() != null && vo.getProjectStatus().equals(value.getCode())) {
                        vo.setProjectStatusName(value.getInfo());
                        break;
                    }
                }

            } else if("2".equals(detailType)) { //需求建档

                //采购需求审核文件
                List<SysFileInfo> auditFileInfos = getSysFileInfoList(vo.getDemandId(),SysFileRefEnum.PM_DEMAND_EXAMINE.getType());
                if(!ObjectUtils.isEmpty(auditFileInfos)){
                    vo.setAuditFileInfos(auditFileInfos);
                }

                LambdaQueryWrapper<PmBookBuilding> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(PmBookBuilding::getDemandId,demandId);
                PmBookBuilding pmBookBuilding = pmBookBuildingService.getOne(lambdaQueryWrapper);
                if(pmBookBuilding != null){
                    PmBookBuildingResVo responseVo = new PmBookBuildingResVo();
                    BeanUtils.copyProperties(pmBookBuilding,responseVo);

                    List<SysFileInfo> fileInfos = getSysFileInfoList(pmBookBuilding.getId(),SysFileRefEnum.PM_BOOK_BUILDING.getType());
                    if(!ObjectUtils.isEmpty(fileInfos)){
                        responseVo.setFileInfos(fileInfos);
                    }
                    vo.setPmBookBuildingResVo(responseVo);
                }
            } else if("3".equals(detailType)) { //任务下达
                //任务下达文件
                List<SysFileInfo> taskReleaseFileInfos = getSysFileInfoList(vo.getDemandId(),SysFileRefEnum.PM_TAST_RELEASE.getType());
                if(!ObjectUtils.isEmpty(taskReleaseFileInfos)){
                    vo.setTaskReleaseFileInfos(taskReleaseFileInfos);
                }
            } else if("4".equals(detailType)) { //中标信息
                PmPurchaseExecutionResVo pmPurchaseExecutionResVo = new PmPurchaseExecutionResVo();

                //代理商信息
                BaseAgency baseAgency = this.baseAgencyService.getById(pmDemand.getAgencyId());
                pmPurchaseExecutionResVo.setBaseAgency(baseAgency);

                //发布公告列表
                LambdaQueryWrapper<PmReleaseAnnouncement> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(PmReleaseAnnouncement::getDemandId,demandId);
                List<PmReleaseAnnouncement> pmReleaseAnnouncementList = this.pmReleaseAnnouncementService.list(lambdaQueryWrapper);
                if(!ObjectUtils.isEmpty(pmReleaseAnnouncementList)){
                    List<PmReleaseAnnouncementResVo> pmReleaseAnnouncementResVoList = new ArrayList<>();
                    for (PmReleaseAnnouncement pmReleaseAnnouncement : pmReleaseAnnouncementList) {
                        PmReleaseAnnouncementResVo pmReleaseAnnouncementResVo = new PmReleaseAnnouncementResVo();
                        BeanUtils.copyProperties(pmReleaseAnnouncement,pmReleaseAnnouncementResVo);

                        List<SysFileInfo> fileInfos = getSysFileInfoList(pmReleaseAnnouncement.getId(),SysFileRefEnum.PM_ANNOUNCEMENT_FILE.getType());
                        if(!ObjectUtils.isEmpty(fileInfos)){
                            pmReleaseAnnouncementResVo.setFileInfos(fileInfos);
                        }
                        pmReleaseAnnouncementResVoList.add(pmReleaseAnnouncementResVo);
                    }
                    pmPurchaseExecutionResVo.setPmReleaseAnnouncementResVoList(pmReleaseAnnouncementResVoList);
                }

                //专家信息列表
                List<PmBaseExpertResVo> pmBaseExpertResVoList = this.pmDemandExpertRefService.getPmBaseExpertResVoList(demandId);
                pmPurchaseExecutionResVo.setPmBaseExpertResVoList(pmBaseExpertResVoList);

                //开标信息列表
                List<PmBidOpeningResVo> pmBidOpeningResVoList = this.pmBidOpeningService.getPmBidOpeningResVoList(demandId);
                pmPurchaseExecutionResVo.setPmBidOpeningResVoList(pmBidOpeningResVoList);

                //中标信息列表
                LambdaQueryWrapper<PmBidWinning> lambdaQueryWrapper1 = new LambdaQueryWrapper<>();
                lambdaQueryWrapper1.eq(PmBidWinning::getDemandId,demandId).orderByDesc(PmBidWinning::getBidAnnouncementTime);
                List<PmBidWinning> pmBidWinningList = this.pmBidWinningService.list(lambdaQueryWrapper1);
                if (!ObjectUtils.isEmpty(pmBidWinningList)) {
                    List<PmBidWinningResVo> pmBidWinningResVoList = new ArrayList<>();
                    for(PmBidWinning pmBidWinning : pmBidWinningList) {
                        PmBidWinningResVo pmBidWinningResVo = new PmBidWinningResVo();
                        BeanUtils.copyProperties(pmBidWinning, pmBidWinningResVo);
                        List<SysFileInfo> fileInfos = getSysFileInfoList(pmBidWinning.getId(),SysFileRefEnum.PM_BID_WINNING_FILE.getType());
                        if(!ObjectUtils.isEmpty(fileInfos)){
                            pmBidWinningResVo.setFileInfos(fileInfos);
                        }
                        pmBidWinningResVoList.add(pmBidWinningResVo);
                    }
                    pmPurchaseExecutionResVo.setPmBidWinningResVoList(pmBidWinningResVoList);
                }

                //质疑情况
                List<SysFileInfo> callRequestFileInfos = getSysFileInfoList(vo.getDemandId(),SysFileRefEnum.PM_BID_CALL_QEUSTION_FILE.getType());
                if(!ObjectUtils.isEmpty(callRequestFileInfos)){
                    pmPurchaseExecutionResVo.setCallRequestFileInfos(callRequestFileInfos);
                }
                //流标情况
                LambdaQueryWrapper<PmBidFailure> lambdaQueryWrapper2 = new LambdaQueryWrapper<>();
                lambdaQueryWrapper2.eq(PmBidFailure::getDemandId,demandId).orderByDesc(PmBidFailure::getBidFailureTime);
                List<PmBidFailure> pmBidFailureList = this.pmBidFailureService.list(lambdaQueryWrapper2);
                if (!ObjectUtils.isEmpty(pmBidFailureList)) {
                    List<PmBidFailureResVo> pmBidFailureResVoList = new ArrayList<>();
                    for(PmBidFailure pmBidFailure : pmBidFailureList) {
                        PmBidFailureResVo pmBidFailureResVo = new PmBidFailureResVo();
                        BeanUtils.copyProperties(pmBidFailure, pmBidFailureResVo);
                        List<SysFileInfo> fileInfos = getSysFileInfoList(pmBidFailure.getId(),SysFileRefEnum.PM_BID_FAILURE_FILE.getType());
                        if(!ObjectUtils.isEmpty(fileInfos)){
                            pmPurchaseExecutionResVo.setFileInfos(fileInfos);
                        }
                        pmBidFailureResVoList.add(pmBidFailureResVo);
                    }
                    pmPurchaseExecutionResVo.setPmBidFailureResVoList(pmBidFailureResVoList);
                }

                //中标通知书
                List<SysFileInfo> pmBidWinningNotificationFileInfos = getSysFileInfoList(vo.getDemandId(),SysFileRefEnum.PM_BID_WINNING_NOTIFICATION.getType());
                if(!ObjectUtils.isEmpty(pmBidWinningNotificationFileInfos)){
                    pmPurchaseExecutionResVo.setPmBidWinningNotificationFileInfos(pmBidWinningNotificationFileInfos);
                }

                vo.setPmPurchaseExecutionResVo(pmPurchaseExecutionResVo);

            } else if("5".equals(detailType)) { //合同信息
                LambdaQueryWrapper<PmContractInfo> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(PmContractInfo::getDemandId,demandId);
                PmContractInfo pmContractInfo = pmContractInfoService.getOne(lambdaQueryWrapper);
                if(pmContractInfo != null){
                    PmContractInfoResVo pmContractInfoResVo = new PmContractInfoResVo();
                    BeanUtils.copyProperties(pmContractInfo,pmContractInfoResVo);

                     //合同信息文件
                    List<SysFileInfo> fileInfos = getSysFileInfoList(pmContractInfo.getId(),SysFileRefEnum.PM_CONTRACT_INFO.getType());
                    if(!ObjectUtils.isEmpty(fileInfos)){
                        pmContractInfoResVo.setFileInfos(fileInfos);
                    }
                    vo.setPmContractInfoResVo(pmContractInfoResVo);
                }
            } else if("6".equals(detailType)) { //建设情况
                LambdaQueryWrapper<PmProjectConstruction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(PmProjectConstruction::getDemandId,demandId);
                PmProjectConstruction pmProjectConstruction = pmProjectConstructionService.getOne(lambdaQueryWrapper);
                if(pmProjectConstruction != null){
                    PmProjectConstructionResVo pmProjectConstructionResVo = new PmProjectConstructionResVo();
                    BeanUtils.copyProperties(pmProjectConstruction,pmProjectConstructionResVo);

                    //建设情况文件
                    List<SysFileInfo> fileInfos = getSysFileInfoList(pmProjectConstruction.getId(),SysFileRefEnum.PM_PROJECT_CONSTRUCTION.getType());
                    if(!ObjectUtils.isEmpty(fileInfos)){
                        pmProjectConstructionResVo.setFileInfos(fileInfos);
                    }
                    vo.setPmProjectConstructionResVo(pmProjectConstructionResVo);
                }

            }

            return vo;
        } else {
            return null;
        }
    }

    /**
     * 查询采购需求列表
     *
     * @param pmDemandReqVo
     * @return 采购需求
     */
    @Override
    public IPage<PmDemandResVo> selectPmDemandList(PmDemandReqVo pmDemandReqVo, int reqType) {

        LambdaQueryWrapper<PmDemand> lw = new LambdaQueryWrapper<>();
        if (!StringUtils.isBlank(pmDemandReqVo.getProjectName())) {
            lw.like(PmDemand::getProjectName, "%" + pmDemandReqVo.getProjectName() + "%");
        }
        if (!StringUtils.isBlank(pmDemandReqVo.getPurchaseServices())) {
            lw.eq(PmDemand::getPurchaseServices, pmDemandReqVo.getPurchaseServices());
        }
        if (pmDemandReqVo.getProjectStatus() != null) {
            lw.eq(PmDemand::getProjectStatus, pmDemandReqVo.getProjectStatus());
        }
        if (pmDemandReqVo.getIsExcess() != null) {
            lw.eq(PmDemand::getIsExcess, pmDemandReqVo.getIsExcess());
        }
        if (!StringUtils.isBlank(pmDemandReqVo.getBeginDate())) {
            lw.apply("(plan_demand_sub_time >= '" + pmDemandReqVo.getBeginDate() +"' or plan_purchase_finish_time >= '" + pmDemandReqVo.getBeginDate() + "' or plan_deliver_time >=  '" + pmDemandReqVo.getBeginDate() +"' )");
        }
        if (!StringUtils.isBlank(pmDemandReqVo.getEndDate())) {
            lw.apply("(plan_demand_sub_time <= '" + pmDemandReqVo.getEndDate() +"' or plan_purchase_finish_time <= '" + pmDemandReqVo.getEndDate() + "' or plan_deliver_time <=  '" + pmDemandReqVo.getEndDate() +"' )");
        }

        if(reqType== 1) { //需求审核单位列表
            lw.eq(PmDemand::getProjectStatus, PmProjectStatus.DEMAND_WAIT_AUDIT.getCode());
        } else  if(reqType== 2) { //任务下达列表
            lw.apply("(project_status = 8 or project_status = 9 )");
        } else  if(reqType== 3) { //采购执行列表
            lw.apply("(project_status = 9 or project_status = 10 or project_status = 11 or project_status = 12 or project_status = 13 or project_status = 14 or project_status = 15)");
        } else  if(reqType== 4) { //合同信息列表
            lw.apply("(project_status = 15 or project_status = 16 )");
        }  else  if(reqType== 5) { //项目建设列表
            lw.apply("(project_status = 16 or project_status = 17 )");
        }

        IPage<PmDemand> pageRes = this.page(new Page<>(pmDemandReqVo.getPageNum(), pmDemandReqVo.getPageSize()), lw);
        IPage<PmDemandResVo> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
        if(pageRes.getRecords() != null && pageRes.getRecords().size() > 0) {
            List<PmDemandResVo> pmDemandResVos = demandChangeTo(pageRes.getRecords());
            results.setRecords(pmDemandResVos);
        }

        return results;
    }


    /**
     * 需求建档
     *
     * @param vo 采购需求
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean bookBuilding(PmBookBuildingReqVo vo) throws Exception {
        PmDemand pmDemand = this.getById(vo.getDemandId());

        LambdaQueryWrapper<PmBookBuilding> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(PmBookBuilding::getDemandId,vo.getDemandId());
        PmBookBuilding pmBookBuilding = pmBookBuildingService.getOne(lambdaQueryWrapper);

        if(pmBookBuilding != null){
            vo.setId(pmBookBuilding.getId());
            BeanUtils.copyProperties(vo,pmBookBuilding);
            pmBookBuilding.setUpdateBy(vo.getUpdateBy());
            pmBookBuilding.setUpdateTime(new Date());
        } else {
            pmBookBuilding = new PmBookBuilding();
            BeanUtils.copyProperties(vo,pmBookBuilding);
            pmBookBuilding.setCreateBy(vo.getUpdateBy());
            pmBookBuilding.setCreateTime(new Date());
            pmBookBuilding.setUpdateBy(vo.getUpdateBy());
            pmBookBuilding.setUpdateTime(pmBookBuilding.getCreateTime());
        }
        if(pmBookBuildingService.saveOrUpdate(pmBookBuilding)){
            List<SysFileRef> sysFileRefs = vo.getSysFileRefs();
            uploadFile(pmBookBuilding.getId(),SysFileRefEnum.PM_BOOK_BUILDING.getType(),sysFileRefs,vo.getUpdateBy());

            pmDemand.setProjectStatus(PmProjectStatus.DEMAND_WAIT_COMMIT.getCode());
            pmDemand.setUpdateBy(vo.getUpdateBy());
            pmDemand.setUpdateTime(DateUtils.getNowDate());
            return this.updateById(pmDemand);
        } else {
            return false;
        }

    }

    private List<SysFileInfo> getSysFileInfoList(Long redId,Integer type){
        HashMap<String, Object> map = new HashMap<>();
        map.put("red_id", redId);
        map.put("type", type);
        List<SysFileRef> fileRefs = sysFileRefService.listByMap(map);
        if (!ObjectUtils.isEmpty(fileRefs)) {
            List<SysFileInfo> fileInfos = new ArrayList<>();
            for (SysFileRef ref : fileRefs) {
                SysFileInfo fileInfo = fileService.getById(ref.getFileId());
                fileInfos.add(fileInfo);
            }

            return fileInfos;
        } else {
            return null;
        }

    }


    /**
     * 查看流程图
     *
     * @param demandId 采购需求主键
     * @return 采购需求
     */
    @Override
    public Object viewFlowChart(Long demandId) {
        PmDemand pmDemand = this.getById(demandId);
        String projectStatus = String.valueOf(pmDemand.getProjectStatus());
        String moduleName = null;
        if (PmProjectStatus.DEMAND_WAIT_FILL.getCode().equals(projectStatus) || PmProjectStatus.DEMAND_AUDIT_RETURN.getCode().equals(projectStatus)) {
            moduleName = "需求填制";
        } else if(PmProjectStatus.DEMAND_WAIT_COMMIT.getCode().equals(projectStatus)) {
            moduleName = "需求提交";
        } else if(PmProjectStatus.DEMAND_WAIT_AUDIT.getCode().equals(projectStatus)) {
            moduleName = "需求审核";
        } else if(PmProjectStatus.TASK_WAIT_RELEASE.getCode().equals(projectStatus)) {
            moduleName = "任务下达";
        } else if(PmProjectStatus.WAIT_SELECT_AGENT.getCode().equals(projectStatus)) {
            moduleName = "选取代理";
        } else if(PmProjectStatus.WAIT_UPLOAD_BID_FILE.getCode().equals(projectStatus)) {
            moduleName = "上传招标文件";
        } else if(PmProjectStatus.WAIT_ANNOUNCEMENT.getCode().equals(projectStatus)) {
            moduleName = "发布公告";
        } else if(PmProjectStatus.WAIT_OPEN_BID.getCode().equals(projectStatus)) {
            moduleName = "填写专家信息,填写开标信息";
        } else if(PmProjectStatus.WAIT_BID_ANNOUNCEMENT.getCode().equals(projectStatus)) {
            moduleName = "填写中标信息";
        } else if(PmProjectStatus.BIDDING_PUBLICITY.getCode().equals(projectStatus)) {
            moduleName = "质疑处理,上传中标通知书";
        } else if(PmProjectStatus.CONTRACT_WAIT_FILL.getCode().equals(projectStatus)) {
            moduleName = "合同填制";
        } else if(PmProjectStatus.UNDER_CONSTRUCTION.getCode().equals(projectStatus)) {
            moduleName = "建设文档填制";
        } else if(PmProjectStatus.COMPLETION_CONSTRUCTION.getCode().equals(projectStatus)) {
            moduleName = "项目归档";
        }
        return moduleName;
    }

    @Override
    public PmFlowChartResVo getModuleInfo(Long demandId,String moduleName){

        LambdaQueryWrapper<PmFlowChart> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(PmFlowChart::getModuleName,moduleName);
        PmFlowChart pmFlowChart = iPmFlowChartService.getOne(lambdaQueryWrapper);
        if(pmFlowChart == null){
            return null;
        }
        PmFlowChartResVo vo = new PmFlowChartResVo();
        BeanUtils.copyProperties(pmFlowChart, vo);

        if("需求填制".equals(moduleName)) {
            List<SysFileInfo> fileInfos = getSysFileInfoList(demandId,SysFileRefEnum.PM_DEMAND.getType());
            if(!ObjectUtils.isEmpty(fileInfos)){
                vo.setFileInfos(fileInfos);
            }
        } else if("需求提交".equals(moduleName)) {
            LambdaQueryWrapper<PmBookBuilding> pmBookBuildingLambdaQueryWrapper = new LambdaQueryWrapper<>();
            pmBookBuildingLambdaQueryWrapper.eq(PmBookBuilding::getDemandId,demandId);
            PmBookBuilding pmBookBuilding = pmBookBuildingService.getOne(pmBookBuildingLambdaQueryWrapper);
            if(pmBookBuilding != null){
                List<SysFileInfo> fileInfos = getSysFileInfoList(pmBookBuilding.getId(),SysFileRefEnum.PM_BOOK_BUILDING.getType());
                if(!ObjectUtils.isEmpty(fileInfos)){
                    vo.setFileInfos(fileInfos);
                }
            }

        } else if("需求审核".equals(moduleName)) {
            List<SysFileInfo> fileInfos = getSysFileInfoList(demandId,SysFileRefEnum.PM_DEMAND_EXAMINE.getType());
            if(!ObjectUtils.isEmpty(fileInfos)){
                vo.setFileInfos(fileInfos);
            }
        } else if("任务下达".equals(moduleName)) {
            List<SysFileInfo> fileInfos = getSysFileInfoList(demandId,SysFileRefEnum.PM_TAST_RELEASE.getType());
            if(!ObjectUtils.isEmpty(fileInfos)){
                vo.setFileInfos(fileInfos);
            }
        } else if("选取代理".equals(moduleName)) {
           //do nothing
        } else if("上传招标文件".equals(moduleName)) {
            List<SysFileInfo> fileInfos = getSysFileInfoList(demandId,SysFileRefEnum.PM_BID_FILE.getType());
            if(!ObjectUtils.isEmpty(fileInfos)){
                vo.setFileInfos(fileInfos);
            }
        } else if("发布公告".equals(moduleName)) {
            LambdaQueryWrapper<PmReleaseAnnouncement> pmReleaseAnnouncementLambdaQueryWrapper = new LambdaQueryWrapper<>();
            pmReleaseAnnouncementLambdaQueryWrapper.eq(PmReleaseAnnouncement::getDemandId,demandId);
            List<PmReleaseAnnouncement> pmReleaseAnnouncementList = pmReleaseAnnouncementService.list(pmReleaseAnnouncementLambdaQueryWrapper);
            if(!ObjectUtils.isEmpty(pmReleaseAnnouncementList)) {
                List<SysFileInfo> listAll = new ArrayList<>();
                for(PmReleaseAnnouncement pmReleaseAnnouncement :pmReleaseAnnouncementList ){

                    List<SysFileInfo> fileInfos = getSysFileInfoList(pmReleaseAnnouncement.getId(),SysFileRefEnum.PM_ANNOUNCEMENT_FILE.getType());
                    if(!ObjectUtils.isEmpty(fileInfos)){
                        listAll.addAll(fileInfos);
                    }
                }
                if (!ObjectUtils.isEmpty(listAll)) {
                    vo.setFileInfos(listAll);
                }
            }
        } else if("填写专家信息".equals(moduleName)) {
            //do nothing
        } else if("填写开标信息".equals(moduleName)) {
            //do nothing
        } else if("填写中标信息".equals(moduleName)) {
            List<SysFileInfo> listAll = new ArrayList<>();

            LambdaQueryWrapper<PmBidWinning> pmBidWinningLambdaQueryWrapper = new LambdaQueryWrapper<>();
            pmBidWinningLambdaQueryWrapper.eq(PmBidWinning::getDemandId,demandId);
            List<PmBidWinning> pmBidWinningList = pmBidWinningService.list(pmBidWinningLambdaQueryWrapper);
            if(!ObjectUtils.isEmpty(pmBidWinningList)) {
                for(PmBidWinning pmBidWinning : pmBidWinningList) {
                    List<SysFileInfo> fileInfos = getSysFileInfoList(pmBidWinning.getId(),SysFileRefEnum.PM_BID_WINNING_FILE.getType());
                    if(!ObjectUtils.isEmpty(fileInfos)){
                        listAll.addAll(fileInfos);
                    }
                }
            }

            LambdaQueryWrapper<PmBidFailure> pmBidFailureLambdaQueryWrapper = new LambdaQueryWrapper<>();
            pmBidFailureLambdaQueryWrapper.eq(PmBidFailure::getDemandId,demandId);
            List<PmBidFailure> pmBidFailureList = pmBidFailureService.list(pmBidFailureLambdaQueryWrapper);
            if(!ObjectUtils.isEmpty(pmBidFailureService)) {
                for(PmBidFailure pmBidFailure : pmBidFailureList) {
                    List<SysFileInfo> fileInfos = getSysFileInfoList(pmBidFailure.getId(),SysFileRefEnum.PM_BID_FAILURE_FILE.getType());
                    if(!ObjectUtils.isEmpty(fileInfos)){
                        listAll.addAll(fileInfos);
                    }
                }
            }

            if(!ObjectUtils.isEmpty(listAll)){
                vo.setFileInfos(listAll);
            }

        } else if("质疑处理".equals(moduleName)) {
            List<SysFileInfo> fileInfos = getSysFileInfoList(demandId,SysFileRefEnum.PM_BID_CALL_QEUSTION_FILE.getType());
            if(!ObjectUtils.isEmpty(fileInfos)){
                vo.setFileInfos(fileInfos);
            }
        } else if("上传中标通知书".equals(moduleName)) {
            List<SysFileInfo> fileInfos = getSysFileInfoList(demandId,SysFileRefEnum.PM_BID_WINNING_NOTIFICATION.getType());
            if(!ObjectUtils.isEmpty(fileInfos)){
                vo.setFileInfos(fileInfos);
            }
        } else if("合同填制".equals(moduleName)) {
            LambdaQueryWrapper<PmContractInfo> pmContractInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
            pmContractInfoLambdaQueryWrapper.eq(PmContractInfo::getDemandId,demandId);
            PmContractInfo pmContractInfo = pmContractInfoService.getOne(pmContractInfoLambdaQueryWrapper);
            if(pmContractInfo != null){
                List<SysFileInfo> fileInfos = getSysFileInfoList(pmContractInfo.getId(),SysFileRefEnum.PM_CONTRACT_INFO.getType());
                if(!ObjectUtils.isEmpty(fileInfos)){
                    vo.setFileInfos(fileInfos);
                }
            }

        } else if("建设文档填制".equals(moduleName)) {
            LambdaQueryWrapper<PmProjectConstruction> pmProjectConstructionLambdaQueryWrapper = new LambdaQueryWrapper<>();
            pmProjectConstructionLambdaQueryWrapper.eq(PmProjectConstruction::getDemandId,demandId);
            PmProjectConstruction pmProjectConstruction = pmProjectConstructionService.getOne(pmProjectConstructionLambdaQueryWrapper);
            if(pmProjectConstruction != null){
                List<SysFileInfo> fileInfos = getSysFileInfoList(pmProjectConstruction.getId(),SysFileRefEnum.PM_PROJECT_CONSTRUCTION.getType());
                if(!ObjectUtils.isEmpty(fileInfos)){
                    vo.setFileInfos(fileInfos);
                }
            }

        } else if("项目归档".equals(moduleName)) {
            //do nothing
        }

        return vo;
    }

    /**
     * 提交采购需求
     *
     * @param pmDemandReqVo
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean commit(PmDemandReqVo pmDemandReqVo) {
        PmDemand pmDemand = new PmDemand();
        pmDemand.setDemandId(pmDemandReqVo.getDemandId());
        pmDemand.setProjectStatus(PmProjectStatus.DEMAND_WAIT_AUDIT.getCode());
        pmDemand.setUpdateBy(pmDemandReqVo.getUpdateBy());
        pmDemand.setUpdateTime(DateUtils.getNowDate());
        return this.updateById(pmDemand);
    }

    /**
     * 审核采购需求通过
     *
     * @param pmDemandReqVo
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean reviewTo(PmDemandReqVo pmDemandReqVo) {
        PmDemand pmDemand = new PmDemand();
        pmDemand.setDemandId(pmDemandReqVo.getDemandId());
        pmDemand.setProjectStatus(PmProjectStatus.TASK_WAIT_RELEASE.getCode());
        List<SysFileRef> sysFileRefs = pmDemandReqVo.getSysFileRefs();
        uploadFile(pmDemandReqVo.getDemandId(),SysFileRefEnum.PM_DEMAND_EXAMINE.getType(),sysFileRefs,pmDemandReqVo.getUpdateBy());

        pmDemand.setUpdateBy(pmDemandReqVo.getUpdateBy());
        pmDemand.setUpdateTime(DateUtils.getNowDate());
        pmDemand.setAuditTime(DateUtils.getNowDate());
        return this.updateById(pmDemand);
    }

    /**
     * 审核采购需求退回
     *
     * @param pmDemandReqVo
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean reviewReturn(PmDemandReqVo pmDemandReqVo) {
        PmDemand pmDemand = new PmDemand();
        pmDemand.setDemandId(pmDemandReqVo.getDemandId());
        pmDemand.setProjectStatus(PmProjectStatus.DEMAND_WAIT_COMMIT.getCode());
        pmDemand.setAdjustReason(pmDemandReqVo.getRefuseReason());
        pmDemand.setUpdateBy(pmDemandReqVo.getUpdateBy());
        pmDemand.setUpdateTime(DateUtils.getNowDate());
        pmDemand.setAuditTime(DateUtils.getNowDate());
        return this.updateById(pmDemand);
    }

    /**
     * 下达任务
     *
     * @param pmDemandReqVo
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean releaseTask(PmDemandReqVo pmDemandReqVo) {
        PmDemand pmDemand = new PmDemand();
        pmDemand.setDemandId(pmDemandReqVo.getDemandId());
        pmDemand.setProjectStatus(PmProjectStatus.WAIT_SELECT_AGENT.getCode());
        List<SysFileRef> sysFileRefs = pmDemandReqVo.getSysFileRefs();

        uploadFile(pmDemandReqVo.getDemandId(),SysFileRefEnum.PM_TAST_RELEASE.getType(),sysFileRefs,pmDemandReqVo.getUpdateBy());
        pmDemand.setUpdateBy(pmDemandReqVo.getUpdateBy());
        pmDemand.setUpdateTime(DateUtils.getNowDate());
        pmDemand.setAuditTime(DateUtils.getNowDate());
        return this.updateById(pmDemand);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean uploadFile(Long redId,Integer fileType, List<SysFileRef> sysFileRefs,String upateBy){

        if (!ObjectUtils.isEmpty(sysFileRefs)) {
            for (SysFileRef ref : sysFileRefs) {
                if(ref.getFileId() == null){
                    continue;
                }
                QueryWrapper<SysFileRef> queryWrapper = new QueryWrapper<>();
                queryWrapper.lambda().eq(SysFileRef::getFileId,ref.getFileId())
                        .eq(SysFileRef::getRedId,redId)
                        .eq(SysFileRef::getType,fileType);
                List<SysFileRef> sysFileRefList = sysFileRefService.list(queryWrapper);
                if(!CollectionUtils.isEmpty(sysFileRefList)){
                    sysFileRefService.remove(queryWrapper);
                }
                ref.setRedId(redId);
                ref.setType(fileType);
                ref.setCreated(upateBy);
                ref.setCreateTime(new Date());
                ref.setUpdated(upateBy);
                ref.setUpdateTime(ref.getCreateTime());
                sysFileRefService.save(ref);
            }
            return true;
        } else {
            return false;
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertPmReleaseAnnouncement(PmReleaseAnnouncementReqVo pmReleaseAnnouncementReqVo) throws Exception {
        PmDemand pmDemand = this.getById(pmReleaseAnnouncementReqVo.getDemandId());
        if(ObjectUtils.isEmpty(pmDemand)){
            throw new Exception("参数错误");
        }
        PmReleaseAnnouncement pmReleaseAnnouncement = new PmReleaseAnnouncement();
        BeanUtils.copyProperties(pmReleaseAnnouncementReqVo,pmReleaseAnnouncement);
        if(pmReleaseAnnouncementService.saveOrUpdate(pmReleaseAnnouncement)){
            uploadFile(pmReleaseAnnouncement.getId(), SysFileRefEnum.PM_ANNOUNCEMENT_FILE.getType(),pmReleaseAnnouncementReqVo.getSysFileRefs(),pmReleaseAnnouncementReqVo.getUpdateBy());
            PmDemand pmDemandUpdate = new PmDemand();
            pmDemandUpdate.setDemandId(pmReleaseAnnouncementReqVo.getDemandId());
            pmDemandUpdate.setProjectStatus(PmProjectStatus.WAIT_OPEN_BID.getCode());
            pmDemandUpdate.setUpdateTime(pmReleaseAnnouncementReqVo.getUpdateTime());
            pmDemandUpdate.setUpdateBy(pmReleaseAnnouncementReqVo.getUpdateBy());
            if(this.updateById(pmDemandUpdate)){
                //发布公告生成后，会默认将该数据同步到公告管理和首页中
                BaseNotice baseNotice = new BaseNotice();
                baseNotice.setName(pmDemand.getProjectName());
                baseNotice.setTitle(pmDemand.getProjectName() + "招标公告" );
                LambdaQueryWrapper<BaseNoticeType> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                lambdaQueryWrapper.eq(BaseNoticeType::getName,"招标公告");
                BaseNoticeType baseNoticeType = baseNoticeTypeService.getOne(lambdaQueryWrapper);
                if(baseNoticeType == null){
                    throw new Exception("招标公告 公告类型不存在");
                }
                baseNotice.setType(baseNoticeType.getId());
                baseNotice.setReleaseTime(pmReleaseAnnouncement.getReleaseTime());
                return this.baseNoticeService.saveOrUpdate(baseNotice);
            } else {
                return false;
            }

        } else {
            return false;
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertExpertBatch(PmBaseExpertFillReqVo pmBaseExpertFillReqVo) throws Exception {
        PmDemand pmDemand = this.getById(pmBaseExpertFillReqVo.getDemandId());
        if(ObjectUtils.isEmpty(pmDemand)){
            throw new Exception("参数错误");
        }
        List<BaseExpert> baseExpertList = pmBaseExpertFillReqVo.getBaseExpertList();
        if(ObjectUtils.isEmpty(baseExpertList)){
            throw new Exception("参数错误");
        }

        Date now = new Date();
        for (BaseExpert baseExpert : baseExpertList) {
            if(NameListType.BLACK.getCode().equals(baseExpert.getStatus())){
                throw new Exception("该专家(身份证号：" +baseExpert.getIdNumber() + "）属于黑名单");
            } else {
                if(ObjectUtils.isEmpty(baseExpert.getStatus())){
                    baseExpert.setStatus(NameListType.WHITE.getCode());
                }
            }
            if(pmDemand.getProjectType().equals(baseExpert.getVarietyPurchase())){
                throw new Exception("该专家(身份证号：" +baseExpert.getIdNumber() + "）所属采购品种和项目类型不匹配");
            }
            if(ObjectUtils.isEmpty(baseExpert.getCreated())){
                baseExpert.setCreated(pmBaseExpertFillReqVo.getCreateBy());
                baseExpert.setCreateTime(now);
            }

            if(ObjectUtils.isEmpty(baseExpert.getUpdated())){
                baseExpert.setUpdated(pmBaseExpertFillReqVo.getUpdateBy());
                baseExpert.setUpdateTime(now);
            }
            if(baseExpertService.saveOrUpdate(baseExpert)){
                LambdaQueryWrapper<PmDemandExpertRef> pmDemandExpertRefLambdaQueryWrapper = new LambdaQueryWrapper<>();
                pmDemandExpertRefLambdaQueryWrapper.eq(PmDemandExpertRef::getDemandId,pmDemand.getDemandId())
                        .eq(PmDemandExpertRef::getExpertId,baseExpert.getId().longValue())
                        .eq(PmDemandExpertRef::getAccessTime,pmBaseExpertFillReqVo.getAccessTime());
                PmDemandExpertRef pmDemandExpertRef =  pmDemandExpertRefService.getOne(pmDemandExpertRefLambdaQueryWrapper);
                if(pmDemandExpertRef == null){
                    pmDemandExpertRef = new PmDemandExpertRef();
                    pmDemandExpertRef.setCreateBy(pmBaseExpertFillReqVo.getCreateBy());
                    pmDemandExpertRef.setCreateTime(now);
                }
                pmDemandExpertRef.setDemandId(pmDemand.getDemandId());
                pmDemandExpertRef.setExpertId(baseExpert.getId().longValue());
                pmDemandExpertRef.setAccessTime(DateUtils.parseDate(pmBaseExpertFillReqVo.getAccessTime()));
                pmDemandExpertRef.setUpdateBy(pmBaseExpertFillReqVo.getCreateBy());
                pmDemandExpertRef.setUpdateTime(pmDemandExpertRef.getCreateTime());
                pmDemandExpertRefService.saveOrUpdate(pmDemandExpertRef);
            }

        }

         return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
   public boolean extractExpertBatch(PmBaseExpertExtractReqVo pmBaseExpertExtractReqVo) throws Exception {
       Integer technicalExpertNumber = pmBaseExpertExtractReqVo.getTechnicalExpertNumber();
       if(technicalExpertNumber== null){
           technicalExpertNumber = 0;
       }
       Integer economicExpertNumber = pmBaseExpertExtractReqVo.getEconomicExpertNumber();
       if(economicExpertNumber == null){
           economicExpertNumber = 0;
       }
       Integer legalAffairsExpertNumber = pmBaseExpertExtractReqVo.getLegalAffairsExpertNumber();
       if(legalAffairsExpertNumber == null){
           legalAffairsExpertNumber = 0;
       }
       Integer spareExpertNumber = pmBaseExpertExtractReqVo.getSpareExpertNumber();
       if(spareExpertNumber == null){
           spareExpertNumber = 0;
       }

       String  professional = pmBaseExpertExtractReqVo.getProfessional();
       if(spareExpertNumber > 0 && ObjectUtils.isEmpty(professional)){
           throw new Exception("抽取备用专家必须选择专家专业");
       }

       PmDemand pmDemand = this.getById(pmBaseExpertExtractReqVo.getDemandId());
       if(ObjectUtils.isEmpty(pmDemand)){
           throw new Exception("参数错误");
       }

        String needAvoidUnit = pmBaseExpertExtractReqVo.getNeedAvoidUnit();
        List<String> needAvoidUnitList = null;
       if(!ObjectUtils.isEmpty(needAvoidUnit)){
           String[] arr = needAvoidUnit.split(",");
           needAvoidUnitList = Arrays.asList(arr);
       }


        String localArea = pmBaseExpertExtractReqVo.getLocalArea();
        List<String> sysRegionCodeList = new ArrayList<>();
       if(!ObjectUtils.isEmpty(localArea)) {
           if(!StringUtils.isNumeric(localArea)){
               throw new Exception("地域必须传数字代码");
           }
           sysRegionCodeList.add(localArea);
           //找到该地域code对应的子列表
           List<SysRegionVO> sysRegionVOList = iSysRegionService.findChildDivisions(localArea);
           if(!ObjectUtils.isEmpty(sysRegionVOList)){
               for(SysRegionVO vo : sysRegionVOList) {
                   sysRegionCodeList.add(vo.getCode());
               }
           }
       }

        //从专家库中查询符合项目类型的以及是白名单的全部列表
       LambdaQueryWrapper<BaseExpert> lw = new LambdaQueryWrapper<>();
       lw.eq(BaseExpert::getVarietyPurchase,pmDemand.getProjectType())
               .eq(BaseExpert::getStatus,NameListType.WHITE.getCode())
                .notIn(!ObjectUtils.isEmpty(needAvoidUnitList),BaseExpert::getUnitInformation,needAvoidUnitList)
               .in(!ObjectUtils.isEmpty(sysRegionCodeList), BaseExpert::getLocalArea,sysRegionCodeList);

       List<BaseExpert> baseExpertList = baseExpertService.list(lw);
       if(ObjectUtils.isEmpty(baseExpertList)){
           throw new Exception("没抽取到符合条件的专家");
       }

       //从列表中挑出来各个类型的子列表
       List<BaseExpert> technicalExpertList = new ArrayList<>();
       List<BaseExpert> economicExpertList = new ArrayList<>();
       List<BaseExpert> legalAffairsExpertList = new ArrayList<>();
       List<BaseExpert> spareExpertList = new ArrayList<>();



       for(BaseExpert baseExpert : baseExpertList){
           if(technicalExpertNumber > 0) {
               if(baseExpert.getExpertType().contains(ExpertType.TECHNICAL_EXPERT.getCode())){
                   technicalExpertList.add(baseExpert);
               }
           }

           if(economicExpertNumber > 0) {
               if(baseExpert.getExpertType().contains(ExpertType.ECONOMIC_EXPERT.getCode())){
                   economicExpertList.add(baseExpert);
               }
           }

           if (legalAffairsExpertNumber > 0) {
               if(baseExpert.getExpertType().contains(ExpertType.LEGALAFFAIRS_EXPERT.getCode())){
                   legalAffairsExpertList.add(baseExpert);
               }
           }

           if (spareExpertNumber > 0) {
               String[] arr = professional.split(",");
               List<String> professionalList = Arrays.asList(arr);
               String majorType = baseExpert.getMajorType();
               if(!ObjectUtils.isEmpty(majorType)){
                   String[] arr2 = majorType.split(",");
                   List<String> majorTypeList =  Arrays.asList(arr2);
                   if(hasIntersection(professionalList,majorTypeList)){
                       spareExpertList.add(baseExpert);
                   }
               }
           }
       }

       //从子列表中随机抽取符合数据量的
       List<BaseExpert> alltExpertList = new ArrayList<>();
       if(!ObjectUtils.isEmpty(technicalExpertList)){
           alltExpertList.addAll(RandomUtil.getRandomList(technicalExpertList,technicalExpertNumber));
       }
       if(!ObjectUtils.isEmpty(economicExpertList)){
           alltExpertList.addAll(RandomUtil.getRandomList(economicExpertList,economicExpertNumber));
       }
       if(!ObjectUtils.isEmpty(legalAffairsExpertList)){
           alltExpertList.addAll(RandomUtil.getRandomList(legalAffairsExpertList,legalAffairsExpertNumber));
       }
       if(!ObjectUtils.isEmpty(spareExpertList)){
           alltExpertList.addAll(RandomUtil.getRandomList(spareExpertList,spareExpertNumber));
       }

      if(ObjectUtils.isEmpty(alltExpertList)){
          throw new Exception("没抽取到符合条件的专家");
      } else {
          List<PmDemandExpertRef> pmDemandExpertRefList = new ArrayList<>();
          for(BaseExpert baseExpert :alltExpertList ) {

              LambdaQueryWrapper<PmDemandExpertRef> baseExpertLambdaQueryWrapper = new LambdaQueryWrapper<>();
              baseExpertLambdaQueryWrapper.eq(PmDemandExpertRef::getExpertId, baseExpert.getId().longValue())
                      .eq(PmDemandExpertRef::getDemandId,pmDemand.getDemandId())
                      .eq(PmDemandExpertRef::getAccessTime,pmBaseExpertExtractReqVo.getAccessTime());
              PmDemandExpertRef pmDemandExpertRef  = pmDemandExpertRefService.getOne(baseExpertLambdaQueryWrapper);
              if(pmDemandExpertRef == null){
                  pmDemandExpertRef = new PmDemandExpertRef();
                  pmDemandExpertRef.setCreateBy(pmBaseExpertExtractReqVo.getCreateBy());
                  pmDemandExpertRef.setCreateTime(new Date());
              }
              pmDemandExpertRef.setDemandId(pmDemand.getDemandId());
              pmDemandExpertRef.setExpertId(baseExpert.getId().longValue());
              pmDemandExpertRef.setAccessTime(DateUtils.parseDate(pmBaseExpertExtractReqVo.getAccessTime()));
              pmDemandExpertRef.setUpdateBy(pmBaseExpertExtractReqVo.getCreateBy());
              pmDemandExpertRef.setUpdateTime(pmDemandExpertRef.getCreateTime());
              pmDemandExpertRefList.add(pmDemandExpertRef);
          }
          return pmDemandExpertRefService.saveOrUpdateBatch(pmDemandExpertRefList);
      }
    }

    //二个列表是否有交集
    private boolean hasIntersection(List<String> professionalList, List<String> majorTypeList) {
        for (String professiona : professionalList) {
            for(String majorType : majorTypeList) {
                if(professiona.equals(majorType)){
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
   public boolean insertBidOpeningBatch(PmBidOpeningFillReqVo pmBidOpeningFillReqVo) throws Exception {
       PmDemand pmDemand = this.getById(pmBidOpeningFillReqVo.getDemandId());
       if(ObjectUtils.isEmpty(pmDemand)){
           throw new Exception("参数错误");
       }

       //从发布公告里获取开标时间
        LambdaQueryWrapper<PmReleaseAnnouncement> lw = new LambdaQueryWrapper<>();
        lw.eq(PmReleaseAnnouncement::getDemandId,pmDemand.getDemandId()).orderByDesc(PmReleaseAnnouncement::getReleaseTime)
                .last(" limit 1 ");
        PmReleaseAnnouncement pmReleaseAnnouncement = this.pmReleaseAnnouncementService.getOne(lw);
        if(pmReleaseAnnouncement == null){
            throw new Exception("发布公告不存在");
        }
       Date tenderOpenTime = pmReleaseAnnouncement.getTenderOpenTime();

       Date now = new Date();
       List<PmBidOpening> pmBidOpeningList = pmBidOpeningFillReqVo.getPmBidOpeningList();
       for (PmBidOpening pmBidOpening : pmBidOpeningList) {
           if(ObjectUtils.isEmpty(pmBidOpening.getBidderName())){
               throw new Exception("投标人名称不能为空");
           }
           if(ObjectUtils.isEmpty(pmBidOpening.getScore())){
               throw new Exception("分数不能为空");
           }
           pmBidOpening.setOpenBidTime(tenderOpenTime);
           pmBidOpening.setDemandId(pmBidOpeningFillReqVo.getDemandId());
           pmBidOpening.setCreateBy(pmBidOpeningFillReqVo.getCreateBy());
           pmBidOpening.setCreateTime(now);
           pmBidOpening.setUpdateBy(pmBidOpeningFillReqVo.getUpdateBy());
           pmBidOpening.setUpdateTime(now);
       }
       if(pmBidOpeningService.saveOrUpdateBatch(pmBidOpeningList)) {
           PmDemand pmDemandUpdate = new PmDemand();
           pmDemandUpdate.setDemandId(pmDemand.getDemandId());
           pmDemandUpdate.setProjectStatus(PmProjectStatus.WAIT_BID_ANNOUNCEMENT.getCode());
           pmDemandUpdate.setUpdateTime(now);
           pmDemandUpdate.setUpdateBy(pmBidOpeningFillReqVo.getUpdateBy());
           return this.updateById(pmDemandUpdate);
       } else {
           return false;
       }
   }

    @Override
    @Transactional(rollbackFor = Exception.class)
   public boolean insertPmBidWinning(PmBidWinningReqVo pmBidWinningReqVo) throws Exception {
       List<Long> pmBidOpeningIdList = pmBidWinningReqVo.getPmBidOpeningIdList();
        if(ObjectUtils.isEmpty(pmBidOpeningIdList)) {
            throw new Exception("中标单位信息列表不能为空");
        }
       if(ObjectUtils.isEmpty(pmBidWinningReqVo.getSysFileRefs())){
           throw new Exception("上传附件不能为空");
       }
       if(ObjectUtils.isEmpty(pmBidWinningReqVo.getBidWinningAmount())){
           throw new Exception("中标金额不能为空");
       }
       PmBidWinning pmBidWinning = new PmBidWinning();
       BeanUtils.copyProperties(pmBidWinningReqVo,pmBidWinning);
       if(pmBidWinningService.saveOrUpdate(pmBidWinning)){
           List<PmBidWinningOpeningRef> pmBidWinningOpeningRefList = new ArrayList<>();
           for(Long pmBidOpeningId : pmBidOpeningIdList){
               LambdaQueryWrapper<PmBidWinningOpeningRef> pmBidWinningOpeningRefLambdaQueryWrapper = new LambdaQueryWrapper<>();
               pmBidWinningOpeningRefLambdaQueryWrapper.eq(PmBidWinningOpeningRef::getOpeningId,pmBidOpeningId)
                       .eq(PmBidWinningOpeningRef::getWinningId,pmBidWinning.getId());
               PmBidWinningOpeningRef pmBidWinningOpeningRef = pmBidWinningOpeningRefService.getOne(pmBidWinningOpeningRefLambdaQueryWrapper);
               if(pmBidWinningOpeningRef == null){
                   pmBidWinningOpeningRef = new PmBidWinningOpeningRef();
                   pmBidWinningOpeningRef.setCreateBy(pmBidWinningReqVo.getCreateBy());
                   pmBidWinningOpeningRef.setCreateTime(pmBidWinningReqVo.getCreateTime());
               }
               pmBidWinningOpeningRef.setOpeningId(pmBidOpeningId);
               pmBidWinningOpeningRef.setWinningId(pmBidWinning.getId());
               pmBidWinningOpeningRef.setUpdateBy(pmBidWinningReqVo.getUpdateBy());
               pmBidWinningOpeningRef.setUpdateTime(pmBidWinningReqVo.getUpdateTime());
               pmBidWinningOpeningRefList.add(pmBidWinningOpeningRef);
           }
          if (pmBidWinningOpeningRefService.saveOrUpdateBatch(pmBidWinningOpeningRefList)) {
              uploadFile(pmBidWinning.getId(), SysFileRefEnum.PM_BID_WINNING_FILE.getType(),pmBidWinningReqVo.getSysFileRefs(),pmBidWinningReqVo.getUpdateBy());
              PmDemand pmDemandUpdate = new PmDemand();
              pmDemandUpdate.setDemandId(pmBidWinningReqVo.getDemandId());
              pmDemandUpdate.setProjectStatus(PmProjectStatus.BIDDING_PUBLICITY.getCode());
              pmDemandUpdate.setUpdateTime(pmBidWinningReqVo.getUpdateTime());
              pmDemandUpdate.setUpdateBy(pmBidWinningReqVo.getUpdateBy());
              return this.updateById(pmDemandUpdate);

          } else {
              return false;
          }

       } else {
           return false;
       }
   }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePmBidWinning(PmBidWinningReqVo pmBidWinningReqVo) throws Exception {
        List<Long> pmBidOpeningIdList = pmBidWinningReqVo.getPmBidOpeningIdList();
        if(ObjectUtils.isEmpty(pmBidOpeningIdList)) {
            throw new Exception("中标单位信息列表不能为空");
        }
        if(ObjectUtils.isEmpty(pmBidWinningReqVo.getSysFileRefs())){
            throw new Exception("上传附件不能为空");
        }
        if(ObjectUtils.isEmpty(pmBidWinningReqVo.getBidWinningAmount())){
            throw new Exception("中标金额不能为空");
        }

        LambdaQueryWrapper<PmBidWinning> lw = new LambdaQueryWrapper<>();
        lw.eq(PmBidWinning::getDemandId,pmBidWinningReqVo.getDemandId());
        PmBidWinning pmBidWinning = pmBidWinningService.getOne(lw);
        if(pmBidWinning == null){
            throw new Exception("原中标信息不存在");
        }

        pmBidWinning.setBidWinningAmount(pmBidWinningReqVo.getBidWinningAmount());
        pmBidWinning.setUpdateBy(pmBidWinningReqVo.getUpdateBy());
        pmBidWinning.setUpdateTime(pmBidWinningReqVo.getUpdateTime());
        if(pmBidWinningService.updateById(pmBidWinning)){
            //删除老的：
            QueryWrapper<PmBidWinningOpeningRef> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(PmBidWinningOpeningRef::getWinningId,pmBidWinning.getId());
            pmBidWinningOpeningRefService.remove(queryWrapper);

            //添加新的
            List<PmBidWinningOpeningRef> pmBidWinningOpeningRefList = new ArrayList<>();
            for(Long pmBidOpeningId : pmBidOpeningIdList){
                PmBidWinningOpeningRef pmBidWinningOpeningRef = new PmBidWinningOpeningRef();
                pmBidWinningOpeningRef.setOpeningId(pmBidOpeningId);
                pmBidWinningOpeningRef.setWinningId(pmBidWinning.getId());
                pmBidWinningOpeningRef.setCreateBy(pmBidWinningReqVo.getCreateBy());
                pmBidWinningOpeningRef.setCreateTime(pmBidWinningReqVo.getCreateTime());
                pmBidWinningOpeningRef.setUpdateBy(pmBidWinningReqVo.getUpdateBy());
                pmBidWinningOpeningRef.setUpdateTime(pmBidWinningReqVo.getUpdateTime());
                pmBidWinningOpeningRefList.add(pmBidWinningOpeningRef);
            }
           return pmBidWinningOpeningRefService.saveBatch(pmBidWinningOpeningRefList);
        } else {
            return false;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertPmBidFailure(PmBidFailureReqVo pmBidFailureReqVo) throws Exception {
        PmBidFailure pmBidFailure = new PmBidFailure();
        BeanUtils.copyProperties(pmBidFailureReqVo,pmBidFailure);
        if(pmBidFailureService.saveOrUpdate(pmBidFailure)){
            uploadFile(pmBidFailure.getId(), SysFileRefEnum.PM_BID_FAILURE_FILE.getType(),pmBidFailureReqVo.getSysFileRefs(),pmBidFailureReqVo.getUpdateBy());
            PmDemand pmDemandUpdate = new PmDemand();
            pmDemandUpdate.setDemandId(pmBidFailureReqVo.getDemandId());
            pmDemandUpdate.setProjectStatus(PmProjectStatus.WAIT_ANNOUNCEMENT.getCode());
            pmDemandUpdate.setUpdateTime(pmBidFailureReqVo.getUpdateTime());
            pmDemandUpdate.setUpdateBy(pmBidFailureReqVo.getUpdateBy());
            return this.updateById(pmDemandUpdate);
        } else {
            return false;
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertContractInfo(PmContractInfoReqVo pmContractInfoReqVo) throws Exception {
        Long demandId = pmContractInfoReqVo.getDemandId();
        if(ObjectUtils.isEmpty(demandId)){
            throw new Exception("采购需求ID不能为空");
        }


        PmDemand pmDemand = this.getById(demandId);
        if(ObjectUtils.isEmpty(pmDemand)){
            throw new Exception("采购需求ID错误");
        }


        List<SysFileRef> sysFileRefs = pmContractInfoReqVo.getSysFileRefs();
        if(ObjectUtils.isEmpty(sysFileRefs)){
            throw new Exception("上传附件不能为空");
        }

        LambdaQueryWrapper<PmContractInfo> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(PmContractInfo::getDemandId,demandId);
        PmContractInfo pmContractInfo = pmContractInfoService.getOne(lambdaQueryWrapper);
        if(pmContractInfo != null){
            pmContractInfoReqVo.setId(pmContractInfo.getId());
            BeanUtils.copyProperties(pmContractInfoReqVo,pmContractInfo);
            pmContractInfo.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
            pmContractInfo.setUpdateBy(pmContractInfoReqVo.getUpdateBy());
        } else {
            pmContractInfo = new PmContractInfo();
            BeanUtils.copyProperties(pmContractInfoReqVo,pmContractInfo);
            pmContractInfo.setCreateBy(pmContractInfoReqVo.getCreateBy());
            pmContractInfo.setCreateTime(pmContractInfoReqVo.getCreateTime());
            pmContractInfo.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
            pmContractInfo.setUpdateBy(pmContractInfoReqVo.getUpdateBy());
        }

        if(pmContractInfoService.saveOrUpdate(pmContractInfo)){
           this.uploadFile(pmContractInfo.getId(), SysFileRefEnum.PM_CONTRACT_INFO.getType(),sysFileRefs,pmContractInfoReqVo.getUpdateBy());
            PmDemand pmDemandUpdate = new PmDemand();
            pmDemandUpdate.setDemandId(demandId);
            pmDemandUpdate.setProjectStatus(PmProjectStatus.UNDER_CONSTRUCTION.getCode());
            pmDemandUpdate.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
            pmDemandUpdate.setUpdateBy(pmContractInfoReqVo.getUpdateBy());
            return this.updateById(pmDemandUpdate);

        } else {
            return false;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean insertProjectConstruction(PmProjectConstructionReqVo pmProjectConstructionReqVo) throws Exception {
        Long demandId = pmProjectConstructionReqVo.getDemandId();
        if(ObjectUtils.isEmpty(demandId)){
            throw new Exception("采购需求ID不能为空");
        }

        PmDemand pmDemand = this.getById(demandId);
        if(ObjectUtils.isEmpty(pmDemand)){
            throw new Exception("采购需求ID错误");
        }

        List<SysFileRef> sysFileRefs = pmProjectConstructionReqVo.getSysFileRefs();
        if(ObjectUtils.isEmpty(sysFileRefs)){
            throw new Exception("上传附件不能为空");
        }

        LambdaQueryWrapper<PmProjectConstruction> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(PmProjectConstruction::getDemandId,demandId);
        PmProjectConstruction pmProjectConstruction = pmProjectConstructionService.getOne(lambdaQueryWrapper);

        if(pmProjectConstruction != null){
            pmProjectConstructionReqVo.setId(pmProjectConstruction.getId());
            BeanUtils.copyProperties(pmProjectConstructionReqVo,pmProjectConstruction);
            pmProjectConstruction.setUpdateBy(pmProjectConstructionReqVo.getUpdateBy());
            pmProjectConstruction.setUpdateTime(pmProjectConstructionReqVo.getUpdateTime());
        } else {
            pmProjectConstruction = new PmProjectConstruction();
            BeanUtils.copyProperties(pmProjectConstructionReqVo,pmProjectConstruction);
            pmProjectConstruction.setCreateBy(pmProjectConstructionReqVo.getCreateBy());
            pmProjectConstruction.setCreateTime(pmProjectConstructionReqVo.getCreateTime());
            pmProjectConstruction.setUpdateBy(pmProjectConstructionReqVo.getUpdateBy());
            pmProjectConstruction.setUpdateTime(pmProjectConstructionReqVo.getUpdateTime());
        }

        if(pmProjectConstructionService.saveOrUpdate(pmProjectConstruction)){
            this.uploadFile(pmProjectConstruction.getId(), SysFileRefEnum.PM_PROJECT_CONSTRUCTION.getType(),sysFileRefs,pmProjectConstructionReqVo.getUpdateBy());
            PmDemand pmDemandUpdate = new PmDemand();
            pmDemandUpdate.setDemandId(demandId);
            pmDemandUpdate.setProjectStatus(PmProjectStatus.COMPLETION_CONSTRUCTION.getCode());
            pmDemandUpdate.setUpdateTime(pmProjectConstructionReqVo.getUpdateTime());
            pmDemandUpdate.setUpdateBy(pmProjectConstructionReqVo.getUpdateBy());
            return this.updateById(pmDemandUpdate);

        } else {
            return false;
        }
    }

    /**
     * 通过需求ID列表 查询采购执行列表 sunhh
     * @param demandIdList
     * @return
     */
    @Override
    public List<PmDemand> selectByDemandIdList(List<Integer> demandIdList) {
        return this.baseMapper.selectByDemandIdList(demandIdList);
    }

    /**
     * 专家库--查询抽取专家列表 非必传条件：专家名称，开始结束时间 sunhh
     *
     * @param baseExpertVo
     * @return
     */
    @Override
    public List<PmDemand> selectExtractionExpert(BaseExpertVo baseExpertVo) {
        return this.baseMapper.selectExtractionExpert(baseExpertVo);
    }

    @Override
    public List<PmDemandResVo> demandWaitCommit() {
        return getListByStatus(PmProjectStatus.DEMAND_WAIT_COMMIT.getCode());
    }

    @Override
    public List<PmDemandResVo> contractWaitFilled() {
        return getListByStatus(PmProjectStatus.CONTRACT_WAIT_FILL.getCode());
    }

    @Override
    public List<PmDemandResVo> projectWaitFinish() {
        return getListByStatus(PmProjectStatus.UNDER_CONSTRUCTION.getCode());
    }

    @Override
    public List<PmDemandResVo> demandWaitExamine() {
        return getListByStatus(PmProjectStatus.DEMAND_WAIT_AUDIT.getCode());
    }

    @Override
    public List<PmDemandResVo> taskWaitRelease() {
        return getListByStatus(PmProjectStatus.TASK_WAIT_RELEASE.getCode());
    }

    @Override
    public List<PmDemandResVo> waitSelectAgent() {
        return getListByStatus(PmProjectStatus.WAIT_SELECT_AGENT.getCode());
    }

    @Override
    public List<PmDemandResVo> waitUpBidFile() {
        return getListByStatus(PmProjectStatus.WAIT_UPLOAD_BID_FILE.getCode());
    }

    @Override
    public List<PmDemandResVo> waitAnnouncement() {
        return getListByStatus(PmProjectStatus.WAIT_ANNOUNCEMENT.getCode());
    }

    @Override
    public List<PmDemandResVo> waitOpenBid() {
        return getListByStatus(PmProjectStatus.WAIT_OPEN_BID.getCode());
    }

    @Override
    public List<PmDemandResVo> waitBidAnnouncement() {
        return getListByStatus(PmProjectStatus.WAIT_BID_ANNOUNCEMENT.getCode());
    }

    @Override
    public List<PmDemandResVo> biddingPublicity() {
        return getListByStatus(PmProjectStatus.BIDDING_PUBLICITY.getCode());
    }

    @Override
    public AjaxResult procurementOfficeWillManipulateTotal() {
        List<HomeToDoQueryResVo> homeRes = new ArrayList<>();
        // 待选取代理, 待上传招标文件, 待发布公告, 待开标, 待发布中标公告, 中标公示中
        List<PmDemandResVo> demandRes = new ArrayList<>();
        demandRes.addAll(getListByStatus(PmProjectStatus.WAIT_SELECT_AGENT.getCode()));
        demandRes.addAll(getListByStatus(PmProjectStatus.WAIT_UPLOAD_BID_FILE.getCode()));
        demandRes.addAll(getListByStatus(PmProjectStatus.WAIT_ANNOUNCEMENT.getCode()));
        demandRes.addAll(getListByStatus(PmProjectStatus.WAIT_OPEN_BID.getCode()));
        demandRes.addAll(getListByStatus(PmProjectStatus.WAIT_BID_ANNOUNCEMENT.getCode()));
        demandRes.addAll(getListByStatus(PmProjectStatus.BIDDING_PUBLICITY.getCode()));

        //计划数据--发函催告
        List<PlanQuarterResponseVo> planRes = planYearsService.willSendLetter();
        //转为首页table展示数据
        if (!ObjectUtils.isEmpty(demandRes) && demandRes.size() > 0) {
            for (PmDemandResVo demandResVoVo : demandRes) {
                HomeToDoQueryResVo home = new HomeToDoQueryResVo();
                BeanUtils.copyProperties(demandResVoVo, home);
                homeRes.add(home);
            }
        }
        if (!ObjectUtils.isEmpty(planRes) && planRes.size() > 0) {
            for (PlanQuarterResponseVo planVo : planRes) {
                HomeToDoQueryResVo home = new HomeToDoQueryResVo();
                BeanUtils.copyProperties(planVo, home);
                homeRes.add(home);
            }
        }
        return AjaxResult.success(homeRes);
    }

    /**
     * 统计分析-采购项目信息统计
     * @param pmDemandReqVo
     * @return
     */
    @Override
    public Map<String, Integer> purchaseProjectStatistical(PmDemandReqVo pmDemandReqVo) {
        Map<String, Integer> mapReturn = new HashMap<>();
        // 查询项目总数量
        Map<String, Integer> mapCount = pmDemandMapper.purchaseProjectStatistical(pmDemandReqVo);
        // 查询已完成项目数量，预算金额数量
        Map<String, Integer> mapYWC = pmDemandMapper.purchaseProjectStatisticalYWC(pmDemandReqVo);
        // 查询新创建项目数量，预算金额数量
        Map<String, Integer> mapXCJ = pmDemandMapper.purchaseProjectStatisticalXCJ(pmDemandReqVo);
        // 查询去年完成项目数量，预算金额数量
        Map<String, Integer> mapQNWC = pmDemandMapper.purchaseProjectStatisticalQNWC(pmDemandReqVo);
        mapReturn.putAll(mapCount);
        mapReturn.putAll(mapYWC);
        mapReturn.putAll(mapXCJ);
        mapReturn.putAll(mapQNWC);
        return mapReturn;
    }

    @Override
    public List<StatisticalChartsResVo> countByProjectAttr() {
        List<StatisticalChartsResVo> resVos = pmDemandMapper.countByProjectAttr();
        for (StatisticalChartsResVo chartsResVo : resVos) {
            for (PmProjectStatus value : PmProjectStatus.values()) {
                if (value.getCode().equals(chartsResVo.getColumnName())) {
                    chartsResVo.setColumnName(value.getInfo());
                    break;
                }
            }
        }
        return resVos;
    }

    @Override
    public List<StatisticalChartsResVo> countByEvaluation() {
        List<StatisticalChartsResVo> resVos = new ArrayList<>();
        //概算金额包括：100万以下采购任务、100至500万元采购任务、500至1000万元采购任务、1000至5000万元采购任务、5000至1亿元采购任务、1亿元及以上采购任务
        StatisticalChartsResVo resVo = pmDemandMapper.countByEvaluationLt(100);
        resVo.setColumnName("100万以下采购任务");
        resVos.add(resVo);
        StatisticalChartsResVo resVo1 = pmDemandMapper.countByEvaluationBet(100, 500);
        resVo1.setColumnName("100至500万元采购任务");
        resVos.add(resVo1);
        StatisticalChartsResVo resVo2 = pmDemandMapper.countByEvaluationBet(500, 1000);
        resVo2.setColumnName("500至1000万元采购任务");
        resVos.add(resVo2);
        StatisticalChartsResVo resVo3 = pmDemandMapper.countByEvaluationBet(1000, 5000);
        resVo3.setColumnName("1000至5000万元采购任务");
        resVos.add(resVo3);
        StatisticalChartsResVo resVo4 = pmDemandMapper.countByEvaluationBet(5000, 10000);
        resVo4.setColumnName("5000至1亿元采购任务");
        resVos.add(resVo4);
        StatisticalChartsResVo resVo5 = pmDemandMapper.countByEvaluationGt(10000);
        resVo5.setColumnName("1亿元及以上采购任务");
        resVos.add(resVo5);
        return resVos;
    }

    /**
     * 通过计划ID查询项目数据
     * @param planId
     * @return
     */
    @Override
    public PmDemand selectByPlanId(Integer planId) {
        return pmDemandMapper.selectByPlanId(planId);
    }


    //查询不同状态下的项目数据
    public List<PmDemandResVo> getListByStatus(String projectStatus) {
        LambdaQueryWrapper<PmDemand> lw = new LambdaQueryWrapper<PmDemand>();
        lw.eq(PmDemand::getProjectStatus, projectStatus);
        List<PmDemand> demandList = this.baseMapper.selectList(lw);
        //数据转换
        List<PmDemandResVo> pmDemandResponseVoList = new ArrayList<>();
        if (!ObjectUtils.isEmpty(demandList) && demandList.size() > 0) {
            pmDemandResponseVoList = demandChangeTo(demandList);
        }
        return pmDemandResponseVoList;
    }

    //字段转换and赋值
    public List<PmDemandResVo> demandChangeTo(List<PmDemand> pmDemandList) {
        List<PmDemandResVo> pmDemandResponseVoList = new ArrayList<>();
        for (PmDemand pmDemand1 : pmDemandList) {
            PmDemandResVo vo = new PmDemandResVo();
            BeanUtils.copyProperties(pmDemand1, vo);
            if (vo.getPurchaseDeptId() != null) {
                Map<String, Object> deptMap = deptService.selectDeptById(vo.getPurchaseDeptId());
                if (deptMap != null) {
                    SysDeptResponseVo sysDeptResponseVo = (SysDeptResponseVo) deptMap.get("sysDept");
                    if (sysDeptResponseVo != null) {
                        vo.setPurchaseDeptName(sysDeptResponseVo.getDeptName());
                    }
                }
            }

            String purchaseServicesName = dictDataService.selectDictLabel("purchase_services", vo.getPurchaseServices());
            if (StringUtils.isNotEmpty(purchaseServicesName)) {
                vo.setPurchaseServicesName(purchaseServicesName);
            }

            //项目类型
            for (ProjectTypes value : ProjectTypes.values()) {
                if (vo.getProjectType() != null && vo.getProjectType().equals(value.getCode())) {
                    vo.setProjectTypeName(value.getInfo());
                    break;
                }
            }
            //是否为超限额计划
            for (IsExcess value : IsExcess.values()) {
                if (vo.getIsExcess() != null && vo.getIsExcess().equals(value.getCode())) {
                    vo.setIsExcessName(value.getInfo());
                    break;
                }
            }

            //采购方式
            for (PlanPurchaseMode value : PlanPurchaseMode.values()) {
                if (vo.getPurchaseMode() != null && vo.getPurchaseMode().equals(value.getCode())) {
                    vo.setPurchaseModeName(value.getInfo());
                    break;
                }
            }
            //项目属性
            for (ProjectAttribute value : ProjectAttribute.values()) {
                if (vo.getProjectAttr() != null && vo.getProjectAttr().equals(value.getCode())) {
                    vo.setProjectAttrName(value.getInfo());
                    break;
                }
            }
            //预警状态
            for (WarnStatus value : WarnStatus.values()) {
                if (vo.getWarnStatus() != null && vo.getWarnStatus().equals(value.getCode())) {
                    vo.setWarnStatusName(value.getInfo());
                    break;
                }
            }

            //项目状态
            for (PmProjectStatus value : PmProjectStatus.values()) {
                if (vo.getProjectStatus() != null && vo.getProjectStatus().equals(value.getCode())) {
                    vo.setProjectStatusName(value.getInfo());
                    break;
                }
            }
            try {
                vo.setTipsMessage(pmDemandGetTips(vo.getPlanDeliverTime()));
                if (vo.getTipsMessage().contains("超过")) {
                    vo.setIsExceedProject("1");
                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
            pmDemandResponseVoList.add(vo);
        }
        return pmDemandResponseVoList;
    }

    /**
     * 根据年度计划提报时间的阈值进行提示
     *
     * @return
     */
    public String pmDemandGetTips(Date planDeliverTime) throws ParseException {
        if(!ObjectUtils.isEmpty(planDeliverTime)){
            //提示信息：定义距离结束时间一周内提示
            Integer remindTine = 1000 * 60 * 60 * 24 * 7;
            //少于一周便提醒
            double surplus = planDeliverTime.getTime() - System.currentTimeMillis();
            if (surplus < remindTine) {
                int i = new Double(Math.ceil(surplus / 1000 / 60 / 60 / 24)).intValue();
                //剩余天数(向上取整)
                if (i > 0) {
                    return "距离计划交付时间不足" + i + "天";
                } else {
                    return "已超过计划完成时间" + i + "天";
                }
            }
        }
        return "";
    }
}