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

package com.ozs.pm.service.impl;

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.BaseExpert;
import com.ozs.base.domain.BaseSupplier;
import com.ozs.base.domain.BaseUnitInformation;
import com.ozs.base.service.BaseExpertService;
import com.ozs.base.service.BaseSupplierService;
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.pm.doman.*;
import com.ozs.pm.doman.vo.PmBaseSupplierVo;
import com.ozs.pm.doman.vo.PmBaseUnitInformationVo;
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.responseVo.SysDeptResponseVo;
import com.ozs.system.service.ISysDeptService;
import com.ozs.system.service.ISysDictDataService;
import com.ozs.system.service.SysFileRefService;
import com.ozs.system.service.SysFileService;
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 IPmDemandEquipService iPmDemandEquipService;
    @Autowired
    private IPmDemandMaterialsService iPmDemandMaterialsService;

    @Autowired
    private IPmDemandServeService iPmDemandServeService;
    @Autowired
    private IPmDemandEngineeringService iPmDemandEngineeringService;
    @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 PmBidWinningService pmBidWinningService;
    @Autowired
    private PmBidFailureService pmBidFailureService;
    @Autowired
    private PmBidWinningOpeningRefService pmBidWinningOpeningRefService;
    @Autowired
    private PmContractInfoService pmContractInfoService;
    @Autowired
    private BaseSupplierService baseSupplierService;

    @Autowired
    private PmContractUnitRefService pmContractUnitRefService;


    @Autowired
    private PmProjectConstructionService pmProjectConstructionService;


    /**
     * 查询采购需求
     *
     * @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);
                }

                //采购需求附件
                HashMap<String, String> demandFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_DEMAND.getType());
                if(demandFileMap != null){
                    vo.setDemandFileMap(demandFileMap);
                }

                //项目类型
                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)) { //需求建档

                //采购需求审核文件
                HashMap<String, String> auditFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_DEMAND_EXAMINE.getType());
                if(auditFileMap != null){
                    vo.setAuditFileMap(auditFileMap);
                }

                if(ProjectTypes.EQUIPMENTTYPE.getCode().equals(pmDemand.getProjectType())){//装备类
                    LambdaQueryWrapper<PmDemandEquip> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                    lambdaQueryWrapper.eq(PmDemandEquip::getDemandId,demandId);
                    PmDemandEquip pmDemandEquip = iPmDemandEquipService.getOne(lambdaQueryWrapper);
                    if(pmDemandEquip != null){
                        PmDemandEquipResVo responseVo = new PmDemandEquipResVo();
                        BeanUtils.copyProperties(pmDemandEquip,responseVo);
                        //采购方式建议
                        for (ProcurementMethodSuggest value : ProcurementMethodSuggest.values()) {
                            if (responseVo.getProcurementMethodSuggest() != null && responseVo.getProcurementMethodSuggest().equals(value.getCode())) {
                                responseVo.setProcurementMethodSuggestName(value.getInfo());
                                break;
                            }
                        }

                        HashMap<String, String> fileMap1 = getFileMap(demandId,SysFileRefEnum.PM_DEMAND_EQUIP.getType());
                        if(fileMap1 != null){
                            responseVo.setFileMap(fileMap1);
                        }

                        vo.setPmDemandEquipResVo(responseVo);
                    }
                } else if(ProjectTypes.MATERIALTYPE.getCode().equals(pmDemand.getProjectType())){ //物资类
                    LambdaQueryWrapper<PmDemandMaterials> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                    lambdaQueryWrapper.eq(PmDemandMaterials::getDemandId,demandId);
                    PmDemandMaterials pmDemandMaterials = iPmDemandMaterialsService.getOne(lambdaQueryWrapper);

                    if(pmDemandMaterials != null){
                        PmDemandMaterialsResVo responseVo = new PmDemandMaterialsResVo();
                        BeanUtils.copyProperties(pmDemandMaterials,responseVo);
                        //采购方式建议
                        for (ProcurementMethodSuggest value : ProcurementMethodSuggest.values()) {
                            if (responseVo.getProcurementMethodSuggest() != null && responseVo.getProcurementMethodSuggest().equals(value.getCode())) {
                                responseVo.setProcurementMethodSuggestName(value.getInfo());
                                break;
                            }
                        }
                        HashMap<String, String> fileMap2 = getFileMap(demandId,SysFileRefEnum.PM_DEMAND_MATERIALS.getType());
                        if(fileMap2 != null){
                            responseVo.setFileMap(fileMap2);
                        }
                        vo.setPmDemandMaterialsResVo(responseVo);
                    }
                } else if(ProjectTypes.SERVICESTYPE.getCode().equals(pmDemand.getProjectType())){//服务类
                    LambdaQueryWrapper<PmDemandServe> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                    lambdaQueryWrapper.eq(PmDemandServe::getDemandId,demandId);
                    PmDemandServe pmDemandServe = iPmDemandServeService.getOne(lambdaQueryWrapper);

                    if(pmDemandServe != null){
                        PmDemandServeResVo responseVo = new PmDemandServeResVo();
                        BeanUtils.copyProperties(pmDemandServe,responseVo);
                        //采购方式建议
                        for (ProcurementMethodSuggest value : ProcurementMethodSuggest.values()) {
                            if (responseVo.getProcurementMethodSuggest() != null && responseVo.getProcurementMethodSuggest().equals(value.getCode())) {
                                responseVo.setProcurementMethodSuggestName(value.getInfo());
                                break;
                            }
                        }
                        HashMap<String, String> fileMap3 = getFileMap(demandId,SysFileRefEnum.PM_DEMAND_SERVE.getType());
                        if(fileMap3 != null){
                            responseVo.setFileMap(fileMap3);
                        }
                        vo.setPmDemandServeResVo(responseVo);
                    }
                } else if(ProjectTypes.PLANTOEXAMINETYPE.getCode().equals(pmDemand.getProjectType())){//工程类
                    LambdaQueryWrapper<PmDemandEngineering> lambdaQueryWrapper = new LambdaQueryWrapper<>();
                    lambdaQueryWrapper.eq(PmDemandEngineering::getDemandId,demandId);
                    PmDemandEngineering pmDemandEngineering = iPmDemandEngineeringService.getOne(lambdaQueryWrapper);
                    if(pmDemandEngineering != null){
                        PmDemandEngineeringResVo responseVo = new PmDemandEngineeringResVo();
                        BeanUtils.copyProperties(pmDemandEngineering,responseVo);
                        //采购方式建议
                        for (ProcurementMethodSuggest value : ProcurementMethodSuggest.values()) {
                            if (responseVo.getProcurementMethodSuggest() != null && responseVo.getProcurementMethodSuggest().equals(value.getCode())) {
                                responseVo.setProcurementMethodSuggestName(value.getInfo());
                                break;
                            }
                        }
                        //项目类别
                        for (EngineeringProjectCategory value : EngineeringProjectCategory.values()) {
                            if (responseVo.getProjectCategory() != null && responseVo.getProjectCategory().equals(value.getCode())) {
                                responseVo.setProjectCategoryName(value.getInfo());
                                break;
                            }
                        }
                        //承包方式
                        for (EngineeringContractingMode value : EngineeringContractingMode.values()) {
                            if (responseVo.getContractingMode() != null && responseVo.getContractingMode().equals(value.getCode())) {
                                responseVo.setContractingModeName(value.getInfo());
                                break;
                            }
                        }
                        //施工图是否完成
                        for (ConstructionDrawing value : ConstructionDrawing.values()) {
                            if (responseVo.getConstructionDrawing() != null && responseVo.getConstructionDrawing().equals(value.getCode())) {
                                responseVo.setConstructionDrawingName(value.getInfo());
                                break;
                            }
                        }
                        HashMap<String, String> fileMap4 = getFileMap(demandId,SysFileRefEnum.PM_DEMAND_ENGINEERING.getType());
                        if(fileMap4 != null){
                            responseVo.setFileMap(fileMap4);
                        }
                        vo.setPmDemandEngineeringResVo(responseVo);
                    }
                }
            } else if("3".equals(detailType)) { //任务下达
                //任务下达文件
                HashMap<String, String> taskReleaseFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_TAST_RELEASE.getType());
                if(taskReleaseFileMap != null){
                    vo.setTaskReleaseFileMap(taskReleaseFileMap);
                }
            } else if("4".equals(detailType)) { //中标信息

            } 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);

                    // todo
                    BaseUnitInformation baseUnitInformation = null;

                    PmBaseUnitInformationVo pmBaseUnitInformationVo = new PmBaseUnitInformationVo();
                    BeanUtils.copyProperties(baseUnitInformation, pmBaseUnitInformationVo);

                    LambdaQueryWrapper<PmContractUnitRef> lambdaQueryWrapper1 = new LambdaQueryWrapper<>();
                    lambdaQueryWrapper1.eq(PmContractUnitRef::getDemandId,demandId)
                            .eq(PmContractUnitRef::getContractInfoId,pmContractInfo.getId())
                            .eq(PmContractUnitRef::getUnitId,baseUnitInformation.getId())
                            .eq(PmContractUnitRef::getUnitType,"A");
                    PmContractUnitRef pmContractUnitRef = this.pmContractUnitRefService.getOne(lambdaQueryWrapper1);
                    if(pmContractUnitRef != null){
                        pmBaseUnitInformationVo.setContractSignPlace(pmContractUnitRef.getContractSignPlace());
                        pmBaseUnitInformationVo.setContractSignDate(pmContractUnitRef.getContractSignDate());
                    }
                    pmContractInfoResVo.setPmBaseUnitInformationVo(pmBaseUnitInformationVo);

                    LambdaQueryWrapper<PmContractUnitRef> lambdaQueryWrapper2 = new LambdaQueryWrapper<>();
                    lambdaQueryWrapper2.eq(PmContractUnitRef::getDemandId,demandId)
                            .eq(PmContractUnitRef::getContractInfoId,pmContractInfo.getId())
                            .eq(PmContractUnitRef::getUnitType,"B");
                    List<PmContractUnitRef> pmContractUnitRefList = this.pmContractUnitRefService.list(lambdaQueryWrapper2);
                    if(!ObjectUtils.isEmpty(pmContractUnitRefList)){
                        List<PmBaseSupplierVo> pmBaseSupplierList = new ArrayList<>();
                        for(PmContractUnitRef pmContractUnitRef1 :pmContractUnitRefList ){
                            BaseSupplier baseSupplier = this.baseSupplierService.getById(pmContractUnitRef1.getUnitId());
                            PmBaseSupplierVo pmBaseSupplierVo = new PmBaseSupplierVo();
                            BeanUtils.copyProperties(baseSupplier,pmBaseSupplierVo);
                            pmBaseSupplierVo.setContractSignPlace(pmContractUnitRef.getContractSignPlace());
                            pmBaseSupplierVo.setContractSignDate(pmContractUnitRef.getContractSignDate());
                            pmBaseSupplierList.add(pmBaseSupplierVo);
                        }
                        pmContractInfoResVo.setBaseSupplierList(pmBaseSupplierList);
                    }

                    //合同信息文件
                    HashMap<String, String> pmContractInfoFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_CONTRACT_INFO.getType());
                    if(pmContractInfoFileMap != null){
                        pmContractInfoResVo.setFileMap(pmContractInfoFileMap);
                    }
                    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);

                    //建设情况文件
                    HashMap<String, String> projectConstructionFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_PROJECT_CONSTRUCTION.getType());
                    if(projectConstructionFileMap != null){
                        pmProjectConstructionResVo.setFileMap(projectConstructionFileMap);
                    }
                    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 )");
        } else  if(reqType== 4) { //合同信息列表
            lw.apply("(project_status = 10 or project_status = 11 )");
        }  else  if(reqType== 5) { //项目建设列表
            lw.apply("(project_status = 11 or project_status = 12 )");
        }

        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> pmDemandResponseVoList = new ArrayList<>();
            for(PmDemand pmDemand1 : pageRes.getRecords()){
                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;
                    }
                }
                pmDemandResponseVoList.add(vo);
            }
            results.setRecords(pmDemandResponseVoList);
        }

        return results;
    }


    /**
     * 需求建档
     *
     * @param vo 采购需求
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean bookBuilding(PmBookBuildingReqVo vo) {
        PmDemand pmDemand = this.getById(vo.getDemandId());
        String projectType = pmDemand.getProjectType();
        if(ProjectTypes.EQUIPMENTTYPE.getCode().equals(projectType)){ //装备类
            PmDemandEquipReqVo pmDemandEquipReqVo =  vo.getPmDemandEquipReqVo();

            LambdaQueryWrapper<PmDemandEquip> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(PmDemandEquip::getDemandId,vo.getDemandId());
            PmDemandEquip pmDemandEquip = iPmDemandEquipService.getOne(lambdaQueryWrapper);

            if(pmDemandEquip != null){
                pmDemandEquipReqVo.setDemandEquipId(pmDemandEquip.getDemandEquipId());
                BeanUtils.copyProperties(pmDemandEquipReqVo,pmDemandEquip);
                pmDemandEquip.setUpdateBy(vo.getUpdateBy());
                pmDemandEquip.setUpdateTime(new Date());
                iPmDemandEquipService.updateById(pmDemandEquip);
            } else {
                pmDemandEquip = new PmDemandEquip();
                BeanUtils.copyProperties(pmDemandEquipReqVo,pmDemandEquip);
                pmDemandEquip.setCreateBy(vo.getUpdateBy());
                pmDemandEquip.setCreateTime(new Date());
                pmDemandEquip.setUpdateBy(vo.getUpdateBy());
                pmDemandEquip.setUpdateTime(pmDemandEquip.getCreateTime());
                iPmDemandEquipService.save(pmDemandEquip);
            }

            List<SysFileRef> sysFileRefs = pmDemandEquipReqVo.getSysFileRefs();
            uploadFile(pmDemandEquip.getDemandEquipId(),SysFileRefEnum.PM_DEMAND_EQUIP.getType(),sysFileRefs,vo.getUpdateBy());

        } else if(ProjectTypes.MATERIALTYPE.getCode().equals(projectType)) { //物资类
            PmDemandMaterialsReqVo pmDemandMaterialsReqVo =  vo.getPmDemandMaterialsReqVo();

            LambdaQueryWrapper<PmDemandMaterials> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(PmDemandMaterials::getDemandId,vo.getDemandId());
            PmDemandMaterials pmDemandMaterials = iPmDemandMaterialsService.getOne(lambdaQueryWrapper);

            if(pmDemandMaterials != null){
                pmDemandMaterialsReqVo.setDemandMaterialsId(pmDemandMaterials.getDemandMaterialsId());
                BeanUtils.copyProperties(pmDemandMaterialsReqVo,pmDemandMaterials);
                pmDemandMaterials.setUpdateBy(vo.getUpdateBy());
                pmDemandMaterials.setUpdateTime(new Date());
                iPmDemandMaterialsService.updateById(pmDemandMaterials);
            } else {
                pmDemandMaterials = new PmDemandMaterials();
                BeanUtils.copyProperties(pmDemandMaterialsReqVo,pmDemandMaterials);
                pmDemandMaterials.setCreateBy(vo.getUpdateBy());
                pmDemandMaterials.setCreateTime(new Date());
                pmDemandMaterials.setUpdateBy(vo.getUpdateBy());
                pmDemandMaterials.setUpdateTime(pmDemandMaterials.getCreateTime());
                iPmDemandMaterialsService.save(pmDemandMaterials);
            }

            List<SysFileRef> sysFileRefs = pmDemandMaterialsReqVo.getSysFileRefs();
            uploadFile(pmDemandMaterials.getDemandMaterialsId(),SysFileRefEnum.PM_DEMAND_MATERIALS.getType(),sysFileRefs,vo.getUpdateBy());

        } else if(ProjectTypes.SERVICESTYPE.getCode().equals(projectType)) { //服务类
            PmDemandServeReqVo pmDemandServeReqVo =  vo.getPmDemandServeReqVo();

            LambdaQueryWrapper<PmDemandServe> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(PmDemandServe::getDemandId,vo.getDemandId());
            PmDemandServe pmDemandServe = iPmDemandServeService.getOne(lambdaQueryWrapper);

            if(pmDemandServe != null){
                pmDemandServeReqVo.setDemandServeId(pmDemandServe.getDemandServeId());
                BeanUtils.copyProperties(pmDemandServeReqVo,pmDemandServe);
                pmDemandServe.setUpdateBy(vo.getUpdateBy());
                pmDemandServe.setUpdateTime(new Date());
                iPmDemandServeService.updateById(pmDemandServe);
            } else {
                pmDemandServe = new PmDemandServe();
                BeanUtils.copyProperties(pmDemandServeReqVo,pmDemandServe);
                pmDemandServe.setCreateBy(vo.getUpdateBy());
                pmDemandServe.setCreateTime(new Date());
                pmDemandServe.setUpdateBy(vo.getUpdateBy());
                pmDemandServe.setUpdateTime(pmDemandServe.getCreateTime());
                iPmDemandServeService.save(pmDemandServe);
            }
            List<SysFileRef> sysFileRefs = pmDemandServeReqVo.getSysFileRefs();
            uploadFile(pmDemandServe.getDemandServeId(),SysFileRefEnum.PM_DEMAND_SERVE.getType(),sysFileRefs,vo.getUpdateBy());

        } else if(ProjectTypes.PLANTOEXAMINETYPE.getCode().equals(projectType)) { //工程类
            PmDemandEngineeringReqVo pmDemandEngineeringReqVo =  vo.getPmDemandEngineeringReqVo();

            LambdaQueryWrapper<PmDemandEngineering> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(PmDemandEngineering::getDemandId,vo.getDemandId());
            PmDemandEngineering pmDemandEngineering = iPmDemandEngineeringService.getOne(lambdaQueryWrapper);

            if(pmDemandEngineering != null){
                pmDemandEngineeringReqVo.setDemandEngineeringId(pmDemandEngineering.getDemandEngineeringId());
                BeanUtils.copyProperties(pmDemandEngineeringReqVo,pmDemandEngineering);
                pmDemandEngineering.setUpdateBy(vo.getUpdateBy());
                pmDemandEngineering.setUpdateTime(new Date());
                iPmDemandEngineeringService.updateById(pmDemandEngineering);
            } else {
                pmDemandEngineering = new PmDemandEngineering();
                BeanUtils.copyProperties(pmDemandEngineeringReqVo,pmDemandEngineering);
                pmDemandEngineering.setCreateBy(vo.getUpdateBy());
                pmDemandEngineering.setCreateTime(new Date());
                pmDemandEngineering.setUpdateBy(vo.getUpdateBy());
                pmDemandEngineering.setUpdateTime(pmDemandEngineering.getCreateTime());
                iPmDemandEngineeringService.save(pmDemandEngineering);
            }
            List<SysFileRef> sysFileRefs = pmDemandEngineeringReqVo.getSysFileRefs();
            uploadFile(pmDemandEngineering.getDemandEngineeringId(),SysFileRefEnum.PM_DEMAND_ENGINEERING.getType(),sysFileRefs,vo.getUpdateBy());

        }

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

    private HashMap<String, String> getFileMap(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)) {
            HashMap<String, String> fileMap = new HashMap<>();
            for (SysFileRef ref : fileRefs) {
                SysFileInfo fileInfo = fileService.getById(ref.getFileId());
                fileMap.put(fileInfo.getFileUrl(), fileInfo.getFileName());
            }
            return fileMap;
        } 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){
        PmDemand pmDemand = this.getById(demandId);
        String projectType = pmDemand.getProjectType();

        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)) {
            HashMap<String, String> fileMap = getFileMap(demandId,SysFileRefEnum.PM_DEMAND.getType());
            if(fileMap != null){
                vo.setFileMap(fileMap);
            }
        } else if("需求提交".equals(moduleName)) {
            if(ProjectTypes.EQUIPMENTTYPE.getCode().equals(projectType)){ //装备类
                LambdaQueryWrapper<PmDemandEquip> pmDemandEquipLambdaQueryWrapper = new LambdaQueryWrapper<>();
                pmDemandEquipLambdaQueryWrapper.eq(PmDemandEquip::getDemandId,demandId);
                PmDemandEquip pmDemandEquip = iPmDemandEquipService.getOne(pmDemandEquipLambdaQueryWrapper);
                if(pmDemandEquip != null){
                    HashMap<String, String> fileMap = getFileMap(pmDemandEquip.getDemandEquipId(),SysFileRefEnum.PM_DEMAND_EQUIP.getType());
                    if(fileMap != null){
                        vo.setFileMap(fileMap);
                    }
                }
            } else if(ProjectTypes.MATERIALTYPE.getCode().equals(projectType)) { //物资类
                LambdaQueryWrapper<PmDemandMaterials> pmDemandMaterialsLambdaQueryWrapper = new LambdaQueryWrapper<>();
                pmDemandMaterialsLambdaQueryWrapper.eq(PmDemandMaterials::getDemandId,demandId);
                PmDemandMaterials pmDemandMaterials = iPmDemandMaterialsService.getOne(pmDemandMaterialsLambdaQueryWrapper);
                if(pmDemandMaterials != null){
                    HashMap<String, String> fileMap = getFileMap(pmDemandMaterials.getDemandMaterialsId(),SysFileRefEnum.PM_DEMAND_MATERIALS.getType());
                    if(fileMap != null){
                        vo.setFileMap(fileMap);
                    }
                }
            } else if(ProjectTypes.SERVICESTYPE.getCode().equals(projectType)) { //服务类
                LambdaQueryWrapper<PmDemandServe> pmDemandServeLambdaQueryWrapper = new LambdaQueryWrapper<>();
                pmDemandServeLambdaQueryWrapper.eq(PmDemandServe::getDemandId,demandId);
                PmDemandServe pmDemandServe = iPmDemandServeService.getOne(pmDemandServeLambdaQueryWrapper);
                if(pmDemandServe != null){
                    HashMap<String, String> fileMap = getFileMap(pmDemandServe.getDemandServeId(),SysFileRefEnum.PM_DEMAND_SERVE.getType());
                    if(fileMap != null){
                        vo.setFileMap(fileMap);
                    }
                }
            } else if(ProjectTypes.PLANTOEXAMINETYPE.getCode().equals(projectType)) { //工程类
                LambdaQueryWrapper<PmDemandEngineering> pmDemandEngineeringLambdaQueryWrapper = new LambdaQueryWrapper<>();
                pmDemandEngineeringLambdaQueryWrapper.eq(PmDemandEngineering::getDemandId,demandId);
                PmDemandEngineering pmDemandEngineering = iPmDemandEngineeringService.getOne(pmDemandEngineeringLambdaQueryWrapper);
                if(pmDemandEngineering != null){
                    HashMap<String, String> fileMap = getFileMap(pmDemandEngineering.getDemandEngineeringId(),SysFileRefEnum.PM_DEMAND_ENGINEERING.getType());
                    if(fileMap != null){
                        vo.setFileMap(fileMap);
                    }
                }
            }

        } else if("需求审核".equals(moduleName)) {
            HashMap<String, String> fileMap = getFileMap(demandId,SysFileRefEnum.PM_DEMAND_EXAMINE.getType());
            if(fileMap != null){
                vo.setFileMap(fileMap);
            }
        } else if("任务下达".equals(moduleName)) {
            //todo
        }

         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(Long.parseLong(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(Long.parseLong(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(Long.parseLong(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(Long.parseLong(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 {

        PmReleaseAnnouncement pmReleaseAnnouncement = new PmReleaseAnnouncement();
        BeanUtils.copyProperties(pmReleaseAnnouncementReqVo,pmReleaseAnnouncement);
        if(pmReleaseAnnouncementService.save(pmReleaseAnnouncement)){
            if (uploadFile(pmReleaseAnnouncement.getId(), SysFileRefEnum.PM_ANNOUNCEMENT_FILE.getType(),pmReleaseAnnouncementReqVo.getSysFileRefs(),pmReleaseAnnouncementReqVo.getUpdateBy())) {
                PmDemand pmDemandUpdate = new PmDemand();
                pmDemandUpdate.setDemandId(pmReleaseAnnouncementReqVo.getDemandId());
                pmDemandUpdate.setProjectStatus(Long.parseLong(PmProjectStatus.WAIT_OPEN_BID.getCode()));
                pmDemandUpdate.setUpdateTime(pmReleaseAnnouncementReqVo.getUpdateTime());
                pmDemandUpdate.setUpdateBy(pmReleaseAnnouncementReqVo.getUpdateBy());
                 return this.updateById(pmDemandUpdate);
                 //TODO 发布公告生成后，会默认将该数据同步到公告管理和首页中

            } 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();
        List<PmDemandExpertRef> pmDemandExpertRefList = new ArrayList<>();
        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);
            }

            PmDemandExpertRef pmDemandExpertRef = new PmDemandExpertRef();
            pmDemandExpertRef.setDemandId(pmDemand.getDemandId());
            pmDemandExpertRef.setExpertId(baseExpert.getId().longValue());
            pmDemandExpertRef.setCreateBy(pmBaseExpertFillReqVo.getCreateBy());
            pmDemandExpertRef.setAccessTime(DateUtils.parseDate(pmBaseExpertFillReqVo.getAccessTime()));
            pmDemandExpertRef.setCreateTime(now);
            pmDemandExpertRef.setUpdateBy(pmBaseExpertFillReqVo.getCreateBy());
            pmDemandExpertRef.setUpdateTime(pmDemandExpertRef.getCreateTime());
            pmDemandExpertRefList.add(pmDemandExpertRef);
        }

          if (baseExpertService.saveOrUpdateBatch(baseExpertList)){
              return pmDemandExpertRefService.saveBatch(pmDemandExpertRefList);
          } else {
              return false;
          }
    }

    @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("抽取备用专家必须选择专家专业");
       }
       String  localArea = pmBaseExpertExtractReqVo.getLocalArea();
       if(spareExpertNumber > 0 && ObjectUtils.isEmpty(localArea)){
           throw new Exception("抽取备用专家必须选择所在区域");
       }

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

       //从专家库中查询符合项目类型的以及是白名单的全部列表
       LambdaQueryWrapper<BaseExpert> lw = new LambdaQueryWrapper<BaseExpert>();
       lw.eq(BaseExpert::getVarietyPurchase,pmDemand.getProjectType())
               .eq(BaseExpert::getStatus,NameListType.WHITE.getCode());
       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<>();

       //TODO 所在区域判读

       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 ) {
              PmDemandExpertRef pmDemandExpertRef = new PmDemandExpertRef();
              pmDemandExpertRef.setDemandId(pmDemand.getDemandId());
              pmDemandExpertRef.setExpertId(baseExpert.getId().longValue());
              pmDemandExpertRef.setCreateBy(pmBaseExpertExtractReqVo.getCreateBy());
              pmDemandExpertRef.setAccessTime(DateUtils.parseDate(pmBaseExpertExtractReqVo.getAccessTime()));
              pmDemandExpertRef.setCreateTime(new Date());
              pmDemandExpertRef.setUpdateBy(pmBaseExpertExtractReqVo.getCreateBy());
              pmDemandExpertRef.setUpdateTime(pmDemandExpertRef.getCreateTime());
              pmDemandExpertRefList.add(pmDemandExpertRef);
          }
          return pmDemandExpertRefService.saveBatch(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.saveBatch(pmBidOpeningList)) {
           PmDemand pmDemandUpdate = new PmDemand();
           pmDemandUpdate.setDemandId(pmDemand.getDemandId());
           pmDemandUpdate.setProjectStatus(Long.parseLong(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.save(pmBidWinning)){
           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);
           }
          if (pmBidWinningOpeningRefService.saveBatch(pmBidWinningOpeningRefList)) {
              if(uploadFile(pmBidWinning.getId(), SysFileRefEnum.PM_BID_WINNING_FILE.getType(),pmBidWinningReqVo.getSysFileRefs(),pmBidWinningReqVo.getUpdateBy())) {
                  PmDemand pmDemandUpdate = new PmDemand();
                  pmDemandUpdate.setDemandId(pmBidWinningReqVo.getDemandId());
                  pmDemandUpdate.setProjectStatus(Long.parseLong(PmProjectStatus.BIDDING_PUBLICITY.getCode()));
                  pmDemandUpdate.setUpdateTime(pmBidWinningReqVo.getUpdateTime());
                  pmDemandUpdate.setUpdateBy(pmBidWinningReqVo.getUpdateBy());
                  return this.updateById(pmDemandUpdate);
              } else {
                  return false;
              }
          } 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.save(pmBidFailure)){
            return uploadFile(pmBidFailure.getId(), SysFileRefEnum.PM_BID_FAILURE_FILE.getType(),pmBidFailureReqVo.getSysFileRefs(),pmBidFailureReqVo.getUpdateBy());
        } 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不能为空");
        }

        String contractSignPlaceA = pmContractInfoReqVo.getPmBaseUnitInformationVo().getContractSignPlace();
        if(ObjectUtils.isEmpty(contractSignPlaceA)) {
            throw new Exception("甲方合同签订地点不能为空");
        }
        Date contractSignDateA = pmContractInfoReqVo.getPmBaseUnitInformationVo().getContractSignDate();
        if(ObjectUtils.isEmpty(contractSignDateA)) {
            throw new Exception("甲方合同签订日期不能为空");
        }

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

        List<PmBaseSupplierVo> baseSupplierList = pmContractInfoReqVo.getBaseSupplierList();
        if(ObjectUtils.isEmpty(baseSupplierList)){
            throw new Exception("乙方信息列表不能为空");
        }
        for(PmBaseSupplierVo baseSupplierVo : baseSupplierList) {
            String contractSignPlaceB = baseSupplierVo.getContractSignPlace();
            if(ObjectUtils.isEmpty(contractSignPlaceB)) {
                throw new Exception("乙方合同签订地点不能为空");
            }
            Date contractSignDateB = baseSupplierVo.getContractSignDate();
            if(ObjectUtils.isEmpty(contractSignDateB)) {
                throw new Exception("乙方合同签订日期不能为空");
            }
        }

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

        PmContractInfo pmContractInfo = new PmContractInfo();
        org.springframework.beans.BeanUtils.copyProperties(pmContractInfoReqVo,pmContractInfo);

        if(pmContractInfoService.save(pmContractInfo)){
            if (this.uploadFile(pmContractInfo.getId(), SysFileRefEnum.PM_CONTRACT_INFO.getType(),sysFileRefs,pmContractInfoReqVo.getUpdateBy())) {
                PmContractUnitRef pmContractUnitRefA = new PmContractUnitRef();
                pmContractUnitRefA.setContractInfoId(pmContractInfo.getId());
                pmContractUnitRefA.setDemandId(demandId);
                pmContractUnitRefA.setUnitId(pmDemand.getPurchaseDeptId());
                pmContractUnitRefA.setContractSignPlace(contractSignPlaceA);
                pmContractUnitRefA.setContractSignDate(contractSignDateA);
                pmContractUnitRefA.setUnitType("A");
                pmContractUnitRefA.setCreateBy(pmContractInfoReqVo.getCreateBy());
                pmContractUnitRefA.setCreateTime(pmContractInfoReqVo.getCreateTime());
                pmContractUnitRefA.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
                pmContractUnitRefA.setUpdateBy(pmContractInfoReqVo.getUpdateBy());
                if(pmContractUnitRefService.save(pmContractUnitRefA)){

                    for(PmBaseSupplierVo baseSupplierReqVo : baseSupplierList) {

                        BaseSupplier baseSupplier = new BaseSupplier();
                        BeanUtils.copyProperties(baseSupplierReqVo,baseSupplier);

                        if(ObjectUtils.isEmpty(baseSupplier.getSupplierAdvancePurchase())){
                            baseSupplier.setSupplierAdvancePurchase("0"); //关闭
                        }

                        if(ObjectUtils.isEmpty(baseSupplier.getSupplierType())){
                            baseSupplier.setSupplierType(pmDemand.getProjectType());
                        }

                        if(ObjectUtils.isEmpty(baseSupplier.getSupplierState())){
                            baseSupplier.setSupplierState(NameListType.WHITE.getCode());
                        }

                        if(ObjectUtils.isEmpty(baseSupplier.getCreated())){
                            baseSupplier.setCreated(pmContractInfoReqVo.getCreateBy());
                            baseSupplier.setCreateTime(pmContractInfoReqVo.getCreateTime());
                        }

                        if(ObjectUtils.isEmpty(baseSupplier.getUpdated())){
                            baseSupplier.setUpdated(pmContractInfoReqVo.getUpdateBy());
                            baseSupplier.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
                        }
                       if(baseSupplierService.saveOrUpdate(baseSupplier)) {
                           String contractSignPlaceB = baseSupplierReqVo.getContractSignPlace();
                           Date contractSignDateB = baseSupplierReqVo.getContractSignDate();

                           PmContractUnitRef pmContractUnitRefB = new PmContractUnitRef();
                           pmContractUnitRefB.setContractInfoId(pmContractInfo.getId());
                           pmContractUnitRefB.setDemandId(demandId);
                           pmContractUnitRefA.setUnitId(baseSupplier.getId().longValue());
                           pmContractUnitRefB.setContractSignPlace(contractSignPlaceB);
                           pmContractUnitRefB.setContractSignDate(contractSignDateB);
                           pmContractUnitRefB.setUnitType("B");
                           pmContractUnitRefB.setCreateBy(pmContractInfoReqVo.getCreateBy());
                           pmContractUnitRefB.setCreateTime(pmContractInfoReqVo.getCreateTime());
                           pmContractUnitRefB.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
                           pmContractUnitRefB.setUpdateBy(pmContractInfoReqVo.getUpdateBy());
                           if(!this.pmContractUnitRefService.save(pmContractUnitRefB)){
                               throw new Exception("保存合同单位关系失败");
                           }
                       } else {
                           throw new Exception("保存或更新供应商失败");
                       }
                    }

                } else {
                    throw new Exception("保存合同单位关系失败");
                }

                PmDemand pmDemandUpdate = new PmDemand();
                pmDemandUpdate.setDemandId(demandId);
                pmDemandUpdate.setProjectStatus(Long.parseLong(PmProjectStatus.UNDER_CONSTRUCTION.getCode()));
                pmDemandUpdate.setUpdateTime(pmContractInfoReqVo.getUpdateTime());
                pmDemandUpdate.setUpdateBy(pmContractInfoReqVo.getUpdateBy());
                return this.updateById(pmDemandUpdate);
            } else {
                throw new Exception("保存附件失败");
            }
        } 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("上传附件不能为空");
        }

        PmProjectConstruction pmProjectConstruction = new PmProjectConstruction();
        org.springframework.beans.BeanUtils.copyProperties(pmProjectConstructionReqVo,pmProjectConstruction);

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