~admin/ERP_override.git

			@@ -174,17 +174,30 @@
			}
			//主表插入
			reportingWorkMapper.insert(reportingWork);

			//副表循环插入，并且插入次破信息表。再根据次破信息修改订单玻璃流程表的完工数量与刺破数量
			reportingWorkDetails.forEach(reportingWorkDetail -> {
			// reportingWork.setThisProcessQuantity(
			// reportingWork.getThisProcessQuantity()
			// +reportingWorkDetail.getCompletedQuantity()
			// +reportingWorkDetail.getBreakageQuantity());
			// reportingWork.setThisCompletedQuantity(
			// reportingWork.getThisCompletedQuantity()+reportingWorkDetail.getCompletedQuantity());
			// reportingWork.setThisWornQuantity(
			// reportingWork.getThisWornQuantity()+reportingWorkDetail.getBreakageQuantity());


			reportingWorkDetail.setReportingWorkId(reportingWorkId);
			List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
			//次破明细表插入数据
			if(damageDetails!=null && !damageDetails.isEmpty()){
			damageDetails.forEach(damageDetail ->{
			damageDetail.setReportingWorkId(reportingWorkId);
			damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
			damageDetail.setProcessId(reportingWork.getProcessId());
			damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
			if(damageDetail.getResponsibleProcess()!=reportingWork.getThisProcess()){
			damageDetail.setQualityInsStatus(1);
			}
			damageDetailsMapper.insert(damageDetail);
			});
			}
			@@ -241,7 +254,12 @@
			.setSql("reporting_work_num =reporting_work_num +"+orderProcessDetail.getReportingWorkNum())
			.setSql("broken_num =broken_num +"+orderProcessDetail.getBrokenNum());
			orderProcessDetailMapper.update(null,updateWrapper);
			reportingWorkDetailMapper.insert(reportingWorkDetail);

			//判断完工数量和刺破数量是否为0，为0则不插入到数据库
			if(!(reportingWorkDetail.getCompletedQuantity()==0 && reportingWorkDetail.getBreakageQuantity()==0)){
			reportingWorkDetailMapper.insert(reportingWorkDetail);
			}

			//更新流程卡表的报工数量
			if(Objects.equals(reportingWork.getNextProcess(), "")){
			LambdaUpdateWrapper<FlowCard> flowCardLambdaUpdateWrapper =
			@@ -256,6 +274,7 @@


			});

			return true;
			}

			@@ -277,21 +296,208 @@
			return true;
			}

			//报工修改查询
			public Map<String,Object> selectUpdateReportingWorkSv(String reportingWorkId) {
			//查询报工主表信息
			ReportingWork reportingWork =reportingWorkMapper.selectOne(new LambdaQueryWrapper<ReportingWork>()
			.eq(ReportingWork::getReportingWorkId,reportingWorkId));
			//根据报工信息查询订单主表信息
			reportingWork.setOrder(
			orderMapper.selectOne(new LambdaQueryWrapper<Order>()
			.eq(Order::getOrderId,reportingWork.getOrderId())));
			reportingWork.setFlowCard(new FlowCard());

			List<ReportingWorkDetail> reportingWorkDetails = reportingWorkDetailMapper.selectByreportingWorkId(reportingWorkId);
			List<Map<String,Object>> reportingWorkDetails = reportingWorkMapper.selectByReportingWorkId(reportingWorkId,reportingWork.getNextProcess());
			reportingWorkDetails.forEach(reportingWorkDetail ->{
			List<DamageDetails> damageDetailsList = new ArrayList<>();
			damageDetailsList = damageDetailsMapper.selectList(new LambdaQueryWrapper<DamageDetails>()
			.eq(DamageDetails::getReportingWorkId,reportingWorkId)
			.eq(DamageDetails::getOrderNumber,reportingWorkDetail.get("order_number"))
			.eq(DamageDetails::getTechnologyNumber,reportingWorkDetail.get("technology_number"))
			);
			reportingWorkDetail.put("damageDetails",damageDetailsList);
			});


			Map<String,Object> map = new HashMap<>();
			map.put("reportingWork",reportingWork);
			map.put("reportingWorkDetails",reportingWorkDetails);
			map.put("basic",getReportingWorkBase(reportingWork.getProcessId(),reportingWork.getThisProcess()));



			return map;

			}

			private Map<String,Object> getReportingWorkBase(String processId, String thisProcess) {
			Map<String,Object> map = new HashMap<>();
			//设备下拉框
			map.put("deviceType", reportingWorkMapper.SelectWorkBasicDeviceMp(thisProcess));
			//班组下拉框
			map.put("teamsType", reportingWorkMapper.SelectWorkBasicTeamsMp(thisProcess));

			map.put("breakageType",reportingWorkMapper.selectBasicNameByType("breakagetype"));
			map.put("breakageReason",reportingWorkMapper.selectBasicNameByType("breakagereason"));

			//获取该流程卡号历史报工工序
			String historyProcess =reportingWorkMapper.historyProcessMp(processId);
			//历史报工工序设备
			map.put("historyDevice",reportingWorkMapper.historyDeviceMp(historyProcess,thisProcess));
			//历史报工工序班组
			map.put("historyTeams",reportingWorkMapper.historyTeamsMp(processId,thisProcess));
			//历史工序
			map.put("historyProcess",reportingWorkMapper.SelectHistoryProcessMp(historyProcess,thisProcess));

			return map;
			}


			@Transactional
			//报工修改
			public Boolean updateReportingWork(Map<String, Object> reportingWorkMap) {
			//接收解析主附表信息
			JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
			ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
			List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
			//删除刺破明细表刺破数据
			damageDetailsMapper.delete(
			new LambdaQueryWrapper<DamageDetails>()
			.eq(DamageDetails::getReportingWorkId,reportingWork.getReportingWorkId())
			);
			//修改小片流程表数量
			orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(),reportingWork.getThisProcess(),"delete");
			//删除报工明细表数据
			reportingWorkDetailMapper
			.delete(new LambdaQueryWrapper<ReportingWorkDetail>()
			.eq(ReportingWorkDetail::getReportingWorkId,reportingWork.getReportingWorkId()));

			//更细报工主表
			reportingWorkMapper.updateById(reportingWork);
			reportingWorkDetails.forEach(reportingWorkDetail->{
			List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
			//每一条报工数据循环插入次破明细表
			if(damageDetails!=null && !damageDetails.isEmpty()){
			damageDetails.forEach(damageDetail->{
			if(!Objects.equals(reportingWork.getThisProcess(), damageDetail.getResponsibleProcess())){
			damageDetail.setQualityInsStatus(1);
			}
			damageDetailsMapper.insert(damageDetail);
			});
			}
			//插入报工数据
			reportingWorkDetailMapper.insert(reportingWorkDetail);
			});
			//修改小片流程表数量为报工明细表数量
			orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(),reportingWork.getThisProcess(),"add");
			return true;
			}
			//报工管理查询
			public Map<String, Object> selectReportingWorkSv(Integer pageNum, Integer pageSize, java.sql.Date selectTime1, java.sql.Date selectTime2, String orderId, ReportingWork reportingWork) {
			Integer offset = (pageNum - 1) * pageSize;
			if (orderId.equals("null")) {
			orderId = "";
			}
			Map<String, Object> map = new HashMap<>();
			map.put("data", reportingWorkMapper.selectReportingWorkMp(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
			map.put("total", reportingWorkMapper.getPageTotal(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
			//System.out.println(map.get("data"));
			return map;
			}

			public Boolean deleteWorkSv(String reportingWorkId, String processId, String thisProcess) {
			if (!reportingWorkId.isEmpty() && !processId.isEmpty() && !thisProcess.isEmpty()) {
			//获取当前报工编号下工序
			String nextProcess = reportingWorkMapper.selectNextProcess(reportingWorkId);
			//查询当前报工编号下工序是否报工
			Integer count = reportingWorkMapper.selectCountByProcessId(processId, nextProcess);
			//获取最后一道工序
			String lastProcess = reportingWorkMapper.selectLastProcess(processId);
			//判断是否是入库工序
			if (lastProcess.equals(thisProcess)) {//是入库工序
			//查询该流程卡数量、可入库数量、已入库数量
			Map<String, Object> list = reportingWorkMapper.selectReceiptQuantity(processId);
			// System.out.println(list.get("quantity")+"--"+list.get("inventoryQuantity")+"---"+list.get("receivedQuantity"));
			if (list.get("quantity") == list.get("receiptQuantity")) {
			return false;
			} else {
			//转换类型:已入库数量
			Integer receiptQuantity = Integer.parseInt(list.get("receivedQuantity").toString());
			//转换类型:可入库数量
			Integer inventoryQuantity = Integer.parseInt(list.get("inventoryQuantity").toString());
			//查询该报工编号本工序完工数量
			Integer completedQuantity = reportingWorkMapper.selectCompletedQuantity(reportingWorkId);
			//当该工序完工数量小于等于已入库数量时
			//System.out.println("inventoryQuantity:" + inventoryQuantity +"completedQuantity:" + completedQuantity + "---receiptQuantity:" + receiptQuantity);
			//可入库数量-已入库数量>=报工编号本工序完工数量
			if (inventoryQuantity - receiptQuantity >= completedQuantity) {
			//查询当前报工编号完工次破数量的数据
			List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
			for (Map<String, Object> item : workDateList) {

			//更新流程卡可入库数量
			reportingWorkMapper.updateInventoryQuantity(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"));
			//更新报工流程表数据
			reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
			}
			//删除报工，将审核状态改为-1
			reportingWorkMapper.deleteWork(reportingWorkId);
			return true;
			} else {
			return false;
			}
			}

			}
			else{//不是入库工序
			if (count==0){
			//查询当前报工编号完工次破数量的数据
			List<Map<String, Object>> workDateList=reportingWorkMapper.reportingWorkDate(reportingWorkId);
			for (Map<String, Object> item : workDateList) {
			//更新报工流程表数据
			reportingWorkMapper.updateWorkProcess(processId,item.get("order_number"),item.get("technology_number"),item.get("completed_quantity"),item.get("breakage_quantity"),thisProcess);
			}
			//删除报工，将审核状态改为-1
			reportingWorkMapper.deleteWork(reportingWorkId);
			return true;
			}
			else {
			return false;
			}
			}


			} else {
			return false;
			}
			}

			public Map<String, Object> selectQualityTestingSv(Integer pageNum, Integer pageSize, java.sql.Date selectTime1, java.sql.Date selectTime2, Integer state, String processId, ReportingWork reportingWork) {
			Integer offset = (pageNum - 1) * pageSize;
			if (processId.equals("null")) {
			processId = "";
			}
			Map<String, Object> map = new HashMap<>();
			map.put("data", reportingWorkMapper.selectQualityTestingMp(offset, pageSize, selectTime1, selectTime2,state, processId, reportingWork));
			map.put("total", reportingWorkMapper.getQualityPageTotal(offset, pageSize, selectTime1, selectTime2,state, processId, reportingWork));

			return map;
			}

			public Boolean updateQualityStatusSv(String reportingWorkId,String username) {
			if (!reportingWorkId.isEmpty()) {
			reportingWorkMapper.updateQualityStatusMp(reportingWorkId,username);
			return true;
			} else {
			return false;
			}
			}

			public Map<String, Object> detailsQualitySv(String reportingWorkId,String processId,String thisProcess, ReportingWork reportingWork) {
			Map<String, Object> map = new HashMap<>();
			map.put("data", reportingWorkMapper.detailsQualityMp(reportingWorkId, reportingWork));
			map.put("basic",getReportingWorkBase(processId,thisProcess));
			System.out.println(map.get("basic"));
			return map;
			}
			}