disaster_sever/src/main/java/com/miniframe/bisiness/system/D00008Service.java

package com.miniframe.bisiness.system;

import com.github.dockerjava.api.async.ResultCallback;
import com.github.dockerjava.api.model.Frame;
import com.miniframe.constant.MFConstant;
import com.miniframe.core.ExecProcessFlow;
import com.miniframe.core.exception.BusinessException;
import com.miniframe.core.ext.UtilTools;
import com.miniframe.disaster.service.LogService;
import com.miniframe.generate.business.system.model.D00008BaseModel;
import com.miniframe.generate.comm.system.D_D10016_CHVALS_RECODE;
import com.miniframe.generate.comm.system.D_D10016_COCODES_RECODE;
import com.miniframe.model.system.*;
import com.miniframe.model.system.dao.*;
import com.miniframe.ptdj.PtDjCgq;
import com.miniframe.ptdj.PtDjResultData;
import com.miniframe.ptdj.PtdjServer;
import com.miniframe.service.impl.FileServiceImpl;
import com.miniframe.solverjob.DockerExe;
import com.miniframe.template.DEscapeVo;
import com.miniframe.template.TemplateGenerator;
import com.miniframe.template.TemplateGenerator2;
import com.miniframe.tools.XIDateTimeUtils;
import com.miniframe.tools.XIFileUtils;
import com.miniframe.tools.baidu.HttpUtil;
import com.miniframe.websocket.WebsocketEndPoint;
import lombok.SneakyThrows;
import tk.mybatis.mapper.util.StringUtil;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

/**
 * 基础系统,“灾情演练”逻辑处理（重新生成不覆盖）。
 */
public class D00008Service extends D00008BaseModel implements ExecProcessFlow {
	
	private static final long serialVersionUID = -7051358269847459502L;
		
	/**
	 * 基础系统,“灾情演练”业务核心处理
 	 */
	public void transExecute() throws Exception {
		Integer aid =this.getA_d00008().getAid();
		/**
		 * totaltime: 10800  - 模拟时长
		 * dt: 0.1   - 时间步长
		 * dx: 10.0 -空间步长
		 * report step: 60 -输出步长
		 * interactionstep : 1200 -交互步长
		 */
		String totaltime =this.getA_d00008().getTotaltime();
		String dt =this.getA_d00008().getDt();
		String dx =this.getA_d00008().getDx();
		String reportstep =this.getA_d00008().getReportstep();
		String interactionstep =this.getA_d00008().getInteractionstep();
		String acctime =this.getA_d00008().getAcctime();
		DAccidentMapper accidentDao  = UtilTools.getBean(DAccidentMapper.class);
		DAccident accident= accidentDao.selectByPrimaryKey(aid);
		DJobMapper dJobDao = UtilTools.getBean(DJobMapper.class);
		String coids=this.getA_d00008().getCoids();
		String cocodes=this.getA_d00008().getCocodes();



		DJob job = CreateJob(aid, totaltime, dt, dx,
				reportstep, interactionstep, acctime);
		if(accident.getStype().equals("Fire")||accident.getStype().equals("Gass")||accident.getStype().equals("Gass1")){
			if(StringUtil.isEmpty(coids)||StringUtil.isEmpty(cocodes)){
				throw new BusinessException("EB3100013");
			}
			job.setCoids(coids);
			job.setCocodes(cocodes);
		}else if(accident.getStype().equals("Water")){
			job.setCoids("-1");
			job.setCocodes("Height");
		}
		dJobDao.insertSelective(job);

		//获取最新JOB
		DJob newJob = getNewJob(aid, dJobDao);
		Integer jid =newJob.getId();
		//存储最新求解ID
		changeAccident(accidentDao, accident, jid);
		//创建日志
		LogService.createLog(accident);
		//获取传感器数据
		//TODO:  需要从第三方获取
		initDNodeVal(aid,jid);


		TemplateGenerator.createMonitor(aid,jid);//生成监测点文件
		TemplateGenerator2.createDevice(aid,jid);//创建设备文件
		LogService.addLog(accident,"device.ftl配置生成——————————————————成功");
		if(accident.getStype().equals("Fire")){
			TemplateGenerator2.createGeometry(aid,jid);
			TemplateGenerator2.createEscape(aid,jid);
			TemplateGenerator2.createFireControl(aid,jid,totaltime,dt,dx,reportstep,interactionstep,cocodes);
			LogService.addLog(accident,"fireControl.ftl配置生成——————————————————成功");
			TemplateGenerator2.createFireRunsh(aid,jid);
			LogService.addLog(accident,"runFile.sh配置生成——————————————————成功");
			TemplateGenerator2.createFireInit(aid,jid);
			LogService.addLog(accident,"Fire.init配置生成——————————————————成功");
			TemplateGenerator2.createFireEsccapeControl(aid,jid);
			LogService.addLog(accident,"FireEscape.control配置生成——————————————————成功");
			exeFire2(aid,jid);

		}
		if(accident.getStype().equals("Water")){
//			TemplateGenerator.createGeometry(aid,jid);//生成几何文件
			TemplateGenerator2.createGeometry(aid,jid);
			TemplateGenerator2.createEscape(aid,jid);
			TemplateGenerator2.createWaterControl(aid,jid,totaltime,dt,dx,reportstep,interactionstep);
			LogService.addLog(accident,"water.control配置生成——————————————————成功");
			TemplateGenerator2.createWaterRunsh(aid,jid);
			LogService.addLog(accident,"runWater.sh配置生成——————————————————成功");
			TemplateGenerator2.createWaterInit(aid,jid);
			LogService.addLog(accident,"water.init配置生成——————————————————成功");
			TemplateGenerator2.createWaterEsccapeControl(aid,jid);
			LogService.addLog(accident,"waterEscape.control配置生成——————————————————成功");
			exeWater2(aid,jid);
		}
		if(accident.getStype().equals("Gass1")) {//瓦斯爆炸一维
			TemplateGenerator2.createGeometry(aid,jid);
			TemplateGenerator2.createEscape(aid,jid);
			TemplateGenerator2.createGassEsccapeControl(aid,jid);

			DGasMapper gasMapper =UtilTools.getBean(DGasMapper.class);
			DGasSQLBuilder gasSb = new DGasSQLBuilder();
			DGasSQLBuilder.Criteria gasSc = gasSb.createCriteria();
			gasSc.andAidEqualTo(aid);
			List<DGas> gases =gasMapper.selectByExample(gasSb);
			if(gases.isEmpty()){
				throw  new BusinessException("EB3000004");
			}
			DGas gas =gases.get(0);

			/**
			 * 一维文件生成
			 */
			TemplateGenerator.createGas1Init(aid,jid,gas.getId());
			TemplateGenerator.createGass1Runsh(aid,jid);
			TemplateGenerator.createGas1Control(aid,jid,totaltime,dt,dx,reportstep,interactionstep,cocodes);


			//执行文件
			exeGass2(aid,jid);

		}
		if(accident.getStype().equals("Gass")){//瓦斯爆炸
			TemplateGenerator2.createGeometry(aid,jid);
			TemplateGenerator2.createEscape(aid,jid);
			DGasMapper gasMapper =UtilTools.getBean(DGasMapper.class);
			DGasSQLBuilder gasSb = new DGasSQLBuilder();
			DGasSQLBuilder.Criteria gasSc = gasSb.createCriteria();
			gasSc.andAidEqualTo(aid);
			List<DGas> gases =gasMapper.selectByExample(gasSb);
			if(gases.isEmpty()){
				throw  new BusinessException("EB3000004");
			}
			DGas gas =gases.get(0);
//			for (DGas gas: gases) {
				TemplateGenerator.createGasControl(aid,jid,totaltime,dt,dx,reportstep,interactionstep,cocodes);
				TemplateGenerator.createGasInit(aid,jid,gas.getId());
				TemplateGenerator.createGassRunsh(aid,jid);
				TemplateGenerator2.createGassEsccapeControl(aid,jid);
				//文件迁移
				//网格文件
				SysFileMapper sysFileMapper = UtilTools.getBean(SysFileMapper.class);
				SysFile gf = sysFileMapper.selectByPrimaryKey(gas.getGfid());
				if (gf == null) {
					throw new BusinessException("EB3100020");
				}
				cpFile(XIFileUtils.getRootPathStr() + MFConstant.separator + gf.getFilepath()
						,TemplateGenerator.BPATH + "/" + aid + "/" + jid + "/" + "/gas"+ "/"+gf.getFilename());
				//边界
				SysFile bf = sysFileMapper.selectByPrimaryKey(gas.getBfid());
				if (bf == null) {
					throw new BusinessException("EB3100021");
				}
				cpFile(XIFileUtils.getRootPathStr() + MFConstant.separator + bf.getFilepath()
						,TemplateGenerator.BPATH + "/" + aid + "/" + jid + "/" + "/gas"  + "/"+bf.getFilename());
				cpFile("/home/disaster/gas/bin/gas_mod.Lewis_2"
						,TemplateGenerator.BPATH + "/" + aid + "/" + jid + "/" + "/gas" + "/gas_mod.Lewis_2");
				cpFile("/home/disaster/gas/bin/reac_mod.fluent_CH4_Air_5x1"
						,TemplateGenerator.BPATH + "/" + aid + "/" + jid + "/" + "/gas" + "/reac_mod.fluent_CH4_Air_5x1");
				//执行文件
				exeGass2(aid,jid);
//			}

		}
	}

	private DJob CreateJob(Integer aid, String totaltime, String dt, String dx, String reportstep, String interactionstep, String acctime) {
		DJob job =new DJob();
		job.setAid(aid);
		job.setAcctime(acctime);
		job.setTotaltime(totaltime);
		job.setDt(dt);
		job.setDx(dx);
		job.setReportstep(reportstep);
		job.setInteractionstep(interactionstep);
		job.setStarttime(XIDateTimeUtils.getNowStr());
		job.setState("0");//未执行
		return job;
	}

	/**
	 * 任务成功
	 * @param jid
	 * @return
	 */
	private void JobSucces(Integer jid) {
		System.out.println("JobSucces--------start");
		DJobMapper dJobDao= UtilTools.getBean(DJobMapper.class);
		DJob job =dJobDao.selectByPrimaryKey(jid);
		job.setEndtime(XIDateTimeUtils.getNowStr());
		job.setState("1");//完成
		dJobDao.updateByPrimaryKey(job);
		System.out.println("JobSucces--------end");
	}
	/**
	 * 任务失败
	 * @param jid
	 * @return
	 */
	private void JobError(Integer jid) {
		DJobMapper dJobDao= UtilTools.getBean(DJobMapper.class);
		DJob job =dJobDao.selectByPrimaryKey(jid);
		job.setEndtime(XIDateTimeUtils.getNowStr());
		job.setState("-1");//任务失败
		dJobDao.updateByPrimaryKey(job);
	}

	private DJob getNewJob(Integer aid, DJobMapper dJobDao) {
		DJobSQLBuilder jsb = new DJobSQLBuilder();
		DJobSQLBuilder.Criteria jsc =jsb.createCriteria();
		jsc.andAidEqualTo(aid);
		jsb.setOrderByClause("starttime desc");
		DJob newJob= dJobDao.selectByExample(jsb).get(0);
		return newJob;
	}

	private void changeAccident(DAccidentMapper accidentDao, DAccident accident, Integer jid) {
		accident.setJid(jid);
		accidentDao.updateByPrimaryKey(accident);
	}

	private void initDNodeVal(Integer aid,Integer jid) {
		//TODO
		try {
			PtDjCgq cgq= PtdjServer.getCgq();
			List<PtDjResultData>  data= cgq.getResult().getData();
			DSensorValMapper svDao =UtilTools.getBean(DSensorValMapper.class);
			if(data!=null && !data.isEmpty()){
				data.forEach(r->{
					DSensorVal val =new DSensorVal();
					val.setCreateTime(r.getCreate_time());
					val.setDataTime(r.getData_time());
					val.setMineCode(r.getMine_code());
					val.setAid(aid);
					val.setJid(jid);
					val.setPipes(r.getPipes());
					val.setPointCode(r.getPoint_code());
					val.setPointLocation(r.getPoint_location());
					val.setPointStatus(r.getPoint_status());
					val.setPointValue(r.getPoint_value());
					val.setSensorType(r.getSensor_type());
					val.setSensorTypeName(r.getSensor_type_name());
					val.setSite(r.getSite());
					val.setValueUnit(r.getValue_unit());
					val.setxCoordinate(r.getX_coordinate());
					val.setyCoordinate(r.getY_coordinate());
					val.setzCoordinate(r.getZ_coordinate());
					svDao.insertSelective(val);
				});
			}

		}catch (Exception e){
			e.printStackTrace();
		}

	}

	public void cpFile(String file1Path,String file2Path) throws IOException {
		Runtime runtime = Runtime.getRuntime();
		Process p =null;
		String shell ="cp -f "+file1Path+"  "+ file2Path;
		System.out.println(shell);
		runtime.exec(shell);
	}

	public void saveMonitorValue(Integer aid,Integer jid) throws FileNotFoundException, BusinessException {
		DJobMapper dJobDao= UtilTools.getBean(DJobMapper.class);
		DJob job =dJobDao.selectByPrimaryKey(jid);
		Double stepDNum = Double.valueOf(job.getTotaltime())/Double.valueOf(job.getReportstep());

		Integer stepNum =stepDNum.intValue();
		DAccidentMapper accidentDao  = UtilTools.getBean(DAccidentMapper.class);
		DAccident accident= accidentDao.selectByPrimaryKey(aid);

		List<DChecknodeVal> nVals =new ArrayList<>();
		List<DChecknodeValcode> nValCodes =new ArrayList<>();
		for (int step = 1; step <=stepNum ; step++) {
			String outPath="";
			String fileName ="";
			if(accident.getStype().endsWith("Fire")){
				outPath= TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/fire/out/monitor/";
				fileName ="monitorValue"+step;
			}
			if(accident.getStype().endsWith("Water")){
				outPath=TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/water/out/monitor/";
				fileName ="monitorValue"+step;
			}
			if(accident.getStype().endsWith("Gass")){
				outPath=TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/gas/out/monitor/";
				fileName ="monitorValue"+step;
			}
			if(accident.getStype().endsWith("Gass1")){
				outPath=TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/gas/out/monitor/";
				fileName ="monitorValue"+step;
			}
			try{
				FileReader fileReader = new FileReader(outPath+"/"+fileName);
				BufferedReader reader = new BufferedReader(fileReader);
				String line;
				int linNum =1;
				while ((line = reader.readLine()) != null) {
					String[] t = line.trim().split(",");
					if(linNum==1){
						if(nValCodes.isEmpty()){
							DChecknodeValcode nValCode =  new DChecknodeValcode();
							nValCode.setJid(jid);
							nValCode.setAid(aid);
							nValCode.setValCode1(t.length>1?t[1]:null);
							nValCode.setValCode2(t.length>2?t[2]:null);
							nValCode.setValCode3(t.length>3?t[3]:null);
							nValCode.setValCode4(t.length>4?t[4]:null);
							nValCode.setValCode5(t.length>5?t[5]:null);
							nValCode.setValCode6(t.length>6?t[6]:null);
							nValCodes.add(nValCode);
						}
					}else {
						DChecknodeVal chval=new DChecknodeVal();
						chval.setJid(jid);
						chval.setAid(aid);
						chval.setStep(step);
						chval.setChcode(t.length>0?t[0]:"");
						chval.setChname(getChnameByChcode(chval.getChcode()));
						chval.setV1(t.length>1?t[1]:"0");
						chval.setV2(t.length>2?t[2]:"0");
						chval.setV3(t.length>3?t[3]:"0");
						chval.setV4(t.length>4?t[4]:"0");
						chval.setV5(t.length>5?t[5]:"0");
						chval.setV6(t.length>6?t[6]:"0");
						nVals.add(chval);
					}
					linNum++;
				}
				fileReader.close();
				reader.close();

			}catch (Exception e){
				System.out.println(e);
				throw  new BusinessException("EB3100014");
			}
		}
		DChecknodeValMapper valMapper =UtilTools.getBean(DChecknodeValMapper.class);
		DChecknodeValcodeMapper valcodeMapper =UtilTools.getBean(DChecknodeValcodeMapper.class);
		for (DChecknodeVal nVal:nVals) {
			valMapper.insertSelective(nVal);
		}
		for (DChecknodeValcode nValCode:nValCodes) {
			valcodeMapper.insertSelective(nValCode);
		}
	}

	public static  String getChnameByChcode(String chcode) throws BusinessException {
		DChecknodeMapper chMapper = UtilTools.getBean(DChecknodeMapper.class);
		DChecknodeSQLBuilder sb = new DChecknodeSQLBuilder();
		DChecknodeSQLBuilder.Criteria sc =sb.createCriteria();
		sc.andChcodeEqualTo(chcode);
		List<DChecknode> clist = chMapper.selectByExample(sb);
		if(clist.isEmpty()){
			return "";
		}else{
			DChecknode dc =clist.get(0);
			return dc.getChname();
		}
	}
	//异步执行
	@SneakyThrows
	public void exeWater2(Integer aid,Integer jid){
		try {
			LogService.addLog(aid,jid,"Water","求解——————————————————开始");
			DockerExe.stopDocker(aid,"Water");
			DockerExe.waterExec(aid, jid, "Water");
		}catch (Exception e) {
			LogService.addLog(aid,jid,"Water","求解——————————————————失败");
			JobError(jid);
			e.printStackTrace();
		}
		CompletableFuture<Void> cf = CompletableFuture.supplyAsync(()-> {
			try {
				DockerExe.getDockerLogs(aid,"Water",new ResultCallback.Adapter<Frame>() {
					@Override
					public void onNext(Frame frame) {
						LogService.addLog(aid,jid,"Water",new String(frame.getPayload()));
						System.out.print(new String(frame.getPayload()));
						super.onNext(frame);
					}
					@Override
					public void onError(Throwable throwable) {
						System.err.println("日志获取失败");
						throwable.printStackTrace();
						super.onError(throwable);
					}
					@Override
					public void onComplete() {
//						LogService.addLog(aid,jid,"Water","求解——————————————————成功");
						System.out.println("日志获取完成");
						super.onComplete();
					}
				});

				saveMonitorValue(aid,jid);
				//路径保存
				saveWayValue(aid,jid);
				JobSucces(jid);
				LogService.addLog(aid,jid,"Water","求解——————————————————成功");
			} catch (Exception e) {
				LogService.addLog(aid,jid,"Water","求解——————————————————失败");
				JobError(jid);
				e.printStackTrace();
			}
			return null;
		});

	}
	//异步执行
	@SneakyThrows
	public void exeWater(Integer aid,Integer jid) throws Exception{
		CompletableFuture<Void> cf = CompletableFuture.supplyAsync(()->{
			try {
				LogService.addLog(aid,jid,"Water","求解——————————————————开始");
//				Runtime runtime = Runtime.getRuntime();
//				Process p =null;
//				p= runtime.exec("sh "+TemplateGenerator.BPATH+"/"+aid+"/"+jid+"/water"+"/"+"runWater.sh");
//				InputStream fis = p.getInputStream();
//				InputStreamReader isr = new InputStreamReader(fis);
//				BufferedReader br = new BufferedReader(isr);
//				String line = null;
//				while ((line = br.readLine()) != null) {
//					LogService.addLog(aid,jid,"Water",line);
//					System.out.println(line);
//				}

				ProcessBuilder processBuilder = new ProcessBuilder("sh",TemplateGenerator.BPATH+"/"+aid+"/"+jid+"/water"+"/"+"runWater.sh");

				Process process = processBuilder.start();
				processBuilder.redirectErrorStream(true); // 将错误流合并到标准输出流
				// 读取命令的输出
				BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
				String line = null;
				while ((line = reader.readLine()) != null) {
					LogService.addLog(aid,jid,"Water",line);
					System.out.println(line);
				}
				// 等待命令执行完成
				int exitCode = process.waitFor();
				System.out.println("\nExited with code: " + exitCode);
				saveMonitorValue(aid,jid);
				//路径保存
				saveWayValue(aid,jid);
				JobSucces(jid);
				LogService.addLog(aid,jid,"Water","求解——————————————————成功");
			} catch (IOException | BusinessException | InterruptedException e) {
				LogService.addLog(aid,jid,"Water","求解——————————————————失败");
				JobError(jid);
				e.printStackTrace();
			}
			return null;
		});

	}
	//异步执行
	@SneakyThrows
	public void exeFire2(Integer aid,Integer jid) throws Exception {
		try {
			LogService.addLog(aid,jid,"Fire","求解——————————————————开始");
			DockerExe.stopDocker(aid,"Fire");
			DockerExe.fireExec(aid, jid, "Fire");
		}catch (Exception e) {
			LogService.addLog(aid,jid,"Fire","求解——————————————————失败");
			JobError(jid);
			e.printStackTrace();
		}
		CompletableFuture<Void> cf = CompletableFuture.supplyAsync(()-> {
			try {
				DockerExe.getDockerLogs(aid,"Fire",new ResultCallback.Adapter<Frame>() {
					@Override
					public void onNext(Frame frame) {
						LogService.addLog(aid,jid,"Fire",new String(frame.getPayload()));
						System.out.print(new String(frame.getPayload()));
						super.onNext(frame);
					}
					@Override
					public void onError(Throwable throwable) {
						System.err.println("日志获取失败");
						throwable.printStackTrace();
						super.onError(throwable);
					}
					@Override
					public void onComplete() {
						System.out.println("日志获取完成");
						super.onComplete();
					}
				});

				//监测点数据保存
				saveMonitorValue(aid,jid);
				//路径保存
				saveWayValue(aid,jid);
				LogService.addLog(aid,jid,"Fire","求解——————————————————成功");
				JobSucces(jid);
			} catch (Exception e) {
				LogService.addLog(aid,jid,"Fire","求解——————————————————失败");
				JobError(jid);
				e.printStackTrace();
			}
			return null;
		});
	}
	//异步执行
	@SneakyThrows
	public void exeFire(Integer aid,Integer jid) throws Exception{

		CompletableFuture<Void> cf = CompletableFuture.supplyAsync(()->{
			try {
			Runtime runtime = Runtime.getRuntime();
			Process p =null;
			LogService.addLog(aid,jid,"Fire","求解——————————————————开始");
			p= runtime.exec("sh "+TemplateGenerator.BPATH+"/"+
					aid+"/"+jid+"/fire"+"/"+"runFile.sh");
			InputStream fis = p.getInputStream();
			InputStreamReader isr = new InputStreamReader(fis);
			BufferedReader br = new BufferedReader(isr);
			String line = null;
			while ((line = br.readLine()) != null) {
				LogService.addLog(aid,jid,"Fire",line);
				System.out.println(line);
			}


				//监测点数据保存
				saveMonitorValue(aid,jid);
				//路径保存
				saveWayValue(aid,jid);
				LogService.addLog(aid,jid,"Fire","求解——————————————————成功");
				JobSucces(jid);
			} catch (IOException | BusinessException e) {
				LogService.addLog(aid,jid,"Fire","求解——————————————————失败");
				e.printStackTrace();
				JobError(jid);
			}
			return null;
		});

	}
	//异步执行
	@SneakyThrows
	public void exeGass2(Integer aid, Integer jid) throws Exception{

		try {
			LogService.addLog(aid,jid,"gass","求解——————————————————开始");
			DockerExe.stopDocker(aid,"gass");
			DockerExe.fireGass(aid, jid, "gass");
		}catch (Exception e) {
			LogService.addLog(aid,jid,"gass","求解——————————————————失败");
			JobError(jid);
			e.printStackTrace();
		}
		CompletableFuture<Void> cf = CompletableFuture.supplyAsync(()-> {
			try {
				DockerExe.getDockerLogs(aid,"gass",new ResultCallback.Adapter<Frame>() {
					@Override
					public void onNext(Frame frame) {
						LogService.addLog(aid,jid,"gass",new String(frame.getPayload()));
						System.out.print(new String(frame.getPayload()));
						super.onNext(frame);
					}
					@Override
					public void onError(Throwable throwable) {
						System.err.println("日志获取失败");
						throwable.printStackTrace();
						super.onError(throwable);
					}
					@Override
					public void onComplete() {
						System.out.println("日志获取完成");
						super.onComplete();
					}
				});

				//监测点数据保存
				saveMonitorValue(aid,jid);
				//路径保存
				saveWayValue(aid,jid);
				LogService.addLog(aid,jid,"gass","求解——————————————————成功");
				JobSucces(jid);
			} catch (Exception e) {
				LogService.addLog(aid,jid,"gass","求解——————————————————失败");
				JobError(jid);
				e.printStackTrace();
			}
			return null;
		});

	}
	//异步执行
	@SneakyThrows
	public void exeGass(Integer aid, Integer jid) throws Exception{

		CompletableFuture<Void> cf = CompletableFuture.supplyAsync(()->{
			try {
				Runtime runtime = Runtime.getRuntime();
				Process p =null;
				LogService.addLog(aid,jid,"gass","求解——————————————————开始");
				p= runtime.exec("sh "+TemplateGenerator.BPATH + "/" + aid + "/" + jid + "/" + "/gas" + "/run.sh");
				InputStream fis = p.getInputStream();
				InputStreamReader isr = new InputStreamReader(fis);
				BufferedReader br = new BufferedReader(isr);
				String line = null;
				while ((line = br.readLine()) != null) {
					LogService.addLog(aid,jid,"gass",line);
					System.out.println(line);
				}
				//监测点数据保存
				saveMonitorValue(aid,jid);
				//路径保存
				saveWayValue(aid,jid);
				LogService.addLog(aid,jid,"gass","求解——————————————————成功");
				JobSucces(jid);
			} catch (IOException | BusinessException e) {
				LogService.addLog(aid,jid,"gass","求解——————————————————失败");
				e.printStackTrace();
				JobError(jid);
			}
			return null;
		});

	}


	public void saveWayValue(Integer aid,Integer jid) throws FileNotFoundException, BusinessException {
		DAccidentMapper accidentDao  = UtilTools.getBean(DAccidentMapper.class);
		DAccident accident= accidentDao.selectByPrimaryKey(aid);
		String SafetyFile="";
		if(accident.getStype().endsWith("Fire")){
			SafetyFile= TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/fire/out/Safety";
		}
		if(accident.getStype().endsWith("Water")){
			SafetyFile=TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/water/out/Safety";
		}
		if(accident.getStype().endsWith("Gass")){
			SafetyFile=TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/gas/out/Safety";
		}
		if(accident.getStype().endsWith("Gass1")){
			SafetyFile=TemplateGenerator.BPATH+"/"+aid+"/"+accident.getJid()+"/gas/out/Safety";
		}
		List<DWayResult> wayResults =new ArrayList<>();
		List<DWaynodeResult> wayNodeResults =new ArrayList<>();
		FileReader fileReader = new FileReader(SafetyFile);
		BufferedReader reader = new BufferedReader(fileReader);
		/**
		 * person1,line1,danger,1
		 * nodes29,987.7211,10.0000,1800.0000
		 * person1,line2,safety,0
		 */
		String line;
		try{
			while ((line = reader.readLine()) != null) {
				String[] t = line.trim().split(",");
				DWayResult result = new DWayResult();
				result.setAid(aid);
				result.setJid(jid);
				result.setPerson(t.length>0?t[0]:"0");
				result.setWcode(t.length>1?t[1]:"0");
				result.setSafety(t.length>2?t[2]:"0");
				result.setFlag(t.length>3?t[3]:"0");

				if("平台".equals(accident.getSource())){
					DMwayMapper mwDao = UtilTools.getBean(DMwayMapper.class);
					Integer mwid = Integer.valueOf(result.getWcode().replace("s",""));
					DMway mw = mwDao.selectByPrimaryKey(mwid);
					mw.setLevel(result.getFlag());
					mwDao.updateByPrimaryKey(mw);
				}

				int i =0;
				if(result.getSafety().equals("danger")||Integer.valueOf(result.getFlag())>0){
					while ((line = reader.readLine()) != null) {
						i++;
						String[] t1 = line.trim().split(",");
						DWaynodeResult wnr =new DWaynodeResult();
						wnr.setAid(aid);
						wnr.setJid(jid);
						wnr.setWcode(result.getWcode());
						wnr.setNcode(t1.length>0?t1[0]:"0");
						wnr.setV1(t1.length>0?t1[1]:"0");
						wnr.setV2(t1.length>0?t1[2]:"0");
						wnr.setV3(t1.length>0?t1[3]:"0");
						wayNodeResults.add(wnr);
						if(i==Integer.valueOf(result.getFlag())){
							break;
						}
					}
				}
				wayResults.add(result);
				}
			fileReader.close();
			reader.close();

		}catch (Exception e){
			System.out.println(e);
			throw  new BusinessException("EB3100014");
		}

		DWayResultMapper rMapper =UtilTools.getBean(DWayResultMapper.class);
		for (DWayResult r:wayResults) {
			rMapper.insertSelective(r);
		}
		DWaynodeResultMapper wnrMapper = UtilTools.getBean(DWaynodeResultMapper.class);
		for (DWaynodeResult r:wayNodeResults) {
			wnrMapper.insertSelective(r);
		}
	}

	
	/**
	 *
	 *
	 *
	 *
	 * 基础系统,“灾情演练”业务前处理
 	 */
	public void preTransFlow() throws Exception {

		this.validater();
	}
	
	/**
	 * 基础系统,“灾情演练”业务后处理
 	 */
	public void afterTransFlow() throws Exception {
	
	}
	
	/**
	 * 基础系统,“灾情演练”逻辑入口处理方法
 	 */
 	@SuppressWarnings("rawtypes")
	@Override
	public Map execute(Map vars) throws Exception {
		this.setTransMap(vars);
		preTransFlow();// 执行业务开始的规则检查和校验
		transExecute();// 执行核心业务段
		afterTransFlow();// 执行核心逻辑完成后的收尾逻辑
		return this.getTransMap();
	}


	public static void main(String[] args) throws FileNotFoundException, BusinessException {
 		String  SafetyFile ="D://Safety";
 		Integer aid=1;
 		Integer jid =2;
		List<DWayResult> wayResults =new ArrayList<>();
		List<DWaynodeResult> wayNodeResults =new ArrayList<>();
		FileReader fileReader = new FileReader(SafetyFile);
		BufferedReader reader = new BufferedReader(fileReader);
		/**
		 * person1,line1,danger,1
		 * nodes29,987.7211,10.0000,1800.0000
		 * person1,line2,safety,0
		 */
		String line;
		try{
			while ((line = reader.readLine()) != null) {
				String[] t = line.trim().split(",");
				DWayResult result = new DWayResult();
				result.setAid(aid);
				result.setJid(jid);
				result.setPerson(t.length>0?t[0]:"0");
				result.setWcode(t.length>1?t[1]:"0");
				result.setSafety(t.length>2?t[2]:"0");
				result.setFlag(t.length>3?t[3]:"0");
				int i =0;
				if(result.getSafety().equals("danger")||Integer.valueOf(result.getFlag())>0){
					while ((line = reader.readLine()) != null) {
						i++;
						String[] t1 = line.trim().split(",");
						DWaynodeResult wnr =new DWaynodeResult();
						wnr.setAid(aid);
						wnr.setJid(jid);
						wnr.setWcode(result.getWcode());
						wnr.setNcode(t1.length>0?t1[0]:"0");
						wnr.setV1(t1.length>0?t1[1]:"0");
						wnr.setV2(t1.length>0?t1[2]:"0");
						wnr.setV3(t1.length>0?t1[3]:"0");
						wayNodeResults.add(wnr);
						if(i==Integer.valueOf(result.getFlag())){
							break;
						}
					}
				}
				wayResults.add(result);
			}
			fileReader.close();
			reader.close();

		}catch (Exception e){
			System.out.println(e);
			throw  new BusinessException("EB3100014");
		}

		System.out.println(wayResults);
		System.out.println(wayNodeResults);

	}
}