YiWuProject.git

			@@ -1,21 +1,32 @@
			package com.mes.pp.service.impl;

			import cn.smallbun.screw.core.util.CollectionUtils;
			import com.baomidou.dynamic.datasource.annotation.DS;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
			import com.baomidou.mybatisplus.core.toolkit.StringUtils;
			import com.github.yulichang.base.MPJBaseServiceImpl;
			import com.mes.engineerScheduling.entity.EngineerScheduling;
			import com.mes.engineerScheduling.service.EngineerSchedulingService;
			import com.mes.engineering.entity.Engineering;
			import com.mes.engineering.service.EngineeringService;
			import com.mes.pp.entity.OptimizeProject;
			import com.mes.pp.entity.dto.ProgressDTO;
			import com.mes.pp.entity.request.OptimizeRequest;
			import com.mes.pp.mapper.OptimizeProjectMapper;
			import com.mes.pp.service.OptimizeProjectService;
			import com.mes.uppattenusage.entity.UpPattenUsage;
			import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
			import lombok.extern.slf4j.Slf4j;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;

			import javax.annotation.Resource;
			import java.time.LocalDateTime;
			import java.util.ArrayList;
			import java.util.HashSet;
			import java.util.List;
			import java.util.Set;
			import java.util.stream.Collectors;

			/**
			* <p>
			@@ -29,44 +40,174 @@
			@DS("pp")
			@Slf4j
			public class OptimizeProjectServiceImpl extends MPJBaseServiceImpl<OptimizeProjectMapper, OptimizeProject> implements OptimizeProjectService {
			@Autowired
			private EngineeringService engineeringService;
			@Autowired
			private EngineerSchedulingService engineerSchedulingService;

			@Resource
			UpPattenUsageMapper upPattenUsageMapper;
			@Override
			public List<OptimizeProject> listByState(OptimizeRequest optimizeRequest) {
			log.info("将参数传入到查询类里,工程号做非空判断模糊查询");
			//PP表未开始的工程号
			// 计算二个月前的时间
			LocalDateTime twoMonthAgo = LocalDateTime.now().minusMonths(2);
			LambdaQueryWrapper<OptimizeProject> wrapper = new LambdaQueryWrapper<>();
			wrapper.eq(OptimizeProject::getState,optimizeRequest.getState())
			.like(StringUtils.isNotBlank(optimizeRequest.getProjectNo()),OptimizeProject::getProjectNo,optimizeRequest.getProjectNo())
			//.groupBy(OptimizeProject::getProjectNo)
			;
			log.info("返回工程信息");
			return this.list(wrapper);
			}
			wrapper.select(OptimizeProject::getProjectNo, OptimizeProject::getProjectName)
			.eq(OptimizeProject::getState, optimizeRequest.getState())
			.ge(OptimizeProject::getCreateTime, twoMonthAgo);
			List<OptimizeProject> glass = this.list(wrapper);
			//暂停的工程号
			List<Engineering> engineerings = engineeringService.selectTask();


			@Override
			public void insetupPattenUsage(List<OptimizeProject> glass) {
			log.info("循环查询结果保存到UpPattenUsage表中");
			for (OptimizeProject project : glass) {
			UpPattenUsage upPattenUsage = new UpPattenUsage();
			upPattenUsage.setEngineeringId(project.getProjectNo());
			upPattenUsage.setFilmsId(project.getGlassType());
			upPattenUsage.setState(project.getState());
			upPattenUsageMapper.insert(upPattenUsage);
			for (int i = 0; i < engineerings.size(); i++) {
			Engineering engineering = engineerings.get(i);
			OptimizeProject newProject = new OptimizeProject();
			newProject.setProjectNo(engineering.getEngineerId());
			newProject.setProjectName(engineering.getEngineerName());
			// 将新创建的 OptimizeProject 对象添加到 glass 列表中
			glass.add(newProject);
			}
			//返回工程信息
			return glass;
			}


			@Override
			public void changeTask(String engineeringId, int state) {
			UpdateWrapper<OptimizeProject> wrapper = new UpdateWrapper<>();
			wrapper.eq("project_no",engineeringId)
			.set("state",state);
			wrapper.eq("project_no", engineeringId)
			.set("state", state);
			boolean updateSuccess = this.update(wrapper);
			log.info("工程表更新状态{}",updateSuccess);
			log.info("工程表更新状态{}", updateSuccess);

			}

			@Override
			public boolean overTask(UpPattenUsage sequence, int state) {
			if (sequence.getState() == 100) {
			UpdateWrapper<OptimizeProject> wrapper = new UpdateWrapper<>();
			wrapper.eq("project_no", sequence.getEngineeringId())
			.set("state", state);
			boolean updateSuccess = this.update(wrapper);
			log.info("工程完成更新状态{}", updateSuccess);
			}
			return false;
			}

			@Override
			public List<OptimizeProject> getDoingTask() {
			QueryWrapper<OptimizeProject> wrapper = new QueryWrapper<>();
			wrapper.select("project_no,project_name")
			.eq("state", 200);
			return this.list(wrapper);
			}

			@Override
			public List<OptimizeProject> queryEngineer() {
			return this.baseMapper.queryEngineer();
			}

			@Override
			public List<OptimizeProject> engineerScheduling(OptimizeProject optimizeProject) {
			return this.baseMapper.engineerScheduling(optimizeProject);
			}

			@Override
			@Transactional(rollbackFor = Exception.class)
			public List<OptimizeProject> updateEngineerScheduling(Integer type, List<OptimizeProject> projectList) {
			// 1. 删除对应类型的数据
			baseMapper.deleteByType(type);
			// 2. 设置值
			projectList.forEach(project -> {
			project.setType(type);
			project.setState(100);
			project.setId(null); // 清除ID
			});
			if (CollectionUtils.isNotEmpty(projectList)) {
			// 3. 批量插入新数据
			baseMapper.batchInsert(projectList);
			}

			return projectList;
			}
			@Override
			@Transactional(rollbackFor = Exception.class)
			@DS("north_glass_mes")
			public List<OptimizeProject> updateCuttingLayout(Integer type, List<OptimizeProject> projectList) {
			//获取当前钢化排版信息
			List<EngineerScheduling> engineerScheduling = engineerSchedulingService.queryByType(3);
			List<EngineerScheduling> cutting = new ArrayList<>();
			if(type==1){
			cutting = engineerSchedulingService.queryByType(2);
			}else {
			cutting = engineerSchedulingService.queryByType(1);
			}
			//保存新增钢化排版信息
			List<EngineerScheduling> newSchedulingList = new ArrayList<>();
			Set<String> existingProjectNoSet = engineerScheduling.stream()
			.map(EngineerScheduling::getProjectNo)
			.collect(Collectors.toSet());
			// 获取当前排版新增工程
			for (OptimizeProject project : projectList) {
			String projectNo = project.getProjectNo();
			// 工程号非空，且不在已有钢化排产数据中
			if (projectNo != null && !existingProjectNoSet.contains(projectNo)) {
			EngineerScheduling newEs = new EngineerScheduling();
			newEs.setProjectNo(projectNo);
			newEs.setProjectName(project.getProjectName());
			newEs.setType(3);
			newEs.setState(100);
			newSchedulingList.add(newEs);
			}
			}
			//获取当前排版取消工程
			Set<String> cuttingProjectNos = new HashSet<>();
			for (EngineerScheduling es : cutting) {
			if (es.getProjectNo() != null) { // 避免空指针
			cuttingProjectNos.add(es.getProjectNo());
			}
			}
			engineerScheduling = engineerScheduling.stream()
			.filter(es -> es.getProjectNo() == null \|\| !cuttingProjectNos.contains(es.getProjectNo()))
			.collect(Collectors.toList());
			//1号线钢化数据对比1号线切割数据
			Set<String> projectNoSet2 = new HashSet<>();
			for (OptimizeProject project : projectList) {
			String projectNo = project.getProjectNo();
			if (projectNo != null) { // 避免空指针
			projectNoSet2.add(projectNo);
			}
			}
			// 2. 筛选并收集符合条件的工程号（String类型）到 List<String>
			List<String> missingProjectNos = engineerScheduling.stream()
			.map(EngineerScheduling::getProjectNo) // 提取 engineerScheduling 中的工程号
			.filter(esProjectNo -> esProjectNo != null // 排除空工程号
			&& !projectNoSet2.contains(esProjectNo)) // 排除 projectList 中存在的工程号
			.collect(Collectors.toList()); // 收集结果到 List<String>
			for (OptimizeProject project : projectList) {
			project.setType(type);
			project.setState(100);
			}
			//新增钢化排版数据
			engineerSchedulingService.saveBatch(newSchedulingList);
			//更新已取消的钢化排版状态
			if(CollectionUtils.isNotEmpty(missingProjectNos)){
			engineerSchedulingService.updateState(missingProjectNos);
			}
			//取消当前类型的工程排产信息
			engineerSchedulingService.updateByType(type);
			//保存当前新切割排版数据
			baseMapper.batchInsert(projectList);
			return projectList;
			}

			@Override
			public void deleteengineerSchedulingByid(String engineerId, List<Integer> types) {
			baseMapper.deleteByScheduling(engineerId, types);
			}

			@Override
			public List<ProgressDTO> selectProgress(String engineerId) {
			return baseMapper.selectProgress(engineerId);
			}
			}