package com.javaweb.platform.controller;
|
|
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeSet;
|
import java.util.stream.Collectors;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestBody;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
|
import com.javaweb.platform.constant.ApplyStatus;
|
import com.javaweb.platform.constant.DrillType;
|
import com.javaweb.platform.domain.FrontUser;
|
import com.javaweb.platform.domain.HoleInfo;
|
import com.javaweb.platform.domain.HoleRecord;
|
import com.javaweb.platform.domain.LayerInfo;
|
import com.javaweb.platform.domain.Point;
|
import com.javaweb.platform.domain.ProjectApply;
|
import com.javaweb.platform.domain.ProjectApplyHole;
|
import com.javaweb.platform.domain.ProjectInfo;
|
import com.javaweb.platform.domain.ReturnInfo;
|
import com.javaweb.platform.domain.SampleInfo;
|
import com.javaweb.platform.domain.StageInfo;
|
import com.javaweb.platform.domain.TestInfo;
|
import com.javaweb.platform.domain.UserMsg;
|
import com.javaweb.platform.mapper.LayerInfoMapper;
|
import com.javaweb.platform.mapper.ProjectInfoMapper;
|
import com.javaweb.platform.mapper.UserMsgMapper;
|
import com.javaweb.platform.service.IProjectApplyService;
|
import com.javaweb.platform.service.IProjectInfoService;
|
import com.javaweb.platform.service.IReturnInfoService;
|
import com.javaweb.platform.service.ISampleInfoService;
|
import com.javaweb.platform.service.IStageInfoService;
|
import com.javaweb.platform.service.ITestInfoService;
|
import com.javaweb.platform.service.IHoleInfoService;
|
import com.javaweb.platform.service.IHoleRecordService;
|
import com.javaweb.platform.service.ILayerInfoService;
|
import com.javaweb.platform.service.IProjectApplyHoleService;
|
import com.javaweb.platform.utils.TdtUtils;
|
import com.javaweb.platform.utils.UserAuthCacheUtils;
|
import com.javaweb.common.annotation.UserAuth;
|
import com.javaweb.common.core.controller.BaseController;
|
import com.javaweb.common.core.domain.AjaxResult;
|
import com.javaweb.common.utils.IdGenerate;
|
import com.javaweb.common.utils.StringUtils;
|
import com.javaweb.hydrology.domain.HydrologyHoleInfo;
|
import com.javaweb.hydrology.mapper.HydrologyHoleInfoMapper;
|
import com.javaweb.hydrology.service.impl.HydrologyHoleInfoServiceImpl;
|
|
/**
|
* @author zmk
|
* @date 2022-03-08
|
*/
|
@Controller
|
@RequestMapping("/webgis")
|
public class WebGisController extends BaseController
|
{
|
|
|
@Autowired
|
private IProjectInfoService projectInfoService;
|
|
@Autowired
|
private ProjectInfoMapper projectInfoMapper;
|
|
@Autowired
|
private IProjectApplyService projectApplyService;
|
|
@Autowired
|
private IHoleInfoService holeInfoService;
|
|
@Autowired
|
private IHoleRecordService holeRecordService;
|
|
@Autowired
|
private ILayerInfoService layerInfoService;
|
@Autowired
|
private ISampleInfoService sampleInfoService;
|
@Autowired
|
private ITestInfoService testInfoService;
|
@Autowired
|
private IStageInfoService stageInfoService;
|
@Autowired
|
private IReturnInfoService returnInfoService;
|
|
|
@Autowired
|
private IProjectApplyHoleService projectApplyHoleService;
|
|
|
/**
|
* 矩形查询 多边形查询
|
* @param points
|
* @return
|
*/
|
@PostMapping("/polygonQuery")
|
@ResponseBody
|
public List<ProjectInfo> polygonQuery(@RequestBody List<Point> points) {
|
|
String polygon = "";
|
StringBuffer sBuffer = new StringBuffer();
|
for (Point point : points) {
|
sBuffer.append(point.getLng()).append(" ").append(point.getLat()).append(",");
|
}
|
String lnglat = sBuffer.toString();
|
lnglat = lnglat.substring(0, lnglat.length() - 1);
|
|
|
polygon = "POLYGON((" + lnglat + "))";
|
List<ProjectInfo> list = projectInfoService.selectByPolygon(polygon);
|
|
return list;
|
}
|
/**
|
* 圆形查询
|
* @param lat
|
* @param lng
|
* @param radius
|
* @return
|
*/
|
@PostMapping("/cicleQuery")
|
@ResponseBody
|
public List<ProjectInfo> cicleQuery(Double lat,Double lng,Double radius) {
|
List<ProjectInfo> list = projectInfoService.selectBynCircle(lat, lng, radius);
|
return list;
|
}
|
|
@PostMapping("/projectQuery")
|
@ResponseBody
|
public List<ProjectInfo> projectQuery(@RequestBody ProjectInfo projectInfo) throws Exception {
|
List<ProjectInfo> list=new ArrayList<>();
|
try {
|
|
list= projectInfoService.selectProjectInfoList(projectInfo);
|
} catch (Exception e) {
|
logger.debug(e.toString());
|
}
|
return list;
|
}
|
/**
|
* 項目信息
|
* @param id
|
* @return
|
*/
|
@PostMapping("/ProjectInfo")
|
@ResponseBody
|
public ProjectInfo ProjectInfo(String id) {
|
|
ProjectInfo info = projectInfoService.selectProjectInfoById(id);
|
return info;
|
}
|
|
/**
|
* 钻孔信息
|
* @param id
|
* @return
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/DrillInfo")
|
@ResponseBody
|
public HoleInfo DrillInfo(String id,HttpServletRequest request) {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
HoleInfo info = holeInfoService.selectHoleInfoById(id);
|
return info;
|
}
|
|
/**
|
* 申请钻孔
|
* @param apply
|
* @return
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/apply")
|
@ResponseBody
|
public AjaxResult apply(@RequestBody ProjectApply apply,HttpServletRequest request) {
|
try {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return AjaxResult.error("权限认证失败，无法申请！");
|
}
|
|
//List<String> holeIdList = apply.getHoleIdList();
|
|
List<ProjectApplyHole> applyHoles = apply.getApplyHoles();
|
|
if(applyHoles.size()> ApplyStatus.applyCount){
|
return AjaxResult.error("申请钻孔数量超过限制10个");
|
|
}
|
String applyId ="P" + IdGenerate.nextId();
|
apply.setId(applyId);
|
apply.setCreateTime(new Date());
|
apply.setStatus(ApplyStatus.under_review);
|
|
projectApplyService.insertProjectApply(apply);
|
|
ProjectApplyHole applyHole=null;
|
|
for(ProjectApplyHole tmp : applyHoles){
|
applyHole=new ProjectApplyHole();
|
applyHole.setId(IdGenerate.nextId());
|
applyHole.setApplyId(applyId);
|
|
applyHole.setHoleId(tmp.getHoleId());
|
if(tmp.getHoleType() !=null && tmp.getHoleType().equals(DrillType.DXS.getInfo())){
|
applyHole.setHoleType(DrillType.DXS.getInfo());
|
}else{
|
applyHole.setHoleType(DrillType.DZ.getInfo());
|
}
|
|
|
applyHole.setUserId(apply.getCreateBy());
|
applyHole.setCreateTime(new Date());
|
applyHole.setStatus(ApplyStatus.under_review);
|
projectApplyHoleService.insertProjectApplyHole(applyHole);
|
|
}
|
} catch (Exception e) {
|
logger.info(e.toString());
|
return AjaxResult.error();
|
}
|
|
return AjaxResult.success();
|
}
|
|
|
/**
|
* 用户申请记录
|
* @param userid
|
* @return
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/userApplyList")
|
@ResponseBody
|
public List<ProjectApply> userApply(String userid,HttpServletRequest request)
|
{
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
FrontUser user = (FrontUser) UserAuthCacheUtils.getCahce(token);
|
if(!user.getUserName().equals(userid)){
|
return null;
|
}
|
|
ProjectApply apply= new ProjectApply();
|
apply.setCreateBy(userid);
|
return projectApplyService.selectProjectApplyList(apply);
|
}
|
/**
|
* 申请记录对应的钻孔
|
* @param applyId
|
* @return
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/userApplyHoleList")
|
@ResponseBody
|
public List<ProjectApplyHole> userApplyHoleList(String applyId,HttpServletRequest request)
|
{
|
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
|
ProjectApplyHole projectApplyHole=new ProjectApplyHole();
|
projectApplyHole.setApplyId(applyId);
|
List<ProjectApplyHole> holes= projectApplyHoleService.selectProjectApplyHoleListJoinHoleInfo(projectApplyHole);
|
return holes;
|
|
}
|
|
@UserAuth("frontUser")
|
@PostMapping("/userApproveHoleList")
|
@ResponseBody
|
public AjaxResult userApproveHoleList(String holeId,String userId,HttpServletRequest request)
|
{
|
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
|
ProjectApplyHole projectApplyHole=new ProjectApplyHole();
|
projectApplyHole.setHoleId(holeId);
|
projectApplyHole.setUserId(userId);
|
projectApplyHole.setStatus(ApplyStatus.apply_approve);
|
List<ProjectApplyHole> list = projectApplyHoleService.selectProjectApplyHoleList(projectApplyHole);
|
|
int count = StringUtils.isEmpty(list) ? 0 : 1;
|
|
AjaxResult ajaxResult=new AjaxResult();
|
ajaxResult.put("count", count);
|
|
return ajaxResult;
|
|
|
}
|
|
@PostMapping("/getGeocoding")
|
@ResponseBody
|
public AjaxResult getGeocoding() throws Exception
|
{
|
List<ProjectInfo> list= projectInfoMapper.selectEmptyLnglat();
|
|
for(ProjectInfo info : list){
|
String address=info.getAddress();
|
List<String> lnglat=TdtUtils.getGeocoding(address);
|
info.setLat(Double.valueOf(lnglat.get(0)));
|
info.setLng(Double.valueOf(lnglat.get(1)));
|
projectInfoMapper.updateProjectInfo(info);
|
|
}
|
return AjaxResult.success();
|
|
}
|
|
/**
|
* 根据地名字查找 经纬度
|
* @param address
|
* @return
|
* @throws Exception
|
*/
|
@PostMapping("/findGeocodingByPlace")
|
@ResponseBody
|
public AjaxResult findGeocodingByPlace(String address) throws Exception {
|
List<String> lnglat = new ArrayList<>();
|
try {
|
lnglat = TdtUtils.getGeocoding(address);
|
} catch (Exception e) {
|
|
}
|
return AjaxResult.success(lnglat);
|
|
}
|
|
/**
|
* 根据项目id找钻孔
|
* @param projectId
|
* @return
|
* @throws Exception
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/findHoleByProject")
|
@ResponseBody
|
public List<HoleInfo> findHoleByProject(String projectId,HttpServletRequest request) throws Exception {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
HoleInfo holeInfo= new HoleInfo();
|
holeInfo.setProjNo(projectId);
|
return holeInfoService.selectHoleInfoList(holeInfo);
|
}
|
|
@UserAuth("frontUser")
|
@PostMapping("/findRecordByHole")
|
@ResponseBody
|
public List<HoleRecord> findRecordByHole(String holeId,HttpServletRequest request) throws Exception {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
HoleRecord holeRecord= new HoleRecord();
|
holeRecord.setDrillId(holeId);
|
return holeRecordService.selectHoleRecordList(holeRecord);
|
}
|
|
@UserAuth("frontUser")
|
@PostMapping("/findLayerByProjectAndHole")
|
@ResponseBody
|
public Map<String,Object> findLayerByProjectAndHole(String projId,String holeId,HttpServletRequest request) throws Exception {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
String projectNo=projectInfoService.selectProjectInfoById(projId).getProjectNo();
|
LayerInfo layerInfo=new LayerInfo();
|
layerInfo.setProjNo(projId);
|
layerInfo.setHoleNo(holeId);
|
int length=layerInfoService.selectLayerInfoList(layerInfo).size();
|
Map<String,Object> map=new HashMap<String,Object>();
|
map.put("projectNo", projectNo);
|
map.put("length",length);
|
return map;
|
}
|
|
/**
|
* 获取钻孔信息
|
* @param holeId
|
* @return
|
* @throws Exception
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/findHoleInfoByHoleId")
|
@ResponseBody
|
public Map<String,Object> findHoleInfoByHoleId(String holeId,HttpServletRequest request) throws Exception {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
HoleInfo holeInfo=holeInfoService.selectHoleInfoById(holeId);
|
String projectId=holeInfo.getProjNo();
|
ProjectInfo projectInfo=projectInfoService.selectProjectInfoById(projectId);
|
|
//孔深
|
LayerInfo layerInfo=new LayerInfo();
|
List<LayerInfo> listLayer=new ArrayList<LayerInfo>();
|
layerInfo.setHoleNo(holeId);
|
listLayer.addAll(layerInfoService.selectLayerInfoList(layerInfo));
|
listLayer.sort((x, y) -> Double.compare(x.getBottomDepth(), y.getBottomDepth()));
|
Double holeDepth=listLayer.get(listLayer.size()-1).getBottomDepth();
|
String holeInfo1="";
|
String holeInfo2="";
|
if(projectInfo.getProjectName()!=null&&!projectInfo.getProjectName().equals("")) {
|
holeInfo1+="所属项目："+projectInfo.getProjectName();
|
}
|
if(holeDepth!=null&&!holeDepth.equals("")) {
|
holeInfo1+=" 孔深："+holeDepth;
|
}
|
if(holeInfo.getStartDate()!=null&&!holeInfo.getStartDate().equals("")) {
|
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
|
holeInfo1+=" 开始时间："+sdf.format(holeInfo.getStartDate());
|
}
|
if(projectInfo.getExprorationUnit()!=null&&!projectInfo.getExprorationUnit().equals("")) {
|
holeInfo2+="勘察单位："+projectInfo.getExprorationUnit();
|
}
|
if(holeInfo.getHoleNo()!=null&&!holeInfo.getHoleNo().equals("")) {
|
holeInfo2+=" 钻孔编号："+holeInfo.getHoleNo();
|
}
|
if(holeInfo.getEndDate()!=null&&!holeInfo.getEndDate().equals("")) {
|
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
|
holeInfo2+=" 结束时间："+sdf.format(holeInfo.getEndDate());
|
}
|
Map<String,Object> map=new HashMap<String,Object>();
|
map.put("holeInfo1", holeInfo1);
|
map.put("holeInfo2", holeInfo2);
|
return map;
|
}
|
|
/**
|
* 绘制钻孔柱状图
|
* @param holeId
|
* @return
|
*/
|
@UserAuth("frontUser")
|
@RequestMapping(value = "drawHole")
|
@ResponseBody
|
public List<Map<Object,Object>> drawHole(String holeId,HttpServletRequest request) {
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
List<Map<Object,Object>> mapList=new ArrayList<>();
|
//地层
|
LayerInfo layerInfo=new LayerInfo();
|
List<LayerInfo> listLayer=new ArrayList<LayerInfo>();
|
layerInfo.setHoleNo(holeId);
|
listLayer.addAll(layerInfoService.selectLayerInfoList(layerInfo));
|
listLayer=listLayer.stream().filter(v->v.getTopdepth()!=null&&v.getBottomDepth()!=null).collect(Collectors.toList());
|
listLayer = listLayer.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(LayerInfo :: getBottomDepth))), ArrayList::new));
|
try {
|
listLayer.sort((x, y) -> Double.compare(x.getBottomDepth(), y.getBottomDepth()));
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
for(LayerInfo layer:listLayer) {
|
Map<Object,Object> map=new HashMap<Object,Object>();
|
map.put("id", layer.getId());
|
map.put("type", "岩土");
|
map.put("code", layer.getRecordNo());
|
map.put("typeName", layer.getRockType()+'-'+layer.getRockName());
|
map.put("layerName", layer.getRockName());
|
map.put("begin", layer.getTopdepth());
|
map.put("end", layer.getBottomDepth());
|
map.put("medias",new String[0]);
|
String title="";
|
if(layer.getRockType()!=null&&!layer.getRockType().equals("")) {
|
title+="岩土类型："+layer.getRockType()+";";
|
}
|
if(layer.getRockName()!=null&&!layer.getRockName().equals("")) {
|
title+="岩土定名："+layer.getRockName()+";";
|
}
|
if(layer.getColour()!=null&&!layer.getColour().equals("")) {
|
title+="颜色："+layer.getColour()+";";
|
}
|
if(layer.getDensity()!=null&&!layer.getDensity().equals("")) {
|
title+="密实度："+layer.getDensity()+";";
|
}
|
if(layer.getHumidity()!=null&&!layer.getHumidity().equals("")) {
|
title+="湿度："+layer.getHumidity()+";";
|
}
|
if(layer.getBlockDiameterRangeSmall()!=null&&!layer.getBlockDiameterRangeSmall().equals("")) {
|
title+="一般粒径小："+layer.getBlockDiameterRangeSmall()+";";
|
}
|
if(layer.getBlockDiameterRangeBig()!=null&&!layer.getBlockDiameterRangeBig().equals("")) {
|
title+="一般粒径大："+layer.getBlockDiameterRangeBig()+";";
|
}
|
if(layer.getBlockDiameterRangeMax()!=null&&!layer.getBlockDiameterRangeMax().equals("")) {
|
title+="最大粒径："+layer.getBlockDiameterRangeMax()+";";
|
}
|
if(layer.getState()!=null&&!layer.getState().equals("")) {
|
title+="状态："+layer.getState()+";";
|
}
|
if(layer.getIncluding()!=null&&!layer.getIncluding().equals("")) {
|
title+="包含物："+layer.getIncluding()+";";
|
}
|
if(layer.getParticalShape()!=null&&!layer.getParticalShape().equals("")) {
|
title+="颗粒形状："+layer.getParticalShape()+";";
|
}
|
if(layer.getParticalLine()!=null&&!layer.getParticalLine().equals("")) {
|
title+="颗粒排列："+layer.getParticalLine()+";";
|
}
|
if(layer.getParticalSizeDistribution()!=null&&!layer.getParticalSizeDistribution().equals("")) {
|
title+="颗粒级配："+layer.getParticalSizeDistribution()+";";
|
}
|
map.put("title", title);
|
mapList.add(map);
|
}
|
//水位
|
StageInfo stageInfo=new StageInfo();
|
List<StageInfo> listStage=new ArrayList<StageInfo>();
|
stageInfo.setHoleNo(holeId);
|
listStage.addAll(stageInfoService.selectStageInfoList(stageInfo));
|
listStage=listStage.stream().filter(v->v.getInitialWaterLevel()!=null&&v.getStaticWaterLevel()!=null).collect(Collectors.toList());
|
try {
|
listStage.sort((x, y) -> Double.compare(x.getInitialWaterLevel(),y.getInitialWaterLevel()));
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
for(StageInfo stage:listStage) {
|
Map<Object,Object> map=new HashMap<Object,Object>();
|
map.put("id", stage.getId());
|
map.put("type", "水位");
|
map.put("code", stage.getRecordNo());
|
map.put("typeName", "地下水");
|
map.put("begin", stage.getInitialWaterLevel());
|
map.put("end", stage.getStaticWaterLevel());
|
map.put("medias",new String[0]);
|
String title="";
|
if(stage.getInitialWaterLevel()!=null&&!stage.getInitialWaterLevel().equals("")) {
|
title+="初见水位："+stage.getInitialWaterLevel()+";";
|
}
|
if(stage.getStaticWaterLevel()!=null&&!stage.getStaticWaterLevel().equals("")) {
|
title+="稳定水位："+stage.getStaticWaterLevel()+";";
|
}
|
map.put("title", title);
|
mapList.add(map);
|
}
|
try {
|
mapList.sort((x, y) -> Double.compare(Double.parseDouble(x.get("begin").toString()),Double.parseDouble(y.get("begin").toString())));
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
//回次
|
ReturnInfo returnInfo=new ReturnInfo();
|
List<ReturnInfo> listReturn=new ArrayList<ReturnInfo>();
|
returnInfo.setHoleNo(holeId);
|
listReturn.addAll(returnInfoService.selectReturnInfoList(returnInfo));
|
listReturn=listReturn.stream().filter(v->v.getStartDepth()!=null&&v.getEndDepth()!=null).collect(Collectors.toList());
|
try {
|
listReturn.sort((x, y) -> Double.compare(x.getEndDepth(),y.getEndDepth()));
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
for(ReturnInfo return1:listReturn) {
|
Map<Object,Object> map=new HashMap<Object,Object>();
|
map.put("id", return1.getId());
|
map.put("type", "回次");
|
map.put("code", return1.getRecordNo());
|
map.put("typeName", return1.getDrillMethod()+'-'+return1.getWallProtectMethod());
|
map.put("begin", return1.getStartDepth());
|
map.put("end", return1.getEndDepth());
|
map.put("medias",new String[0]);
|
String title="";
|
if(return1.getDrillMethod()!=null&&!return1.getDrillMethod().equals("")) {
|
title+="钻进方法："+return1.getDrillMethod()+";";
|
}
|
if(return1.getWallProtectMethod()!=null&&!return1.getWallProtectMethod().equals("")) {
|
title+="护壁方法："+return1.getWallProtectMethod()+";";
|
}
|
if(return1.getBoreDiameter()!=null&&!return1.getBoreDiameter().equals("")) {
|
title+="钻孔孔径："+return1.getBoreDiameter()+";";
|
}
|
if(return1.getStartDepth()!=null&&!return1.getStartDepth().equals("")) {
|
title+="起始深度："+return1.getStartDepth()+";";
|
}
|
if(return1.getEndDepth()!=null&&!return1.getEndDepth().equals("")) {
|
title+="终止深度："+return1.getEndDepth()+";";
|
}
|
map.put("title", title);
|
mapList.add(map);
|
}
|
//取样
|
SampleInfo sampleInfo=new SampleInfo();
|
List<SampleInfo> listSample=new ArrayList<SampleInfo>();
|
sampleInfo.setHoleNo(holeId);
|
listSample.addAll(sampleInfoService.selectSampleInfoList(sampleInfo));
|
listSample=listSample.stream().filter(v->v.getSampleStartDepth()!=null&&v.getSampleEndDepth()!=null).collect(Collectors.toList());
|
try {
|
listSample.sort((x, y) -> Double.compare(x.getSampleEndDepth(),y.getSampleEndDepth()));
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
for(SampleInfo sample:listSample) {
|
Map<Object,Object> map=new HashMap<Object,Object>();
|
map.put("id", sample.getId());
|
map.put("type", "取土");
|
map.put("code",sample.getRecordNo());
|
map.put("typeName", "取土");
|
map.put("begin", sample.getSampleStartDepth());
|
map.put("end", sample.getSampleEndDepth());
|
map.put("medias",new String[0]);
|
String title="";
|
if(sample.getQualityLevel()!=null&&!sample.getQualityLevel().equals("")) {
|
title+="土样质量等级："+sample.getQualityLevel()+";";
|
}
|
if(sample.getSamplingTool()!=null&&!sample.getSamplingTool().equals("")) {
|
title+="取样工具和方法："+sample.getSamplingTool()+";";
|
}
|
map.put("title", title);
|
mapList.add(map);
|
}
|
//测试
|
TestInfo testInfo=new TestInfo();
|
List<TestInfo> listTest=new ArrayList<TestInfo>();
|
testInfo.setHoleNo(holeId);
|
listTest.addAll(testInfoService.selectTestInfoList(testInfo));
|
try {
|
listTest.sort((x, y) -> Double.compare(x.getExpectDepthStart(),y.getExpectDepthStart()));
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
for(TestInfo test:listTest) {
|
if(test.getExpectDepthStart()!=null&&!test.getExpectDepthStart().equals("")&&test.getExpectDepthStart()!=0) {
|
Map<Object,Object> map=new HashMap<Object,Object>();
|
map.put("id", test.getId());
|
if(test.getRecordType().equals("JL001")) {
|
map.put("type", "动探");
|
map.put("typeName", "动探");
|
}
|
else if(test.getRecordType().equals("JL013")) {
|
map.put("type", "标贯");
|
map.put("typeName", "标贯");
|
}
|
map.put("code", test.getRecordNo());
|
map.put("begin", test.getExpectDepthStart());
|
Double endDepth=0.0;
|
if(test.getThirdDepthEnd()!=null&&!test.getThirdDepthEnd().equals("")) {
|
endDepth=test.getThirdDepthEnd();
|
}
|
else if(test.getSecondDepthEnd()!=null&&!test.getSecondDepthEnd().equals("")) {
|
endDepth=test.getSecondDepthEnd();
|
}
|
else if(test.getFirstDepthEnd()!=null&&!test.getFirstDepthEnd().equals("")) {
|
endDepth=test.getFirstDepthEnd();
|
}
|
else if(test.getExpectDepthEnd()!=null&&!test.getExpectDepthEnd().equals("")) {
|
endDepth=test.getExpectDepthEnd();
|
}
|
map.put("end", endDepth);
|
map.put("medias",new String[0]);
|
String title="";
|
|
if(test.getPipeLenth()!=null&&!test.getPipeLenth().equals("")) {
|
title+="钻杆长度："+test.getPipeLenth()+";";
|
}
|
if(test.getExpectDepthStart()!=null&&!test.getExpectDepthStart().equals("")&&test.getExpectHammerTimes()!=null&&!test.getExpectHammerTimes().equals("")&&test.getExpectHammerTimes()!=0) {
|
title+="<br/>预："+test.getExpectDepthStart()+"m~"+test.getExpectDepthEnd()+"m="+test.getExpectHammerTimes()+";";
|
}
|
if(test.getFirstDepthStart()!=null&&!test.getFirstDepthStart().equals("")&&test.getFirstHammerTimes()!=null&&!test.getFirstHammerTimes().equals("")&&test.getFirstHammerTimes()!=0) {
|
title+="<br/>1："+test.getFirstDepthStart()+"m~"+test.getFirstDepthEnd()+"m="+test.getFirstHammerTimes()+";";
|
}
|
if(test.getSecondDepthStart()!=null&&!test.getSecondDepthStart().equals("")&&test.getSecondHammerTimes()!=null&&!test.getSecondHammerTimes().equals("")&&test.getSecondHammerTimes()!=0) {
|
title+="<br/>2："+test.getSecondDepthStart()+"m~"+test.getSecondDepthEnd()+"m="+test.getSecondHammerTimes()+";";
|
}
|
if(test.getThirdDepthStart()!=null&&!test.getThirdDepthStart().equals("")&&test.getThirdHammerTimes()!=null&&!test.getThirdHammerTimes().equals("")&&test.getThirdHammerTimes()!=0) {
|
title+="<br/>3："+test.getThirdDepthStart()+"m~"+test.getThirdDepthEnd()+"m="+test.getThirdHammerTimes()+";";
|
}
|
map.put("title", title);
|
mapList.add(map);
|
}
|
}
|
return mapList;
|
}
|
|
@Autowired
|
private LayerInfoMapper LayerInfoMapper;
|
|
@PostMapping("/insertDepth")
|
@ResponseBody
|
public void insertDepth() throws Exception {
|
HoleInfo holeInfo=new HoleInfo();
|
|
List<HoleInfo> holeList=holeInfoService.selectHoleInfoList(holeInfo);
|
LayerInfo layerInfo=null;
|
for(HoleInfo hole:holeList) {
|
try {
|
layerInfo=new LayerInfo();
|
|
layerInfo.setHoleNo(hole.getId());
|
Double max =LayerInfoMapper.findMaxHoleDepth(layerInfo);
|
|
hole.setHoleDepth(max);
|
|
holeInfoService.updateHoleInfo(hole);
|
}
|
catch(Exception e) {
|
System.out.print(e);
|
}
|
}
|
}
|
|
|
@RequestMapping(value = "isTokenValid")
|
@ResponseBody
|
public Boolean isTokenValid(String userId,HttpServletRequest request) {
|
String token =request.getParameter("token");
|
if(token!=null && UserAuthCacheUtils.userCaches.containsKey(token)){
|
FrontUser user = (FrontUser) UserAuthCacheUtils.getCahce(token);
|
if(user.getUserName().equals(userId)){
|
return true;
|
}
|
else {
|
return false;
|
}
|
}
|
return false;
|
}
|
|
|
@Autowired
|
private UserMsgMapper UserMsgMapper;
|
|
/**
|
* 消息列表
|
* @param userid
|
* @param request
|
* @return
|
*/
|
@UserAuth("frontUser")
|
@PostMapping("/userMsgList")
|
@ResponseBody
|
public List<UserMsg> userMsgList(String userid,HttpServletRequest request)
|
{
|
String token =request.getParameter("token");
|
if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
|
return null;
|
}
|
FrontUser user = (FrontUser) UserAuthCacheUtils.getCahce(token);
|
if(!user.getUserName().equals(userid)){
|
return null;
|
}
|
UserMsg userMsg=new UserMsg();
|
userMsg.setUserName(userid);
|
List<UserMsg> msgs= UserMsgMapper.selectUserMsgList(userMsg) ;
|
return msgs;
|
|
}
|
|
|
@Autowired
|
private HydrologyHoleInfoMapper hydrologyHoleInfoMapper;
|
|
|
/**
|
* 水位数据列表
|
* @param userid
|
* @param request
|
* @return
|
*/
|
//@UserAuth("frontUser")
|
@PostMapping("/hydrologyList")
|
@ResponseBody
|
public List<HydrologyHoleInfo> hydrologyList(String userid,HttpServletRequest request)
|
{
|
List<HydrologyHoleInfo> list = hydrologyHoleInfoMapper.selectSpecificFiledList(new HydrologyHoleInfo());
|
return list;
|
|
}
|
|
@Autowired
|
private HydrologyHoleInfoServiceImpl hydrologyHoleInfoServiceImpl;
|
|
/**
|
*地下水 折线图
|
* @param userid
|
* @param holeNum
|
* @param request
|
* @return
|
*/
|
@PostMapping("/hydrologyChart")
|
@ResponseBody
|
public AjaxResult hydrologyChart(String userid,String holeNum ,HttpServletRequest request)
|
{
|
AjaxResult result = hydrologyHoleInfoServiceImpl.hydrologyChart(holeNum);
|
|
return result;
|
}
|
|
|
/**
|
* 圆形查询
|
* @param lat
|
* @param lng
|
* @param radius
|
* @return
|
*/
|
@PostMapping("/cicleQueryDxs")
|
@ResponseBody
|
public List<HydrologyHoleInfo> cicleQueryDxs(Double lat,Double lng,Double radius) {
|
List<HydrologyHoleInfo> list = hydrologyHoleInfoMapper.selectByCircle(lat, lng, radius);
|
return list;
|
}
|
}
|
