kangwei: 风险点---移动端---风险点巡检--开始巡检

@@ -76,7 +76,7 @@ public class DangerInspectInfoController {
 		Result<IPage<DangerInspectInfo>> result = new Result<IPage<DangerInspectInfo>>();
 		Result<IPage<DangerInspectInfo>> result = new Result<IPage<DangerInspectInfo>>();
 		QueryWrapper<DangerInspectInfo> queryWrapper = QueryGenerator.initQueryWrapper(dangerInspectInfo, req.getParameterMap());
 		QueryWrapper<DangerInspectInfo> queryWrapper = QueryGenerator.initQueryWrapper(dangerInspectInfo, req.getParameterMap());
 		Page<DangerInspectInfo> page = new Page<DangerInspectInfo>(pageNo, pageSize);
 		Page<DangerInspectInfo> page = new Page<DangerInspectInfo>(pageNo, pageSize);
-		queryWrapper.eq("danger_level_id",dangerInspectInfo.getDangerLevelId());
+		queryWrapper.eq("danger_id",dangerInspectInfo.getDangerId());
 		queryWrapper.orderByDesc("create_time");
 		queryWrapper.orderByDesc("create_time");
 
 
 		IPage<DangerInspectInfo> pageList = dangerInspectInfoService.page(page, queryWrapper);
 		IPage<DangerInspectInfo> pageList = dangerInspectInfoService.page(page, queryWrapper);

+package com.skua.modules.safe.controller;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import com.skua.core.api.vo.Result;
+import com.skua.core.aspect.annotation.AutoLog;
+import com.skua.core.context.BaseContextHandler;
+import com.skua.core.query.QueryGenerator;
+import com.skua.core.service.ISequenceService;
+import com.skua.core.util.ConvertUtils;
+import com.skua.modules.safe.entity.DangerInspectionInfo;
+import com.skua.modules.safe.service.IDangerInspectionInfoService;
+import java.util.Date;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.extern.slf4j.Slf4j;
+
+import org.jeecgframework.poi.excel.ExcelImportUtil;
+import org.jeecgframework.poi.excel.def.NormalExcelConstants;
+import org.jeecgframework.poi.excel.entity.ExportParams;
+import org.jeecgframework.poi.excel.entity.ImportParams;
+import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartHttpServletRequest;
+import org.springframework.web.servlet.ModelAndView;
+import com.alibaba.fastjson.JSON;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+/**
+ * <pre>
+ * 巡检对象
+ * </pre>
+ * @author 开发者姓名
+ * @version V0.1, 开发时间
+ */
+@Slf4j
+@Api(tags="巡检对象")
+@RestController("webDangerInspectionInfoController")
+@RequestMapping("/web/safe/dangerInspectionInfo")
+public class DangerInspectionInfoController {
+	@Autowired
+	private IDangerInspectionInfoService dangerInspectionInfoService;
+
+	/**
+	 * <pre>
+	 * 	分页列表查询
+	 * </pre>
+	 * @param dangerInspectionInfo
+	 * @param pageNo
+	 * @param pageSize
+	 * @param req
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+
+	@AutoLog(value = "巡检对象-分页列表查询")
+	@ApiOperation(value="巡检对象-分页列表查询", notes="巡检对象-分页列表查询")
+	@GetMapping(value = "/list")
+	public Result<IPage<DangerInspectionInfo>> queryPageList(DangerInspectionInfo dangerInspectionInfo,
+									  @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
+									  @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
+									  HttpServletRequest req) {
+		Result<IPage<DangerInspectionInfo>> result = new Result<IPage<DangerInspectionInfo>>();
+		QueryWrapper<DangerInspectionInfo> queryWrapper = QueryGenerator.initQueryWrapper(dangerInspectionInfo, req.getParameterMap());
+		Page<DangerInspectionInfo> page = new Page<DangerInspectionInfo>(pageNo, pageSize);
+		IPage<DangerInspectionInfo> pageList = dangerInspectionInfoService.page(page, queryWrapper);
+		result.setSuccess(true);
+		result.setResult(pageList);
+		return result;
+	}
+
+	/**
+	 * <pre>
+	 * 	添加
+	 * </pre>
+	 * @param dangerInspectionInfo
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检对象-添加")
+	@ApiOperation(value="巡检对象-添加", notes="巡检对象-添加")
+	@PostMapping(value = "/add")
+	public Result<DangerInspectionInfo> add(@RequestBody DangerInspectionInfo dangerInspectionInfo) {
+		Result<DangerInspectionInfo> result = new Result<DangerInspectionInfo>();
+		try {
+			dangerInspectionInfoService.save(dangerInspectionInfo);
+			result.success("添加成功！");
+		} catch (Exception e) {
+			log.error(e.getMessage(),e);
+			result.error500("操作失败");
+		}
+		return result;
+	}
+	/**
+	 * <pre>
+	 * 	 编辑
+	 * </pre>
+	 * @param dangerInspectionInfo
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检对象-编辑")
+	@ApiOperation(value="巡检对象-编辑", notes="巡检对象-编辑")
+	@PutMapping(value = "/edit")
+	public Result<DangerInspectionInfo> edit(@RequestBody DangerInspectionInfo dangerInspectionInfo) {
+		Result<DangerInspectionInfo> result = new Result<DangerInspectionInfo>();
+		DangerInspectionInfo dangerInspectionInfoEntity = dangerInspectionInfoService.getById(dangerInspectionInfo.getId());
+		if(dangerInspectionInfoEntity==null) {
+			result.error500("未找到对应实体");
+		}else {
+			boolean ok = dangerInspectionInfoService.updateById(dangerInspectionInfo);
+			//TODO 返回false说明什么？
+			if(ok) {
+				result.success("修改成功!");
+			}
+		}
+
+		return result;
+	}
+	/**
+	 * <pre>
+	 * 	 通过id删除
+	 * </pre>
+	 * @param id
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检对象-通过id删除")
+	@ApiOperation(value="巡检对象-通过id删除", notes="巡检对象-通过id删除")
+	@DeleteMapping(value = "/delete")
+	public Result<?> delete(@RequestParam(name="id",required=true) String id) {
+		try {
+			dangerInspectionInfoService.removeById(id);
+		} catch (Exception e) {
+			log.error("删除失败",e.getMessage());
+			return Result.error("删除失败!");
+		}
+		return Result.ok("删除成功!");
+	}
+
+	/**
+	 * <pre>
+	 * 	  批量删除
+	 * </pre>
+	 * @param ids
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检对象-批量删除")
+	@ApiOperation(value="巡检对象-批量删除", notes="巡检对象-批量删除")
+	@DeleteMapping(value = "/deleteBatch")
+	public Result<DangerInspectionInfo> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
+		Result<DangerInspectionInfo> result = new Result<DangerInspectionInfo>();
+		if(ids==null || "".equals(ids.trim())) {
+			result.error500("参数不识别！");
+		}else {
+			this.dangerInspectionInfoService.removeByIds(Arrays.asList(ids.split(",")));
+			result.success("删除成功!");
+		}
+		return result;
+	}
+	/**
+	 * <pre>
+	 * 	 通过id查询
+	 * </pre>
+	 * @param id
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检对象-通过id查询")
+	@ApiOperation(value="巡检对象-通过id查询", notes="巡检对象-通过id查询")
+	@GetMapping(value = "/queryById")
+	public Result<DangerInspectionInfo> queryById(@RequestParam(name="id",required=true) String id) {
+		Result<DangerInspectionInfo> result = new Result<DangerInspectionInfo>();
+		DangerInspectionInfo dangerInspectionInfo = dangerInspectionInfoService.getById(id);
+		if(dangerInspectionInfo==null) {
+			result.error500("未找到对应实体");
+		}else {
+			result.setResult(dangerInspectionInfo);
+			result.setSuccess(true);
+		}
+		return result;
+	}
+
+   /**
+	 * <pre>
+	 * 	 导出excel
+	 * </pre>
+	 * @param request
+	 * @param response
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+
+  @RequestMapping(value = "/exportXls")
+  public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
+      // Step.1 组装查询条件
+      QueryWrapper<DangerInspectionInfo> queryWrapper = null;
+      try {
+          String paramsStr = request.getParameter("paramsStr");
+          if (ConvertUtils.isNotEmpty(paramsStr)) {
+              String deString = URLDecoder.decode(paramsStr, "UTF-8");
+              DangerInspectionInfo dangerInspectionInfo = JSON.parseObject(deString, DangerInspectionInfo.class);
+              queryWrapper = QueryGenerator.initQueryWrapper(dangerInspectionInfo, request.getParameterMap());
+          }
+      } catch (UnsupportedEncodingException e) {
+          e.printStackTrace();
+      }
+
+      //Step.2 AutoPoi 导出Excel
+      ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
+      List<DangerInspectionInfo> pageList = dangerInspectionInfoService.list(queryWrapper);
+      //导出文件名称
+      mv.addObject(NormalExcelConstants.FILE_NAME, "巡检对象列表");
+      mv.addObject(NormalExcelConstants.CLASS, DangerInspectionInfo.class);
+      mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("巡检对象列表数据", "导出人:Jeecg", "导出信息"));
+      mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
+      return mv;
+  }
+
+   /**
+	 * <pre>
+	 * 	 通过excel导入数据
+	 * </pre>
+	 * @param request
+	 * @param response
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+  @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
+  public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
+      MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
+      Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
+      for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
+          MultipartFile file = entity.getValue();// 获取上传文件对象
+          ImportParams params = new ImportParams();
+          params.setTitleRows(2);
+          params.setHeadRows(1);
+          params.setNeedSave(true);
+          try {
+              List<DangerInspectionInfo> listDangerInspectionInfos = ExcelImportUtil.importExcel(file.getInputStream(), DangerInspectionInfo.class, params);
+              dangerInspectionInfoService.saveBatch(listDangerInspectionInfos);
+              return Result.ok("文件导入成功！数据行数:" + listDangerInspectionInfos.size());
+          } catch (Exception e) {
+              log.error(e.getMessage(),e);
+              return Result.error("文件导入失败:"+e.getMessage());
+          } finally {
+              try {
+                  file.getInputStream().close();
+              } catch (IOException e) {
+                  e.printStackTrace();
+              }
+          }
+      }
+      return Result.ok("文件导入失败！");
+  }
+
+}

+package com.skua.modules.safe.controller;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import com.skua.core.api.vo.Result;
+import com.skua.core.aspect.annotation.AutoLog;
+import com.skua.core.context.BaseContextHandler;
+import com.skua.core.query.QueryGenerator;
+import com.skua.core.service.ISequenceService;
+import com.skua.core.util.ConvertUtils;
+import com.skua.modules.safe.entity.DangerInspectionRecord;
+import com.skua.modules.safe.service.IDangerInspectionRecordService;
+import java.util.Date;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.extern.slf4j.Slf4j;
+
+import org.jeecgframework.poi.excel.ExcelImportUtil;
+import org.jeecgframework.poi.excel.def.NormalExcelConstants;
+import org.jeecgframework.poi.excel.entity.ExportParams;
+import org.jeecgframework.poi.excel.entity.ImportParams;
+import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartHttpServletRequest;
+import org.springframework.web.servlet.ModelAndView;
+import com.alibaba.fastjson.JSON;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+/**
+ * <pre>
+ * 巡检记录
+ * </pre>
+ * @author 开发者姓名
+ * @version V0.1, 开发时间
+ */
+@Slf4j
+@Api(tags="巡检记录")
+@RestController("webDangerInspectionRecordController")
+@RequestMapping("/web/safe/dangerInspectionRecord")
+public class DangerInspectionRecordController {
+	@Autowired
+	private IDangerInspectionRecordService dangerInspectionRecordService;
+
+	/**
+	 * <pre>
+	 * 	分页列表查询
+	 * </pre>
+	 * @param dangerInspectionRecord
+	 * @param pageNo
+	 * @param pageSize
+	 * @param req
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+
+	@AutoLog(value = "巡检记录-分页列表查询")
+	@ApiOperation(value="巡检记录-分页列表查询", notes="巡检记录-分页列表查询")
+	@GetMapping(value = "/list")
+	public Result<IPage<DangerInspectionRecord>> queryPageList(DangerInspectionRecord dangerInspectionRecord,
+									  @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
+									  @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
+									  HttpServletRequest req) {
+		Result<IPage<DangerInspectionRecord>> result = new Result<IPage<DangerInspectionRecord>>();
+		QueryWrapper<DangerInspectionRecord> queryWrapper = QueryGenerator.initQueryWrapper(dangerInspectionRecord, req.getParameterMap());
+		Page<DangerInspectionRecord> page = new Page<DangerInspectionRecord>(pageNo, pageSize);
+		IPage<DangerInspectionRecord> pageList = dangerInspectionRecordService.page(page, queryWrapper);
+		result.setSuccess(true);
+		result.setResult(pageList);
+		return result;
+	}
+
+	/**
+	 * <pre>
+	 * 	添加
+	 * </pre>
+	 * @param dangerInspectionRecord
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检记录-添加")
+	@ApiOperation(value="巡检记录-添加", notes="巡检记录-添加")
+	@PostMapping(value = "/add")
+	public Result<DangerInspectionRecord> add(@RequestBody DangerInspectionRecord dangerInspectionRecord) {
+		Result<DangerInspectionRecord> result = new Result<DangerInspectionRecord>();
+		try {
+			dangerInspectionRecordService.save(dangerInspectionRecord);
+			result.success("添加成功！");
+		} catch (Exception e) {
+			log.error(e.getMessage(),e);
+			result.error500("操作失败");
+		}
+		return result;
+	}
+	/**
+	 * <pre>
+	 * 	 编辑
+	 * </pre>
+	 * @param dangerInspectionRecord
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检记录-编辑")
+	@ApiOperation(value="巡检记录-编辑", notes="巡检记录-编辑")
+	@PutMapping(value = "/edit")
+	public Result<DangerInspectionRecord> edit(@RequestBody DangerInspectionRecord dangerInspectionRecord) {
+		Result<DangerInspectionRecord> result = new Result<DangerInspectionRecord>();
+		DangerInspectionRecord dangerInspectionRecordEntity = dangerInspectionRecordService.getById(dangerInspectionRecord.getId());
+		if(dangerInspectionRecordEntity==null) {
+			result.error500("未找到对应实体");
+		}else {
+			boolean ok = dangerInspectionRecordService.updateById(dangerInspectionRecord);
+			//TODO 返回false说明什么？
+			if(ok) {
+				result.success("修改成功!");
+			}
+		}
+
+		return result;
+	}
+	/**
+	 * <pre>
+	 * 	 通过id删除
+	 * </pre>
+	 * @param id
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检记录-通过id删除")
+	@ApiOperation(value="巡检记录-通过id删除", notes="巡检记录-通过id删除")
+	@DeleteMapping(value = "/delete")
+	public Result<?> delete(@RequestParam(name="id",required=true) String id) {
+		try {
+			dangerInspectionRecordService.removeById(id);
+		} catch (Exception e) {
+			log.error("删除失败",e.getMessage());
+			return Result.error("删除失败!");
+		}
+		return Result.ok("删除成功!");
+	}
+
+	/**
+	 * <pre>
+	 * 	  批量删除
+	 * </pre>
+	 * @param ids
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检记录-批量删除")
+	@ApiOperation(value="巡检记录-批量删除", notes="巡检记录-批量删除")
+	@DeleteMapping(value = "/deleteBatch")
+	public Result<DangerInspectionRecord> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
+		Result<DangerInspectionRecord> result = new Result<DangerInspectionRecord>();
+		if(ids==null || "".equals(ids.trim())) {
+			result.error500("参数不识别！");
+		}else {
+			this.dangerInspectionRecordService.removeByIds(Arrays.asList(ids.split(",")));
+			result.success("删除成功!");
+		}
+		return result;
+	}
+	/**
+	 * <pre>
+	 * 	 通过id查询
+	 * </pre>
+	 * @param id
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+	@AutoLog(value = "巡检记录-通过id查询")
+	@ApiOperation(value="巡检记录-通过id查询", notes="巡检记录-通过id查询")
+	@GetMapping(value = "/queryById")
+	public Result<DangerInspectionRecord> queryById(@RequestParam(name="id",required=true) String id) {
+		Result<DangerInspectionRecord> result = new Result<DangerInspectionRecord>();
+		DangerInspectionRecord dangerInspectionRecord = dangerInspectionRecordService.getById(id);
+		if(dangerInspectionRecord==null) {
+			result.error500("未找到对应实体");
+		}else {
+			result.setResult(dangerInspectionRecord);
+			result.setSuccess(true);
+		}
+		return result;
+	}
+
+   /**
+	 * <pre>
+	 * 	 导出excel
+	 * </pre>
+	 * @param request
+	 * @param response
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+
+  @RequestMapping(value = "/exportXls")
+  public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
+      // Step.1 组装查询条件
+      QueryWrapper<DangerInspectionRecord> queryWrapper = null;
+      try {
+          String paramsStr = request.getParameter("paramsStr");
+          if (ConvertUtils.isNotEmpty(paramsStr)) {
+              String deString = URLDecoder.decode(paramsStr, "UTF-8");
+              DangerInspectionRecord dangerInspectionRecord = JSON.parseObject(deString, DangerInspectionRecord.class);
+              queryWrapper = QueryGenerator.initQueryWrapper(dangerInspectionRecord, request.getParameterMap());
+          }
+      } catch (UnsupportedEncodingException e) {
+          e.printStackTrace();
+      }
+
+      //Step.2 AutoPoi 导出Excel
+      ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
+      List<DangerInspectionRecord> pageList = dangerInspectionRecordService.list(queryWrapper);
+      //导出文件名称
+      mv.addObject(NormalExcelConstants.FILE_NAME, "巡检记录列表");
+      mv.addObject(NormalExcelConstants.CLASS, DangerInspectionRecord.class);
+      mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("巡检记录列表数据", "导出人:Jeecg", "导出信息"));
+      mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
+      return mv;
+  }
+
+   /**
+	 * <pre>
+	 * 	 通过excel导入数据
+	 * </pre>
+	 * @param request
+	 * @param response
+	 * @return
+	 * @author 开发者姓名, 开发时间
+	 * @Description: TODO(这里描述这个方法的需求变更情况)
+	 */
+  @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
+  public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
+      MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
+      Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
+      for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
+          MultipartFile file = entity.getValue();// 获取上传文件对象
+          ImportParams params = new ImportParams();
+          params.setTitleRows(2);
+          params.setHeadRows(1);
+          params.setNeedSave(true);
+          try {
+              List<DangerInspectionRecord> listDangerInspectionRecords = ExcelImportUtil.importExcel(file.getInputStream(), DangerInspectionRecord.class, params);
+              dangerInspectionRecordService.saveBatch(listDangerInspectionRecords);
+              return Result.ok("文件导入成功！数据行数:" + listDangerInspectionRecords.size());
+          } catch (Exception e) {
+              log.error(e.getMessage(),e);
+              return Result.error("文件导入失败:"+e.getMessage());
+          } finally {
+              try {
+                  file.getInputStream().close();
+              } catch (IOException e) {
+                  e.printStackTrace();
+              }
+          }
+      }
+      return Result.ok("文件导入失败！");
+  }
+
+}

+package com.skua.modules.safe.controller.app;
+import java.util.List;
+
+import com.skua.core.api.vo.Result;
+import com.skua.core.aspect.annotation.AutoLog;
+import com.skua.core.context.BaseContextHandler;
+import com.skua.modules.safe.entity.*;
+import com.skua.modules.safe.mapper.DangerInspectionItemMapper;
+import com.skua.modules.safe.service.*;
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+/**
+ * <pre>
+ * 风险巡检
+ * </pre>
+ * @author 开发者姓名
+ * @version V0.1, 开发时间
+ */
+@Slf4j
+@Api(tags="风险巡检")
+@RestController("APPDangerInspectionController")
+@RequestMapping("/app/safe/dangerInspection")
+public class APPDangerInspectionController {
+
+    @Autowired
+    private IDangerLevelManageService dangerLevelManageService;//风险点Service
+
+    @Autowired
+    private IDangerInspectionRecordService inspectionRecordService ;//巡检对象
+
+    @Autowired
+    private IDangerInspectionInfoService  inspectionInfoService ;//巡检对象
+
+    @Autowired
+    private IDangerInspectionItemService  inspectionItemService ;//巡检对象，检查项
+
+
+    /**
+     * <pre>
+     * 	 扫描二维码进入：风险点详情
+     * </pre>
+     * @param id
+     * @return
+     * @author 开发者姓名, 开发时间
+     * @Description: TODO(这里描述这个方法的需求变更情况)
+     */
+    @AutoLog(value = "扫描二维码进入：风险点详情")
+    @ApiOperation(value="扫描二维码进入：风险点详情", notes="扫描二维码进入：风险点详情")
+    @GetMapping(value = "/queryDangerById")
+    public Result<DangerLevelManage> queryById(@RequestParam(name="id",required=true) String id) {
+        Result<DangerLevelManage> result = new Result<DangerLevelManage>();
+        DangerLevelManage dangerInspection = dangerLevelManageService.getById(id);
+        //查询：上次巡检时间
+        DangerInspectionRecord inspection  = inspectionRecordService.queryOneByDangerId( id,"2" ,BaseContextHandler.getUserId());//根据分线点编号，获取巡检最后一条记录
+        if(inspection != null ){
+            dangerInspection.setLastInspectionTime( inspection.getReportDate() );
+        }else{
+            dangerInspection.setLastInspectionTime("");
+        }
+        if(dangerInspection==null) {
+            result.error500("未找到对应实体");
+        }else {
+            result.setResult(dangerInspection);
+            result.setSuccess(true);
+        }
+        return result;
+    }
+
+    /**
+     * <pre>
+     * 	 开始巡检-->获取风险点，检查对象集合
+     * </pre>
+     * @param dangerId
+     * @return
+     * @author 开发者姓名, 开发时间
+     * @Description: TODO(这里描述这个方法的需求变更情况)
+     */
+    @AutoLog(value = "开始巡检-->开始巡检")
+    @ApiOperation(value="开始巡检-->开始巡检", notes="开始巡检-->开始巡检")
+    @GetMapping(value = "/startInspection")
+    public Result< DangerInspectionRecord > startInspection(@RequestParam(name="dangerId",required=true) String dangerId) {
+        Result< DangerInspectionRecord > result = new Result< DangerInspectionRecord >();
+
+        //开始巡检，将风险点下的检查内容（检查项目）插入到巡检、巡检项目，并创建巡检记录
+        DangerInspectionRecord dangerInspection  =   inspectionRecordService.startInspection(dangerId,"1",BaseContextHandler.getUserId());
+        if(dangerInspection==null) {
+            result.error500("未找到对应实体");
+        }else {
+            result.setResult(dangerInspection);
+            result.setSuccess(true);
+        }
+        return result;
+    }
+
+    /**
+     * <pre>
+     * 	 开始巡检-->根据id获取检查内容对象
+     * </pre>
+     * @param id
+     * @return
+     * @author 开发者姓名, 开发时间
+     * @Description: TODO(这里描述这个方法的需求变更情况)
+     */
+    @AutoLog(value = "开始巡检-->根据id获取检查内容对象")
+    @ApiOperation(value="开始巡检-->根据id获取检查内容对象", notes="开始巡检-->根据id获取检查内容对象")
+    @GetMapping(value = "/queryInspectInfoById")
+    public Result< DangerInspectionInfo> queryInspectInfoById(@RequestParam(name="id",required=true) String id) {
+        Result< DangerInspectionInfo> result = new Result< DangerInspectionInfo >();
+
+        DangerInspectionInfo   inspectionInfo  = inspectionInfoService.getById( id ) ;
+        if(inspectionInfo != null ){
+            List<DangerInspectionItem>  inspectionItemList = inspectionItemService.queryListByInfoId(inspectionInfo.getId());
+            inspectionInfo.setInspectionItemList( inspectionItemList ) ;
+        }
+
+        if(inspectionInfo==null) {
+            result.error500("未找到对应实体");
+        }else {
+            result.setResult(inspectionInfo);
+            result.setSuccess(true);
+        }
+        return result;
+    }
+
+    @AutoLog(value = "巡查内容对象-保存")
+    @ApiOperation(value="巡查内容对象-保存", notes="巡查内容对象-保存")
+    @PostMapping(value = "/saveInspectionInf")
+    public Result<DangerInspectInfo> updateDangerInspectionInfo(@RequestBody DangerInspectionInfo dangerInspectionInfo) {
+        Result<DangerInspectInfo> result = new Result<DangerInspectInfo>();
+        try {
+            inspectionInfoService.updateDangerInspectionInfo(dangerInspectionInfo);
+            result.success("添加成功！");
+        } catch (Exception e) {
+            log.error(e.getMessage(),e);
+            result.error500("操作失败");
+        }
+        return result;
+    }
+    @AutoLog(value = "结束巡检")
+    @ApiOperation(value="结束巡检", notes="结束巡检")
+    @PostMapping(value = "/endInspection")
+    public Result<DangerInspectInfo> endInspection(@RequestParam(name="id",required=true) String id) {
+        Result<DangerInspectInfo> result = new Result<DangerInspectInfo>();
+        try {
+
+            //inspectionRecordService.(id);
+            result.success("添加成功！");
+        } catch (Exception e) {
+            log.error(e.getMessage(),e);
+            result.error500("操作失败");
+        }
+        return result;
+    }
+
+
+}

@@ -34,7 +34,7 @@ public class DangerInspectInfo {
 	/**风险点编号*/
 	/**风险点编号*/
 	@Excel(name = "风险点编号", width = 15)
 	@Excel(name = "风险点编号", width = 15)
     @ApiModelProperty(value = "风险点编号")
     @ApiModelProperty(value = "风险点编号")
-	private String dangerLevelId;
+	private String dangerId;
 	/**检查内容*/
 	/**检查内容*/
 	@Excel(name = "检查内容", width = 15)
 	@Excel(name = "检查内容", width = 15)
     @ApiModelProperty(value = "检查内容")
     @ApiModelProperty(value = "检查内容")

@@ -29,6 +29,12 @@ public class DangerInspectItem {
 	@TableId(type = IdType.ID_WORKER_STR)
 	@TableId(type = IdType.ID_WORKER_STR)
     @ApiModelProperty(value = "id")
     @ApiModelProperty(value = "id")
 	private String id;
 	private String id;
+
+	/**风险点编号*/
+	@Excel(name = "风险点编号", width = 15)
+	@ApiModelProperty(value = "风险点编号")
+	private String dangerId;
+
 	/**检查内容对象编号*/
 	/**检查内容对象编号*/
 	@Excel(name = "检查内容对象编号", width = 15)
 	@Excel(name = "检查内容对象编号", width = 15)
     @ApiModelProperty(value = "检查内容对象编号")
     @ApiModelProperty(value = "检查内容对象编号")

+package com.skua.modules.safe.entity;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.TableField;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.jeecgframework.poi.excel.annotation.Excel;
+
+/**
+ * 巡检对象
+ */
+@Data
+@TableName("danger_inspection_info")
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@ApiModel(value="danger_inspection_info对象", description="巡检对象")
+public class DangerInspectionInfo {
+    
+	/**id*/
+	@TableId(type = IdType.ID_WORKER_STR)
+    @ApiModelProperty(value = "id")
+	private String id;
+	/**厂id*/
+	@Excel(name = "厂id", width = 15)
+    @ApiModelProperty(value = "厂id")
+	private String departId;
+	/**记录人用户编号*/
+	@Excel(name = "巡检记录编号", width = 15)
+    @ApiModelProperty(value = "巡检记录编号")
+	private String inspectionRecordId;
+	/**风险等级对象*/
+	@Excel(name = "风险等级对象", width = 15)
+    @ApiModelProperty(value = "风险等级对象")
+	private String dangerId;
+	/**检查内容对象编号*/
+	@Excel(name = "检查内容对象编号", width = 15)
+    @ApiModelProperty(value = "检查内容对象编号")
+	private String inspectObjId;
+
+	/**检查内容*/
+	@Excel(name = "检查内容", width = 15)
+	@ApiModelProperty(value = "检查内容")
+	private String inspectName;
+	/**检查标准*/
+	@Excel(name = "检查标准", width = 15)
+	@ApiModelProperty(value = "检查标准")
+	private String inspectStandard;
+	/**检查方法*/
+	@Excel(name = "检查方法", width = 15)
+	@ApiModelProperty(value = "检查方法")
+	private String inspectMethod;
+
+
+	/**检查图片*/
+	@Excel(name = "检查图片", width = 15)
+    @ApiModelProperty(value = "检查图片")
+	private String inspectImg;
+	/**上报人（用户id）*/
+	@Excel(name = "上报人（用户id）", width = 15)
+    @ApiModelProperty(value = "上报人（用户id）")
+	private String reportUser;
+	/**巡检状态(0:未开始，1:开始，2:结束，3：作废)*/
+	@Excel(name = "巡检状态(0:未开始，1:开始，2:结束，3：作废)", width = 15)
+    @ApiModelProperty(value = "巡检状态(0:未开始，1:开始，2:结束，3：作废)")
+	private String status;
+	/**备注*/
+	@Excel(name = "备注", width = 15)
+    @ApiModelProperty(value = "备注")
+	private String remark;
+	/**创建人Id*/
+	@Excel(name = "创建人Id", width = 15)
+    @ApiModelProperty(value = "创建人Id")
+	private String createBy;
+	/**上报时间*/
+	@Excel(name = "上报时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
+	@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "上报时间")
+	private Date createTime;
+	/**修改人Id*/
+	@Excel(name = "修改人Id", width = 15)
+    @ApiModelProperty(value = "修改人Id")
+	private String updateBy;
+	/**修改时间*/
+	@Excel(name = "修改时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
+	@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "修改时间")
+	private Date updateTime;
+	/**删除标识，1有效，0删除*/
+	@Excel(name = "删除标识，1有效，0删除", width = 15)
+    @ApiModelProperty(value = "删除标识，1有效，0删除")
+	private Integer delFlag;
+
+	@TableField(exist=false)
+	@ApiModelProperty(value = "检查项集合")
+	private  List<DangerInspectionItem> inspectionItemList;
+}

@@ -29,6 +29,11 @@ public class DangerInspectionItem {
 	@TableId(type = IdType.ID_WORKER_STR)
 	@TableId(type = IdType.ID_WORKER_STR)
     @ApiModelProperty(value = "id")
     @ApiModelProperty(value = "id")
 	private String id;
 	private String id;
+
+	@Excel(name = "巡检检查内容对象编号", width = 15)
+	@ApiModelProperty(value = "巡检检查内容对象编号")
+	private String inspectionInfoId;
+
 	/**检查内容对象编号*/
 	/**检查内容对象编号*/
 	@Excel(name = "检查内容对象编号", width = 15)
 	@Excel(name = "检查内容对象编号", width = 15)
     @ApiModelProperty(value = "检查内容对象编号")
     @ApiModelProperty(value = "检查内容对象编号")

@@ -102,7 +102,6 @@ public class DangerLevelManage {
 	private String qrCode;
 	private String qrCode;
 
 
 
 
-
 	/**创建人Id*/
 	/**创建人Id*/
     @ApiModelProperty(value = "创建人Id")
     @ApiModelProperty(value = "创建人Id")
 	private String createBy;
 	private String createBy;

+package com.skua.modules.safe.mapper;
+
+import java.util.List;
+
+import org.apache.ibatis.annotations.Param;
+import com.skua.modules.safe.entity.DangerInspectionInfo;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * 巡检对象
+ */
+public interface DangerInspectionInfoMapper extends BaseMapper<DangerInspectionInfo> {
+
+}

+package com.skua.modules.safe.mapper;
+
+import java.util.List;
+
+import org.apache.ibatis.annotations.Param;
+import com.skua.modules.safe.entity.DangerInspectionRecord;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * 巡检记录
+ */
+public interface DangerInspectionRecordMapper extends BaseMapper<DangerInspectionRecord> {
+
+    /***
+     * 批量插入检查内容对象
+     * @param dangerInspection
+     */
+    public void batchSaveInspectionInfo(DangerInspectionRecord dangerInspection);
+}

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.skua.modules.safe.mapper.DangerInspectionInfoMapper">
+
+</mapper>
\ No newline at end of file

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.skua.modules.safe.mapper.DangerInspectionRecordMapper">
+
+</mapper>
\ No newline at end of file

+package com.skua.modules.safe.service;
+
+import com.skua.modules.safe.entity.DangerInspectionInfo;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * 巡检对象
+ */
+public interface IDangerInspectionInfoService extends IService<DangerInspectionInfo> {
+
+    /***
+     * 保存巡检对象
+     * @param dangerInspectionInfo
+     */
+    public void updateDangerInspectionInfo(DangerInspectionInfo dangerInspectionInfo);
+}

@@ -3,9 +3,17 @@ package com.skua.modules.safe.service;
 import com.skua.modules.safe.entity.DangerInspectionItem;
 import com.skua.modules.safe.entity.DangerInspectionItem;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.baomidou.mybatisplus.extension.service.IService;
 
 
+import java.util.List;
+
 /**
 /**
  * 风险检查项记录
  * 风险检查项记录
  */
  */
 public interface IDangerInspectionItemService extends IService<DangerInspectionItem> {
 public interface IDangerInspectionItemService extends IService<DangerInspectionItem> {
 
 
+    /***
+     *  根据infoId查询检查项目集合
+     * @param infoId
+     * @return
+     */
+    public  List<DangerInspectionItem> queryListByInfoId(String infoId);
 }
 }

+package com.skua.modules.safe.service;
+
+import com.skua.modules.safe.entity.DangerInspectionInfo;
+import com.skua.modules.safe.entity.DangerInspectionRecord;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.List;
+
+/**
+ * 巡检记录
+ */
+public interface IDangerInspectionRecordService extends IService<DangerInspectionRecord> {
+
+    /**
+     * 根据分线点编号dangerId，获取最新的巡检记录
+     * @param dangerId
+     * @return
+     */
+    public DangerInspectionRecord queryOneByDangerId(String dangerId,String status,String userId);
+
+    /***
+     * 开始i巡检，如果用户已经开始巡检，返回巡检对象，如果未巡检，那就创建新的巡检对象
+     * @param dangerId  风险点编号
+     * @param status  状态
+     * @param userId   用户编号
+     * @return
+     */
+    public DangerInspectionRecord startInspection(String dangerId, String status , String userId);
+}

@@ -54,7 +54,7 @@ public class DangerInspectInfoServiceImpl extends ServiceImpl<DangerInspectInfoM
      */
      */
     public List<DangerInspectInfo> queryListByDangerId(String  dangerId){
     public List<DangerInspectInfo> queryListByDangerId(String  dangerId){
         LambdaQueryWrapper<DangerInspectInfo> queryWrapper = new LambdaQueryWrapper<DangerInspectInfo>();
         LambdaQueryWrapper<DangerInspectInfo> queryWrapper = new LambdaQueryWrapper<DangerInspectInfo>();
-        queryWrapper.eq(DangerInspectInfo::getDangerLevelId, dangerId);
+        queryWrapper.eq(DangerInspectInfo::getDangerId, dangerId);
         queryWrapper.orderByDesc(DangerInspectInfo::getCreateTime);//添加排序
         queryWrapper.orderByDesc(DangerInspectInfo::getCreateTime);//添加排序
         return this.baseMapper.selectList(queryWrapper);
         return this.baseMapper.selectList(queryWrapper);
     }
     }

+package com.skua.modules.safe.service.impl;
+
+import com.skua.modules.safe.entity.DangerInspectionInfo;
+import com.skua.modules.safe.entity.DangerInspectionItem;
+import com.skua.modules.safe.mapper.DangerInspectionInfoMapper;
+import com.skua.modules.safe.mapper.DangerInspectionItemMapper;
+import com.skua.modules.safe.service.IDangerInspectionInfoService;
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+
+/**
+ * 巡检对象
+ */
+@Service
+public class DangerInspectionInfoServiceImpl extends ServiceImpl<DangerInspectionInfoMapper, DangerInspectionInfo> implements IDangerInspectionInfoService {
+
+    @Resource
+    private DangerInspectionItemMapper   inspectionItemMapper ;
+    /***
+     * 保存巡检对象
+     * @param dangerInspectionInfo
+     */
+    @Transactional
+    public void updateDangerInspectionInfo(DangerInspectionInfo dangerInspectionInfo){
+
+        this.baseMapper.updateById(dangerInspectionInfo ) ;
+
+        if(dangerInspectionInfo.getInspectionItemList() != null && !dangerInspectionInfo.getInspectionItemList().isEmpty()){
+            for( DangerInspectionItem item  : dangerInspectionInfo.getInspectionItemList()){
+                inspectionItemMapper.updateById( item) ;
+            }
+        }
+    }
+}

 package com.skua.modules.safe.service.impl;
 package com.skua.modules.safe.service.impl;
 
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.skua.modules.safe.entity.DangerInspectInfo;
 import com.skua.modules.safe.entity.DangerInspectionItem;
 import com.skua.modules.safe.entity.DangerInspectionItem;
 import com.skua.modules.safe.mapper.DangerInspectionItemMapper;
 import com.skua.modules.safe.mapper.DangerInspectionItemMapper;
 import com.skua.modules.safe.service.IDangerInspectionItemService;
 import com.skua.modules.safe.service.IDangerInspectionItemService;
@@ -7,10 +9,24 @@ import org.springframework.stereotype.Service;
 
 
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 
 
+import java.util.List;
+
 /**
 /**
  * 风险检查项记录
  * 风险检查项记录
  */
  */
 @Service
 @Service
 public class DangerInspectionItemServiceImpl extends ServiceImpl<DangerInspectionItemMapper, DangerInspectionItem> implements IDangerInspectionItemService {
 public class DangerInspectionItemServiceImpl extends ServiceImpl<DangerInspectionItemMapper, DangerInspectionItem> implements IDangerInspectionItemService {
 
 
+    /***
+     *  根据infoId查询检查项目集合
+     * @param infoId
+     * @return
+     */
+    public List<DangerInspectionItem> queryListByInfoId(String infoId){
+        LambdaQueryWrapper<DangerInspectionItem> queryWrapper = new LambdaQueryWrapper<DangerInspectionItem>();
+        queryWrapper.eq(DangerInspectionItem::getInspectionInfoId, infoId);
+        queryWrapper.orderByDesc(DangerInspectionItem::getCreateTime);//添加排序
+
+        return this.baseMapper.selectList(queryWrapper  );
+    }
 }
 }

+package com.skua.modules.safe.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.skua.core.context.BaseContextHandler;
+import com.skua.modules.safe.entity.*;
+import com.skua.modules.safe.mapper.*;
+import com.skua.modules.safe.service.IDangerInspectionRecordService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 巡检记录
+ */
+@Service
+public class DangerInspectionRecordServiceImpl extends ServiceImpl<DangerInspectionRecordMapper, DangerInspectionRecord> implements IDangerInspectionRecordService {
+
+    @Resource
+    private DangerLevelManageMapper dangerLevelManageMapper;
+    @Resource
+    private DangerInspectionInfoMapper dangerInspectionInfoMapper ;//巡检对象
+    @Resource
+    private DangerInspectionItemMapper dangerInspectionItemMapper ;//巡检对象，检查项
+    @Resource
+    private DangerInspectInfoMapper inspectInfoMapper;//检查对象
+    @Resource
+    private DangerInspectItemMapper  inspectItemMapper;//检查选项
+
+
+    /**
+     * 根据分线点编号dangerId，获取最新的巡检记录
+     * @param dangerId
+     * @return
+     */
+    public DangerInspectionRecord queryOneByDangerId(String dangerId,String status,String userId){
+        LambdaQueryWrapper<DangerInspectionRecord> queryWrapper = new LambdaQueryWrapper<DangerInspectionRecord>();
+        queryWrapper.eq(DangerInspectionRecord::getDangerId, dangerId);
+        queryWrapper.eq(DangerInspectionRecord::getStatus  , status);
+        queryWrapper.eq(DangerInspectionRecord::getReportUser  , userId);
+        queryWrapper.orderByDesc(DangerInspectionRecord::getCreateTime);//添加排序
+        return this.baseMapper.selectOne(queryWrapper);
+    }
+
+    /***
+     * 开始i巡检，如果用户已经开始巡检，返回巡检对象，如果未巡检，那就创建新的巡检对象
+     * @param dangerId  风险点编号
+     * @param status  状态
+     * @param userId   用户编号
+     * @return
+     */
+    @Transactional
+    public  DangerInspectionRecord startInspection(String dangerId,String status , String userId){
+
+        DangerInspectionRecord   dangerInspection =  queryOneByDangerId(dangerId  ,status  ,userId );
+        if(dangerInspection == null ){
+            DangerLevelManage  dangerLevelManage =  dangerLevelManageMapper.selectById(dangerId );
+            dangerInspection = new  DangerInspectionRecord();
+            dangerInspection.setDepartId(dangerLevelManage.getDepartId());
+            dangerInspection.setDangerId( dangerId  );
+            dangerInspection.setStatus( status);
+            dangerInspection.setReportUser( userId );
+
+            this.baseMapper.insert( dangerInspection ) ;
+
+            //添加检查对象
+            //批量插入检查内容对象
+            LambdaQueryWrapper<DangerInspectInfo> queryWrapper = new LambdaQueryWrapper<DangerInspectInfo>();
+            queryWrapper.eq(DangerInspectInfo::getDangerId, dangerId);
+            List<DangerInspectInfo> dangerInspectInfoList = inspectInfoMapper.selectList( queryWrapper );
+
+            LambdaQueryWrapper<DangerInspectItem> queryItemWrapper = new LambdaQueryWrapper<DangerInspectItem>();
+            List<DangerInspectItem> inspectItemList =  null;
+
+
+            if(dangerInspectInfoList != null && !dangerInspectInfoList.isEmpty()){
+                DangerInspectionInfo  inspectionInfo = null;
+                for(DangerInspectInfo dangerInspectInfo : dangerInspectInfoList){
+                    inspectionInfo = new DangerInspectionInfo();
+                    // ( depart_id , user_id,  danger_id ,    inspect_obj_id,inspect_name,inspect_standard  , inspect_method,report_user, )
+                    inspectionInfo.setDepartId(dangerLevelManage.getDepartId() ) ;
+                    inspectionInfo.setInspectionRecordId( dangerInspection.getId());
+                    inspectionInfo.setDangerId( dangerInspectInfo.getDangerId() );
+                    inspectionInfo.setInspectName( dangerInspectInfo.getInspectName() );
+                    inspectionInfo.setInspectMethod(   dangerInspectInfo.getInspectMethod());
+                    inspectionInfo.setInspectStandard( dangerInspectInfo.getInspectStandard() );
+                    inspectionInfo.setReportUser( userId) ;
+                    dangerInspectionInfoMapper.insert(inspectionInfo);
+
+                    //搜索检查内容对象，检查项目
+                    queryItemWrapper.eq(DangerInspectItem::getInspectObjId, dangerInspectInfo.getId());
+                    inspectItemList = inspectItemMapper.selectList(queryItemWrapper);
+                    if(inspectItemList != null && !inspectItemList.isEmpty()){
+                        DangerInspectionItem  inspectionItem = null;
+
+                        for(DangerInspectItem inspectItem : inspectItemList){
+                            inspectionItem = new DangerInspectionItem();
+                            // ( depart_id , user_id,  danger_id ,    inspect_obj_id,inspect_name,inspect_standard  , inspect_method,report_user, )
+                            inspectionItem.setInspectObjId( inspectItem.getInspectObjId() ) ;
+                            inspectionItem.setItemName( inspectItem.getItemName());
+                            inspectionItem.setItemType( inspectItem.getItemType());
+                            inspectionItem.setInspectionInfoId (inspectionInfo.getId());
+                            dangerInspectionItemMapper.insert(inspectionItem);
+                        }
+                    }
+                }
+            }
+           // inspectInfoMapper.
+
+            //this.baseMapper.batchSaveInspectionInfo(dangerInspection);
+            // 批量插入检查选项集合
+            //this.baseMapper.batchSaveInspectionItem(dangerInspection);
+   /*         LambdaQueryWrapper<DangerInspectItem> queryItemWrapper = new LambdaQueryWrapper<DangerInspectItem>();
+            queryItemWrapper.eq(DangerInspectItem::getDangerId, dangerId);
+            List<DangerInspectItem> inspectItemList = inspectItemMapper.selectList(queryItemWrapper);
+            if(inspectItemList != null && !inspectItemList.isEmpty()){
+                DangerInspectionItem  inspectionItem = null;
+
+                for(DangerInspectItem inspectItem : inspectItemList){
+                    inspectionItem = new DangerInspectionItem();
+                    // ( depart_id , user_id,  danger_id ,    inspect_obj_id,inspect_name,inspect_standard  , inspect_method,report_user, )
+                    inspectionItem.setInspectObjId( inspectItem.getInspectObjId() ) ;
+                    inspectionItem.setItemName( inspectItem.getItemName());
+                    inspectionItem.setItemType( inspectItem.getItemType());
+                    inspectionItem.setUserId(userId);
+                    dangerInspectionItemMapper.insert(inspectionItem);
+                }
+            }*/
+            // 添加检查对象的检查项目
+        }
+
+        List<DangerInspectionInfo>  inspectionInfoList   = queryInspectionInfoByDangerId( dangerId ,userId);
+        dangerInspection.setInspectionInfoList( inspectionInfoList  ) ;
+        return dangerInspection;
+    }
+
+    /***
+     * 根据检查点编号，获取用户的巡检检查集合
+     * @param dangerId
+     * @param userId
+     * @return
+     */
+    public List<DangerInspectionInfo> queryInspectionInfoByDangerId(String dangerId ,String userId){
+        LambdaQueryWrapper<DangerInspectionInfo> queryWrapper = new LambdaQueryWrapper<DangerInspectionInfo>();
+        queryWrapper.eq(DangerInspectionInfo::getReportUser, userId);
+        queryWrapper.eq(DangerInspectionInfo::getDangerId, dangerId);
+        queryWrapper.orderByAsc(  DangerInspectionInfo::getCreateTime );
+        List<DangerInspectionInfo>   inspectionInfoList = dangerInspectionInfoMapper.selectList( queryWrapper) ;
+
+        return inspectionInfoList;
+    }
+}