package com.javaweb.geotdp.service.impl;
|
|
import cn.hutool.core.util.ObjectUtil;
|
import com.javaweb.common.exception.BusinessException;
|
import com.javaweb.common.json.JSON;
|
import com.javaweb.common.utils.DateUtils;
|
import com.javaweb.common.utils.IdGenerate;
|
import com.javaweb.common.utils.NumberUtils;
|
import com.javaweb.common.utils.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import com.javaweb.geo.domain.*;
|
import com.javaweb.geo.mapper.*;
|
import com.javaweb.geo.service.IDataSourceService;
|
import com.javaweb.geo.service.IHandleExceptionService;
|
import com.javaweb.geo.utils.ExceptionDistanceUtils;
|
import com.javaweb.geo.utils.ExceptionTimeUtils;
|
import com.javaweb.geo.vo.ExceptionDistanceVo;
|
import com.javaweb.geo.vo.ExceptionTimeVo;
|
import com.javaweb.geotdp.vo.*;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.ObjectUtils;
|
import org.springframework.web.bind.annotation.RequestParam;
|
import org.yaml.snakeyaml.constructor.BaseConstructor;
|
|
import com.javaweb.geotdp.domain.ResponseResult;
|
import com.javaweb.geotdp.enums.RecordType;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.json.JSONObject;
|
import cn.hutool.json.JSONUtil;
|
|
/**
|
* 项目Service业务层处理
|
*
|
* @author zmk
|
* @date 2022-10-14
|
*/
|
@Service
|
public class GeoDataServiceImpl extends BaseConstructor {
|
|
@Autowired
|
private CompanyMapper companyMapper;
|
|
@Autowired
|
private CompanyUserMapper companyUserMapper;
|
|
@Autowired
|
private ProjectMapper projectMapper;
|
|
@Autowired
|
private HoleMapper holeMapper;
|
|
@Autowired
|
private HoleHuiciMapper holeHuiciMapper;
|
|
@Autowired
|
private HoleYantuMapper holeYantuMapper;
|
|
@Autowired
|
private HoleQutuMapper holeQutuMapper;
|
|
@Autowired
|
private HoleBiaoguanMapper holeBiaoguanMapper;
|
|
@Autowired
|
private HoleShuiweiMapper holeShuiweiMapper;
|
|
@Autowired
|
private HolePersonMapper holePersonMapper;
|
|
@Autowired
|
private HoleMediaMapper holeMediaMapper;
|
|
@Autowired
|
private LaborUnitMapper laborUnitMapper;
|
|
@Autowired
|
private HandleExceptionMapper handleExceptionMapper;
|
|
@Autowired
|
private ExceptionConfigMapper exceptionConfigMapper;
|
|
@Autowired
|
private CollectStatisticsMapper statisticsMapper;
|
|
@Autowired
|
private HandleOpinionMapper handleOpinionMapper;
|
|
@Autowired
|
private IDataSourceService dataSourceService;
|
|
@Autowired
|
private IHandleExceptionService handleExceptionService;
|
|
/**
|
* 上传公司信息
|
*
|
* @return
|
* @throws Exception
|
*/
|
public ResponseResult uploadCompany(CompanyVo companyVo) throws Exception {
|
|
String secretKey = companyVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
//此处需要根据秘钥判断
|
String datasourceStr = dataSourceService.selectDataSourceBySecretKey(secretKey);
|
if (StringUtils.isEmpty(datasourceStr)){
|
companyVo.setDatasource("-1");
|
}else {
|
companyVo.setDatasource(datasourceStr);
|
}
|
|
Company company = new Company();
|
BeanUtil.copyProperties(companyVo, company);
|
String companyId = IdGenerate.nextId();
|
|
// =========================新增、更新==============================
|
if (StringUtils.isEmpty(companyVo.getIds())) {
|
company.setIds(companyId);
|
companyVo.setIds(companyId);
|
companyMapper.insertCompany(company);
|
|
// 更新dataSource表中的数据
|
dataSourceService.updateDataSourceBySecretKey(secretKey , companyId);
|
} else {
|
companyMapper.updateCompany(company);
|
}
|
|
return ResponseResult.success("公司信息上传成功", JSON.marshal(companyVo));
|
}
|
|
/**
|
* 上传人员
|
*
|
* @return
|
* @throws Exception
|
*/
|
public ResponseResult uploadUser(CompanyUserVo companyUserVo) throws Exception {
|
|
String secretKey = companyUserVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在！");
|
}
|
|
CompanyUser companyUser = new CompanyUser();
|
BeanUtil.copyProperties(companyUserVo, companyUser);
|
companyUser.setCompanyId(companyUserVo.getCompanyID());
|
String userIds = companyUser.getIds();
|
|
// 新增
|
if (StringUtils.isEmpty(userIds)){
|
String id = IdGenerate.nextId();
|
companyUser.setIds(id);
|
companyUserVo.setIds(id);
|
companyUserMapper.insertCompanyUser(companyUser);
|
return ResponseResult.success("人员上传成功", JSON.marshal(companyUserVo));
|
}else {
|
|
// ==========================校验数据==========================
|
Company company = companyMapper.selectCompanyById(companyUserVo.getCompanyID());
|
if (ObjectUtils.isEmpty(company)){
|
return ResponseResult.error("人员更新失败，公司不存在！！");
|
}
|
CompanyUser companyUser1 = companyUserMapper.selectCompanyUserById(userIds);
|
if (ObjectUtils.isEmpty(companyUser1)){
|
return ResponseResult.error("人员更新失败，人员不存在！！");
|
}
|
companyUserMapper.updateCompanyUser(companyUser);
|
return ResponseResult.success("人员更新成功", JSON.marshal(companyUserVo));
|
}
|
}
|
|
/**
|
* 上传项目
|
*
|
* @param projectVo
|
* @return
|
* @throws Exception
|
*/
|
|
public ResponseResult uploadProject(ProjectVo projectVo) throws Exception {
|
String secretKey = projectVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
// 项目序列号（保存时选填（如果提供则必须保证唯一，不填则由服务端生成），更新时必填）
|
String serialNumber = projectVo.getSerialNumber();
|
String companyId = projectVo.getCompanyID();
|
//==============================如果为空则为保存操作，服务端生成序列号==========================
|
if (StringUtils.isEmpty(serialNumber)) {
|
String num = IdGenerate.nextId();
|
|
projectVo.setSerialNumber(num);
|
projectVo.setIds(IdGenerate.nextId());
|
saveProject(projectVo);
|
return ResponseResult.success("项目上传成功", JSON.marshal(projectVo));
|
}else {
|
|
//=============================如果不为空，还需要进一步判断===========================
|
Project query = new Project();
|
query.setCompanyId(companyId);
|
query.setSerialNumber(serialNumber);
|
List<Project> list = projectMapper.selectProjectList(query);
|
// 如果查询不到序列号，则为新增，服务端生成序列号
|
if (StringUtils.isEmpty(list)) {
|
projectVo.setIds(IdGenerate.nextId());
|
saveProject(projectVo);
|
return ResponseResult.success("项目上传成功", JSON.marshal(projectVo));
|
|
} else {
|
// 查询到序列号，则为更新
|
Project project = list.get(0);
|
Project updateProject = new Project();
|
BeanUtil.copyProperties(projectVo, updateProject);
|
updateProject.setIds(project.getIds());
|
projectVo.setIds(project.getIds());
|
projectMapper.updateProject(updateProject);
|
return ResponseResult.success("项目更新成功", JSON.marshal(projectVo));
|
}
|
}
|
|
|
}
|
|
//保存项目
|
private Project saveProject(ProjectVo projectVo) {
|
|
Project project = new Project();
|
BeanUtil.copyProperties(projectVo, project);
|
project.setCompanyId(projectVo.getCompanyID());
|
|
String secretKey = projectVo.getSecretKey();
|
String dataSource = dataSourceService.selectDataSourceBySecretKey(secretKey);
|
project.setDataSource(dataSource);
|
|
projectMapper.insertProject(project);
|
return project;
|
}
|
|
/**
|
* 上传勘探点数据接口
|
*/
|
public ResponseResult uploadHole(HoleVo holeVo) {
|
String secretKey = holeVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
try {
|
holeVo = convertBean(holeVo);
|
} catch (Exception e) {
|
return ResponseResult.error("数据上传异常：" + e.toString());
|
}
|
|
try {
|
Boolean resultFlag = insertHoleData(holeVo);
|
if (!resultFlag) {
|
return ResponseResult.error("验收完成的项目以及废孔状态的勘探点，均不再接收后续数据的上传。");
|
}
|
} catch (Exception e) {
|
return ResponseResult.error("数据入库异常：" + e.toString());
|
}
|
return ResponseResult.success("上传成功");
|
}
|
|
/**
|
* 插入钻孔数据
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
Boolean insertHoleData(HoleVo holeVo) {
|
|
//根据项目序列号查找唯一的项目
|
Project project = projectMapper.selectProjectBySerialNumber(holeVo.getProjectID());
|
|
// 1、验收完成的项目不再接收后续数据的上传。
|
if (ObjectUtil.isEmpty(project)) {
|
throw new BusinessException("序列号未查找到项目");
|
}
|
if (project.getStatus().equals(RecordType.projectStatus1.getId())) {
|
return false;
|
}
|
|
// 项目的主键id 在业务表中做关联存储使用
|
String projectId = project.getIds();
|
Hole hole = holeMapper.selectHoleBySerNum(projectId, holeVo.getCode());
|
String holeId = IdGenerate.nextId();
|
// 2、废孔状态的勘探点不再接收后续数据的上传。
|
if (ObjectUtil.isNotEmpty(hole) && RecordType.holeStatus3.getId().equals(hole.getStatus())) {
|
return false;
|
}
|
boolean exsitHole = false;
|
if (ObjectUtil.isNotEmpty(hole)) {
|
exsitHole = true;
|
holeId = hole.getIds();
|
}
|
|
// 拷贝属性
|
Hole holeEntity = new Hole();
|
BeanUtil.copyProperties(holeVo, holeEntity);
|
holeEntity.setIds(holeId);
|
holeEntity.setProjectId(projectId);
|
holeEntity.setIsFlag(RecordType.isFlag0.getId());
|
|
List<HoleHuici> holeHuicis = new ArrayList<>();
|
List<HoleYantu> holeYantus = new ArrayList<>();
|
List<HoleQutu> holeQutus = new ArrayList<>();
|
List<HoleBiaoguan> holeBiaoguans = new ArrayList<>();
|
List<HoleShuiwei> holeShuiweis = new ArrayList<>();
|
List<HolePerson> holePersons = new ArrayList<>();
|
List<HoleMedia> holeMedias = new ArrayList<>();
|
|
HoleHuici holeHuici;
|
HoleYantu holeYantu;
|
HoleQutu holeQutu;
|
HoleBiaoguan holeBiaoguan;
|
HoleShuiwei holeShuiwei;
|
HolePerson holePerson;
|
|
//回次数据
|
List<RecordHCVo> recordHCVos = holeVo.getRecordHCVos();
|
for (RecordHCVo recordHCVo : recordHCVos) {
|
|
holeHuici = new HoleHuici();
|
BeanUtil.copyProperties(recordHCVo, holeHuici);
|
holeHuici.setProjectId(projectId);
|
holeHuici.setHoleId(holeId);
|
holeHuicis.add(holeHuici);
|
|
//媒体数据
|
List<MediaVo> mediaVos = recordHCVo.getMediaListStr();
|
if(!ObjectUtils.isEmpty(mediaVos)){
|
for (MediaVo mediaVo : mediaVos) {
|
HoleMedia holeMedia = new HoleMedia();
|
BeanUtil.copyProperties(mediaVo, holeMedia);
|
holeMedia.setIds(IdGenerate.nextId());
|
holeMedia.setRecordId(recordHCVo.getIds());
|
holeMedia.setProjectId(projectId);
|
holeMedias.add(holeMedia);
|
}
|
}
|
}
|
|
// 岩土
|
List<RecordYTVo> recordYTVos = holeVo.getRecordYTVos();
|
for (RecordYTVo recordYTVo : recordYTVos) {
|
holeYantu = new HoleYantu();
|
BeanUtil.copyProperties(recordYTVo, holeYantu);
|
holeYantu.setProjectId(projectId);
|
holeYantu.setHoleId(holeId);
|
holeYantu.setFrequencyType(recordYTVo.getLayerType());
|
holeYantu.setLayerName(recordYTVo.getLayerName());
|
holeYantus.add(holeYantu);
|
|
List<MediaVo> mediaVos = recordYTVo.getMediaListStr();
|
if(!ObjectUtils.isEmpty(mediaVos)){
|
for (MediaVo mediaVo : mediaVos) {
|
HoleMedia holeMedia = new HoleMedia();
|
BeanUtil.copyProperties(mediaVo, holeMedia);
|
holeMedia.setIds(IdGenerate.nextId());
|
holeMedia.setRecordId(recordYTVo.getIds());
|
holeMedia.setProjectId(projectId);
|
holeMedias.add(holeMedia);
|
}
|
}
|
}
|
|
//取土数据
|
List<RecordQTVo> recordQTVos = holeVo.getRecordQTVos();
|
for (RecordQTVo recordQTVo : recordQTVos) {
|
holeQutu = new HoleQutu();
|
|
BeanUtil.copyProperties(recordQTVo, holeQutu);
|
holeQutu.setProjectId(projectId);
|
holeQutu.setHoleId(holeId);
|
holeQutus.add(holeQutu);
|
|
List<MediaVo> mediaVos = recordQTVo.getMediaListStr();
|
if(!ObjectUtils.isEmpty(mediaVos)){
|
for (MediaVo mediaVo : mediaVos) {
|
HoleMedia holeMedia = new HoleMedia();
|
BeanUtil.copyProperties(mediaVo, holeMedia);
|
holeMedia.setIds(IdGenerate.nextId());
|
holeMedia.setRecordId(recordQTVo.getIds());
|
holeMedia.setProjectId(projectId);
|
holeMedias.add(holeMedia);
|
}
|
}
|
|
|
}
|
|
//标贯+ 动探
|
List<RecordYWVo> recordYWVos = holeVo.getRecordYWVos();
|
for (RecordYWVo recordYWVo : recordYWVos) {
|
|
holeBiaoguan = new HoleBiaoguan();
|
BeanUtil.copyProperties(recordYWVo, holeBiaoguan);
|
holeBiaoguan.setProjectId(projectId);
|
holeBiaoguan.setHoleId(holeId);
|
holeBiaoguans.add(holeBiaoguan);
|
|
List<MediaVo> mediaVos = recordYWVo.getMediaListStr();
|
if(!ObjectUtils.isEmpty(mediaVos)){
|
for (MediaVo mediaVo : mediaVos) {
|
HoleMedia holeMedia = new HoleMedia();
|
BeanUtil.copyProperties(mediaVo, holeMedia);
|
holeMedia.setIds(IdGenerate.nextId());
|
holeMedia.setRecordId(recordYWVo.getIds());
|
holeMedia.setProjectId(projectId);
|
holeMedias.add(holeMedia);
|
}
|
}
|
|
|
}
|
|
//水位
|
List<RecordSWVo> recordSWVos = holeVo.getRecordSWVos();
|
for (RecordSWVo recordSWVo : recordSWVos) {
|
|
holeShuiwei = new HoleShuiwei();
|
BeanUtil.copyProperties(recordSWVo, holeShuiwei);
|
holeShuiwei.setProjectId(projectId);
|
holeShuiwei.setHoleId(holeId);
|
holeShuiweis.add(holeShuiwei);
|
|
List<MediaVo> mediaVos = recordSWVo.getMediaListStr();
|
if(!ObjectUtils.isEmpty(mediaVos)){
|
for (MediaVo mediaVo : mediaVos) {
|
HoleMedia holeMedia = new HoleMedia();
|
BeanUtil.copyProperties(mediaVo, holeMedia);
|
holeMedia.setIds(IdGenerate.nextId());
|
holeMedia.setRecordId(recordSWVo.getIds());
|
holeMedia.setProjectId(projectId);
|
holeMedias.add(holeMedia);
|
}
|
}
|
|
|
}
|
|
// 负责人 + 工程师 + 机长 + 钻机
|
List<RecordPersonVo> recordPersonVos = holeVo.getPersonVos();
|
for (RecordPersonVo recordPersonVo : recordPersonVos) {
|
|
holePerson = new HolePerson();
|
BeanUtil.copyProperties(recordPersonVo, holePerson);
|
holePerson.setProjectId(projectId);
|
holePerson.setHoleId(holeId);
|
holePersons.add(holePerson);
|
|
List<MediaVo> mediaVos = recordPersonVo.getMediaListStr();
|
if(!ObjectUtils.isEmpty(mediaVos)){
|
for (MediaVo mediaVo : mediaVos) {
|
HoleMedia holeMedia = new HoleMedia();
|
BeanUtil.copyProperties(mediaVo, holeMedia);
|
holeMedia.setIds(IdGenerate.nextId());
|
holeMedia.setRecordId(recordPersonVo.getIds());
|
holeMedia.setProjectId(projectId);
|
holeMedias.add(holeMedia);
|
}
|
}
|
}
|
|
// 插入数据
|
insertHole(holeEntity, exsitHole);
|
insertHuici(holeHuicis);
|
insertYantu(holeYantus);
|
insertQutu(holeQutus);
|
insertBiaoguan(holeBiaoguans);
|
insertShuiwei(holeShuiweis);
|
insertPersons(holePersons);
|
insertMedia(holeMedias);
|
|
// 删除历史数据
|
List<DeletedVo> deletedVos = holeVo.getDeletedVos();
|
deleteHistory(deletedVos);
|
return true;
|
}
|
|
|
|
private void deleteHistory(List<DeletedVo> deletedVos){
|
String[] ids = deletedVos.stream().map(DeletedVo::getIds).toArray(String[]::new);
|
|
if (!ObjectUtils.isEmpty(ids)){
|
holeHuiciMapper.deleteHoleHuiciByIds(ids);
|
holeYantuMapper.deleteHoleYantuByIds(ids);
|
holeQutuMapper.deleteHoleQutuByIds(ids);
|
holeQutuMapper.deleteHoleQutuByIds(ids);
|
holeBiaoguanMapper.deleteHoleBiaoguanByIds(ids);
|
holeShuiweiMapper.deleteHoleShuiweiByIds(ids);
|
holePersonMapper.deleteHolePersonByIds(ids);
|
}
|
}
|
|
//插入钻孔
|
@Transactional(rollbackFor = Exception.class)
|
void insertHole(Hole hole, boolean isExist) {
|
if (isExist) {
|
holeMapper.updateHole(hole);
|
} else {
|
holeMapper.insertHole(hole);
|
}
|
}
|
|
//插入回次数据
|
@Transactional(rollbackFor = Exception.class)
|
void insertHuici(List<HoleHuici> holeHuicis) {
|
if (!ObjectUtils.isEmpty(holeHuicis)){
|
String[] ids = holeHuicis.stream().map(HoleHuici::getIds).toArray(String[]::new);
|
holeHuiciMapper.deleteHoleHuiciByIds(ids);
|
holeHuiciMapper.insertHoleHuiciList(holeHuicis);
|
}
|
}
|
|
//插入岩土数据
|
@Transactional(rollbackFor = Exception.class)
|
void insertYantu(List<HoleYantu> holeYantus) {
|
if (!ObjectUtils.isEmpty(holeYantus)){
|
String[] ids = holeYantus.stream().map(HoleYantu::getIds).toArray(String[]::new);
|
holeYantuMapper.deleteHoleYantuByIds(ids);
|
holeYantuMapper.insertHoleYantuList(holeYantus);
|
}
|
}
|
|
|
//插入取土数据
|
@Transactional(rollbackFor = Exception.class)
|
void insertQutu(List<HoleQutu> holeQutus) {
|
if (!ObjectUtils.isEmpty(holeQutus)){
|
String[] ids = holeQutus.stream().map(HoleQutu::getIds).toArray(String[]::new);
|
holeQutuMapper.deleteHoleQutuByIds(ids);
|
holeQutuMapper.insertHoleQutuList(holeQutus);
|
}
|
}
|
|
//插入标贯数据
|
@Transactional(rollbackFor = Exception.class)
|
void insertBiaoguan(List<HoleBiaoguan> holeBiaoguans) {
|
if (!ObjectUtils.isEmpty(holeBiaoguans)){
|
String[] ids = holeBiaoguans.stream().map(HoleBiaoguan::getIds).toArray(String[]::new);
|
holeBiaoguanMapper.deleteHoleBiaoguanByIds(ids);
|
holeBiaoguanMapper.insertHoleBiaoguanList(holeBiaoguans);
|
}
|
}
|
|
//插入水位数据
|
@Transactional(rollbackFor = Exception.class)
|
void insertShuiwei(List<HoleShuiwei> holeShuiweis) {
|
if (!ObjectUtils.isEmpty(holeShuiweis)){
|
String[] ids = holeShuiweis.stream().map(HoleShuiwei::getIds).toArray(String[]::new);
|
holeShuiweiMapper.deleteHoleShuiweiByIds(ids);
|
holeShuiweiMapper.insertHoleShuiweiList(holeShuiweis);
|
}
|
}
|
|
//插入人员
|
@Transactional(rollbackFor = Exception.class)
|
void insertPersons(List<HolePerson> holePersons) {
|
if (!ObjectUtils.isEmpty(holePersons)){
|
String[] ids = holePersons.stream().map(HolePerson::getIds).toArray(String[]::new);
|
holePersonMapper.deleteHolePersonByIds(ids);
|
holePersonMapper.insertHolePersonList(holePersons);
|
}
|
}
|
|
//插入媒体数据
|
@Transactional(rollbackFor = Exception.class)
|
void insertMedia(List<HoleMedia> holeMedias) {
|
for (HoleMedia holeMedia : holeMedias) {
|
holeMediaMapper.deleteHoleMediaByRecordId(holeMedia.getRecordId());
|
holeMediaMapper.insertHoleMedia(holeMedia);
|
}
|
}
|
|
/**
|
* 转化数据
|
*/
|
HoleVo convertBean(HoleVo holeVo) {
|
|
List<Object> recordList = holeVo.getRecordListStr();
|
|
List<RecordHCVo> recordHCVos = new ArrayList<>();
|
List<RecordYTVo> recordYTVos = new ArrayList<>();
|
List<RecordQTVo> recordQTVos = new ArrayList<>();
|
List<RecordYWVo> recordYWVos = new ArrayList<>();
|
List<RecordSWVo> recordSWVos = new ArrayList<>();
|
List<DeletedVo> deletedVos = new ArrayList<>();
|
List<RecordPersonVo> recordPersonVos = new ArrayList<>();
|
|
|
for (Object object : recordList) {
|
JSONObject jsonObject = JSONUtil.parseObj(object);
|
// 根据类型判断，转为什么 实体类
|
String type = jsonObject.getStr("type");
|
|
|
// =========================== 处理isDeleted==true 的对象 ===========================
|
if (StringUtils.isEmpty(type)){
|
DeletedVo deletedVo = JSONUtil.toBean(jsonObject, DeletedVo.class);
|
if (deletedVo.getIsDelete()){
|
deletedVos.add(deletedVo);
|
}
|
continue;
|
}
|
// =========================== 回次 ===========================
|
if (RecordType.hc.getName().equals(type)) {
|
RecordHCVo recordHCVo = JSONUtil.toBean(jsonObject, RecordHCVo.class);
|
recordHCVos.add(recordHCVo);
|
// =========================== 岩土 ===========================
|
} else if (RecordType.yt.getName().equals(type)) {
|
RecordYTVo recordYTVo = JSONUtil.toBean(jsonObject, RecordYTVo.class);
|
recordYTVos.add(recordYTVo);
|
// =========================== 取土 ===========================
|
} else if (RecordType.qt.getName().equals(type)) {
|
RecordQTVo recordQTVo = JSONUtil.toBean(jsonObject, RecordQTVo.class);
|
recordQTVos.add(recordQTVo);
|
// =========================== 标贯 + 动探 ===========================
|
} else if (RecordType.bg.getName().equals(type) || RecordType.dt.getName().equals(type)) {
|
RecordYWVo recordYWVo = JSONUtil.toBean(jsonObject, RecordYWVo.class);
|
recordYWVo.setType(type);
|
recordYWVos.add(recordYWVo);
|
// =========================== 水位 + 取水 ===========================
|
} else if (RecordType.sw.getName().equals(type) || RecordType.qs.getName().equals(type)) {
|
RecordSWVo recordSWVo = JSONUtil.toBean(jsonObject, RecordSWVo.class);
|
recordSWVo.setType(type);
|
recordSWVos.add(recordSWVo);
|
// =========================== 负责人 + 工程师 + 机长 + 钻机 + 描述员 + 备注 + 场景 + 提钻录像 ===========================
|
} else if (RecordType.fzr.getName().equals(type) || RecordType.gcs.getName().equals(type)
|
|| RecordType.jz.getName().equals(type) || RecordType.zj.getName().equals(type)
|
|| RecordType.msy.getName().equals(type)|| RecordType.beizhu.getName().equals(type)
|
|| RecordType.changjing.getName().equals(type)|| RecordType.tizuanluxiang.getName().equals(type)) {
|
RecordPersonVo recordPersonVo = JSONUtil.toBean(jsonObject, RecordPersonVo.class);
|
recordPersonVo.setType(type);
|
recordPersonVos.add(recordPersonVo);
|
}
|
|
}
|
holeVo.setRecordHCVos(recordHCVos);
|
holeVo.setRecordQTVos(recordQTVos);
|
holeVo.setRecordSWVos(recordSWVos);
|
holeVo.setRecordYTVos(recordYTVos);
|
holeVo.setRecordYWVos(recordYWVos);
|
holeVo.setPersonVos(recordPersonVos);
|
holeVo.setDeletedVos(deletedVos);
|
return holeVo;
|
}
|
|
/**
|
* 项目验收接口
|
*
|
* @param projectCheckVo
|
* @return
|
*/
|
public ResponseResult checkComplete(ProjectCheckVo projectCheckVo) {
|
|
String secretKey = projectCheckVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
if (StringUtils.isNotEmpty(projectCheckVo.getUserID())) {
|
if (!checkUserIdAndUserName(projectCheckVo.getUserID(), projectCheckVo.getUserName())) {
|
return ResponseResult.error("需和userName对应的ids保持一致!");
|
}
|
}
|
|
Project project = projectMapper.selectProjectBySerialNumber(projectCheckVo.getProjectID());
|
if (ObjectUtil.isNotEmpty(project)) {
|
project.setStatus(RecordType.projectStatus1.getId());
|
if (projectMapper.updateProject(project) > 0) {
|
return ResponseResult.success("项目验收完成");
|
}
|
}
|
return ResponseResult.error("项目验收错误！");
|
}
|
|
/**
|
* 项目验收状态变更接口
|
*
|
* @return
|
*/
|
public ResponseResult updateStatus(ProjectCheckVo projectCheckVo) {
|
String secretKey = projectCheckVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
if (StringUtils.isNotEmpty(projectCheckVo.getUserID())) {
|
if (!checkUserIdAndUserName(projectCheckVo.getUserID(), projectCheckVo.getUserName())) {
|
return ResponseResult.error("需和userName对应的ids保持一致!");
|
}
|
}
|
|
Project project = projectMapper.selectProjectBySerialNumber(projectCheckVo.getProjectID());
|
if (ObjectUtil.isNotEmpty(project)) {
|
project.setStatus(RecordType.projectStatus0.getId());
|
project.setEndTime(DateUtils.getNowDate());
|
project.setStatusChangeUser(projectCheckVo.getUserName());
|
project.setStatusChangeReason(projectCheckVo.getReason());
|
|
if (projectMapper.updateProject(project) > 0) {
|
return ResponseResult.success("项目验收状态变更成功");
|
}
|
}
|
return ResponseResult.error("项目验收状态变更错误！");
|
}
|
|
|
/**
|
* 删除项目接口
|
*
|
* @return
|
*/
|
public ResponseResult deleteProject(ProjectCheckVo projectCheckVo) {
|
|
if (StringUtils.isEmpty(projectCheckVo.getSecretKey()) || StringUtils.isEmpty(projectCheckVo.getSerialNumber())) {
|
return ResponseResult.error("参数错误！");
|
}
|
|
String secretKey = projectCheckVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
String serialNumber = projectCheckVo.getSerialNumber();
|
|
Project project = projectMapper.selectProjectBySerialNumber(serialNumber);
|
if (ObjectUtil.isNotEmpty(project)) {
|
project.setIsDeleted(RecordType.isDelete1.getId());
|
if (projectMapper.updateProject(project) > 0) {
|
return ResponseResult.success("项目删除成功");
|
}
|
}
|
return ResponseResult.error("项目删除失败！");
|
}
|
|
/**
|
* 勘探点状态变更接口
|
*
|
* @return
|
*/
|
public ResponseResult holeUpdateStatus(HoleVo holeVo) {
|
String secretKey = holeVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
String projectID = holeVo.getProjectID();
|
String code = holeVo.getCode();
|
String status = holeVo.getCheckStatus();
|
if (StringUtils.isEmpty(projectID) || StringUtils.isEmpty(code) || StringUtils.isEmpty(status)) {
|
return ResponseResult.error("参数错误！");
|
}
|
|
Hole hole = holeMapper.selectHoleBySerNum(projectID, code);
|
if (ObjectUtil.isNotEmpty(hole)) {
|
if (hole.getStatus().equals(RecordType.holeStatus3.getId())) {
|
return ResponseResult.error("废孔状态的勘探点不能再次修改其状态，请谨慎调用废孔功能。");
|
}
|
hole.setStatus(holeVo.getStatus());
|
if (holeMapper.updateHole(hole) > 0) {
|
return ResponseResult.success("成功修改勘探点状态！");
|
}
|
}
|
return ResponseResult.error("修改勘探点状态失败！");
|
}
|
|
/**
|
* 获取劳务单位接口
|
*
|
* @return
|
*/
|
public ResponseResult getLaborList(LaborUnitVo laborUnitVo) throws Exception {
|
String secretKey = laborUnitVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
List<LaborUnit> laborUnits = laborUnitMapper.selectLaborUnitList(new LaborUnit());
|
return ResponseResult.success("获取劳务单位列表成功", JSON.marshal(laborUnits));
|
}
|
|
|
/**
|
* 获取三员信息接口
|
*/
|
public ResponseResult getPeopleDetail(PeopleDetailVo peopleDetailVo) throws Exception {
|
|
String secretKey = peopleDetailVo.getSecretKey();
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
PeopleDetail peopleDetail;
|
String companyId = dataSourceService.selectCompanyIdBySecretKey(secretKey);
|
String paper = peopleDetailVo.getPaper();
|
|
//查询certificate_number3，描述员证书号码（描述员角色建议填写）
|
List<CompanyUser> companyUser3List = companyUserMapper.selectCompanyUserBypaper3(paper,companyId);
|
if (!ObjectUtils.isEmpty(companyUser3List)){
|
peopleDetail = getPeopleDetail(companyUser3List.get(0));
|
peopleDetail.setState(Integer.valueOf(RecordType.peopleDetail1.getId()));
|
peopleDetail.setType(Integer.valueOf(RecordType.peopleDetail1.getId()));
|
return ResponseResult.success("获取三元信息成功", JSON.marshal(peopleDetail));
|
}
|
|
//查询certificate_number4，司钻员证书号码（司钻员角色建议填写）
|
List<CompanyUser> companyUser4List = companyUserMapper.selectCompanyUserBypaper4(paper,companyId);
|
if (!ObjectUtils.isEmpty(companyUser4List)){
|
peopleDetail = getPeopleDetail(companyUser4List.get(0));
|
peopleDetail.setState(Integer.valueOf(RecordType.peopleDetail2.getId()));
|
peopleDetail.setType(Integer.valueOf(RecordType.peopleDetail2.getId()));
|
return ResponseResult.success("获取三元信息成功", JSON.marshal(peopleDetail));
|
}
|
|
return ResponseResult.error("查无此人");
|
}
|
|
/**
|
* 转化数据对象
|
*/
|
private PeopleDetail getPeopleDetail(CompanyUser data){
|
PeopleDetail result = new PeopleDetail();
|
|
String companyName = "";
|
Company company = companyMapper.selectCompanyById(data.getCompanyId());
|
if (!ObjectUtils.isEmpty(company)){
|
companyName = company.getFullName();
|
}
|
|
result.setCardID(data.getIdCard());
|
result.setCompany(companyName);
|
result.setIds(data.getIds());
|
result.setName(data.getRealName());
|
result.setRemark(data.getRemark());
|
result.setUpdateTime(data.getUpdateTime());
|
return result;
|
}
|
|
|
private Boolean checkUserIdAndUserName(String userID, String userName) {
|
Boolean flag = false;
|
|
CompanyUser companyUser = companyUserMapper.selectCompanyUserById(userID);
|
if (ObjectUtil.isNotEmpty(companyUser) && userName.equals(companyUser.getRealName())) {
|
flag = true;
|
}
|
return flag;
|
}
|
|
|
/**
|
* 扫描异常
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public void scanHandleException() {
|
|
List<HandleException> handleExceptions = new ArrayList<>();
|
|
// 获取异常配置表中的参数，只有一条数据
|
List<ExceptionConfig> configList = exceptionConfigMapper.selectExceptionConfigList(new ExceptionConfig());
|
ExceptionConfig configData = configList.get(0);
|
|
// 查询出Flag=0的钻孔记录，然后开始计算
|
List<Hole> holeList = holeMapper.selectHoleListByFlag0();
|
if (ObjectUtil.isNotEmpty(holeList)) {
|
for (Hole hole : holeList) {
|
Project project = projectMapper.selectProjectById(hole.getProjectId());
|
|
HandleException timeException = timeExceptionFun(hole, configData, project);
|
HandleException distanceException = distanceExceptionFun(hole, configData,project);
|
|
// HandleException persionException = personException(hole, configData);
|
|
if (ObjectUtil.isNotEmpty(timeException)) {
|
handleExceptions.add(timeException);
|
}
|
if (ObjectUtil.isNotEmpty(distanceException)) {
|
handleExceptions.add(distanceException);
|
}
|
// handleExceptions.add(persionException);
|
hole.setIsFlag(RecordType.isFlag1.getId());
|
holeMapper.updateHole(hole);
|
}
|
}
|
insertHandleException(handleExceptions);
|
}
|
|
/**
|
* TODO 人员异常
|
* 从业人员持证检查：是/否
|
* 在x小时内同时出现在两个以上项目
|
*/
|
private HandleException personException(Hole hole, ExceptionConfig configData) {
|
return null;
|
}
|
|
private void insertHandleException(List<HandleException> handleExceptions) {
|
if (ObjectUtil.isNotEmpty(handleExceptions)) {
|
for (HandleException item : handleExceptions) {
|
if (StringUtils.isNotEmpty(item.getIds())) {
|
handleExceptionMapper.insertHandleException(item);
|
} else {
|
handleExceptionMapper.updateHandleException(item);
|
}
|
}
|
}
|
}
|
|
/**
|
* 位置异常
|
* 距离基准点坐标大于x米
|
* 且同一钻孔下的异常记录占比不超过x%（轻微异常）
|
* 且同一钻孔下的异常记录占比不超过20-50%（一般异常）
|
* 且同一钻孔下的异常记录占比不超过x%或最大偏移值大于*米（严重异常）
|
*/
|
private HandleException distanceExceptionFun(Hole hole, ExceptionConfig configData, Project project) {
|
HandleException handleException = new HandleException();
|
|
String companyId = "";
|
if (ObjectUtil.isNotEmpty(project)) {
|
companyId = project.getCompanyId();
|
}
|
double addrDistance = Double.parseDouble(configData.getAddrDistance());
|
double addrNum1 = Double.parseDouble(configData.getAddrNum1());
|
double addrNum2 = Double.parseDouble(configData.getAddrNum2());
|
double addrMaxDistance = Double.parseDouble(configData.getAddrMaxDistance());
|
double count = 0, max = 0;
|
|
Double holeLon = hole.getLongitude();
|
Double holeLat = hole.getLatitude();
|
List<HoleBiaoguan> biaoguans = holeBiaoguanMapper.selectHoleBiaoguanByHoleId(hole.getIds());
|
//计算标贯
|
if (ObjectUtil.isNotEmpty(biaoguans)) {
|
for(HoleBiaoguan o : biaoguans){
|
double distance = ExceptionDistanceUtils.distance(holeLon,holeLat,o.getLongitude(),o.getLatitude());
|
if (distance > addrDistance){ count++;}
|
if (distance > max){ max = distance;}
|
}
|
}
|
|
|
List<HoleHuici> holeHuicis = holeHuiciMapper.selectHoleHuiciByHoleId(hole.getIds()); // [] null
|
if (ObjectUtil.isNotEmpty(holeHuicis)) {
|
for(HoleHuici o : holeHuicis){
|
double distance = ExceptionDistanceUtils.distance(holeLon,holeLat,o.getLongitude(),o.getLatitude());
|
if (distance > addrDistance){ count++;}
|
if (distance > max){ max = distance;}
|
}
|
}
|
|
|
List<HoleQutu> qutus = holeQutuMapper.selectHoleQutuByHoleId(hole.getIds());
|
if (ObjectUtil.isNotEmpty(qutus)) {
|
for(HoleQutu o : qutus){
|
double distance = ExceptionDistanceUtils.distance(holeLon,holeLat,o.getLongitude(),o.getLatitude());
|
if (distance > addrDistance){ count++;}
|
if (distance > max){ max = distance;}
|
}
|
}
|
|
|
List<HoleShuiwei> shuiweis = holeShuiweiMapper.selectHoleShuiWeiByHoleId(hole.getIds());
|
if (ObjectUtil.isNotEmpty(shuiweis)) {
|
for(HoleShuiwei o : shuiweis){
|
double distance = ExceptionDistanceUtils.distance(holeLon,holeLat,o.getLongitude(),o.getLatitude());
|
if (distance > addrDistance){ count++;}
|
if (distance > max){ max = distance;}
|
}
|
}
|
|
|
List<HoleYantu> yantuList = holeYantuMapper.selectHoleYantuListByHoleId(hole.getIds());
|
if (ObjectUtil.isNotEmpty(yantuList)) {
|
for(HoleYantu o : yantuList){
|
double distance = ExceptionDistanceUtils.distance(holeLon,holeLat,o.getLongitude(),o.getLatitude());
|
if (distance > addrDistance){ count++;}
|
if (distance > max){ max = distance;}
|
}
|
}
|
|
|
int size = biaoguans.size() + holeHuicis.size() + qutus.size() + shuiweis.size() + yantuList.size();
|
//如果钻孔下无数据
|
if (size == 0) {
|
setException(handleException, hole, companyId, "未查询到数据记录", RecordType.exceptionType3.getId());
|
return handleException;
|
}
|
|
double percent = count / size;
|
percent=NumberUtils.div(percent,1,4);
|
|
//如果百分比为0 不是异常数据
|
if (percent <= 0) {
|
return null;
|
}
|
|
String desc;
|
if (percent > 0 && percent < addrNum1) {
|
handleException.setLevel(RecordType.exceptionLevel1.getId());
|
} else if (percent > 0.2 && percent < 0.5) {
|
handleException.setLevel(RecordType.exceptionLevel2.getId());
|
} else if (percent > addrNum2) {
|
handleException.setLevel(RecordType.exceptionLevel3.getId());
|
}
|
desc = percent * 100 + "%" + "的记录距离基准点定位坐标的偏差超过" + addrDistance + "米";
|
|
if (max > addrMaxDistance) {
|
handleException.setLevel(RecordType.exceptionLevel3.getId());
|
desc = "最大距离基准点定位坐标的偏差超过" + addrDistance + "米";
|
}
|
setException(handleException, hole, companyId, desc, RecordType.exceptionType1.getId());
|
|
return handleException;
|
}
|
|
|
/**
|
* @param paramList 回次 标贯 取土 岩土等集合参数
|
* @param hole 钻孔
|
* @param count 计数器
|
* @param max 最大值计数器
|
* @param addrDistance 超标的距离参数
|
*/
|
|
private void jisuanDistanceFun(List<?> paramList, Hole hole, double count, double max, double addrDistance) {
|
|
if (ObjectUtil.isNotEmpty(paramList)) {
|
Double holeLon = hole.getLongitude();
|
Double holeLat = hole.getLatitude();
|
for (Object o : paramList) {
|
double distance = 0.0d;
|
if (o instanceof HoleBiaoguan) {
|
distance = ExceptionDistanceUtils.distance(holeLon, holeLat, ((HoleBiaoguan) o).getLongitude(), ((HoleBiaoguan) o).getLatitude());
|
} else if (o instanceof HoleHuici) {
|
distance = ExceptionDistanceUtils.distance(holeLon, holeLat, ((HoleHuici) o).getLongitude(), ((HoleHuici) o).getLatitude());
|
} else if (o instanceof HoleQutu) {
|
distance = ExceptionDistanceUtils.distance(holeLon, holeLat, ((HoleQutu) o).getLongitude(), ((HoleQutu) o).getLatitude());
|
} else if (o instanceof HoleShuiwei) {
|
distance = ExceptionDistanceUtils.distance(holeLon, holeLat, ((HoleShuiwei) o).getLongitude(), ((HoleShuiwei) o).getLatitude());
|
} else if (o instanceof HoleYantu) {
|
distance = ExceptionDistanceUtils.distance(holeLon, holeLat, ((HoleYantu) o).getLongitude(), ((HoleYantu) o).getLatitude());
|
}
|
if (distance > addrDistance) {
|
count++;
|
}
|
if (distance > max) {
|
max = distance;
|
}
|
}
|
}
|
}
|
|
/**
|
* 时间异常
|
* 钻孔速度大于x米/小时
|
* 且同一钻孔下的异常记录占比不超过x%（轻微异常）
|
* 且同一钻孔下的异常记录占比不超过20-50%（一般异常）
|
* 且同一钻孔下的异常记录占比不超过x%或最大钻进速度大于*米（严重异常）
|
*/
|
public HandleException timeExceptionFun(Hole hole, ExceptionConfig configData,Project project) {
|
HandleException item = new HandleException();
|
|
List<HoleYantu> yantuList = holeYantuMapper.selectHoleYantuListByHoleId(hole.getIds());
|
|
String companyId = "";
|
if (ObjectUtil.isNotEmpty(project)) {
|
companyId = project.getCompanyId();
|
}
|
|
// 扫描岩土表
|
if (ObjectUtil.isNotEmpty(yantuList)) {
|
double timeSpead = Double.parseDouble(configData.getTimeSpead());
|
double timeNum1 = Double.parseDouble(configData.getTimeNum1());
|
double timeNum2 = Double.parseDouble(configData.getTimeNum2());
|
double timeMaxSpead = Double.parseDouble(configData.getTimeMaxSpead());
|
|
double count = 0;
|
double max = 0;
|
|
String desc = "";
|
for (int i = 0; i < yantuList.size() - 1; i++) {
|
HoleYantu holeYantu1 = yantuList.get(i);
|
HoleYantu holeYantu2 = yantuList.get(i + 1);
|
// 计算速度
|
Double spead = ExceptionTimeUtils.spead(holeYantu1.getGpsTime(), holeYantu1.getEndDepth(), holeYantu2.getGpsTime(), holeYantu2.getEndDepth());
|
if (spead == null) {
|
continue;
|
}
|
if (spead > timeSpead) {
|
count++;
|
}
|
if (spead > max) {
|
max = spead;
|
}
|
}
|
//计算百分比
|
double percent = count / yantuList.size();
|
|
if (percent <= 0) {
|
//如果百分比为0 不是异常数据
|
return null;
|
}
|
|
if (percent > 0 && percent < timeNum1) {
|
item.setLevel(RecordType.exceptionLevel1.getId());
|
} else if (percent > 0.2 && percent < 0.5) {
|
item.setLevel(RecordType.exceptionLevel2.getId());
|
} else if (percent > timeNum2) {
|
item.setLevel(RecordType.exceptionLevel3.getId());
|
}
|
desc = percent * 100 + "%" + "的岩土记录勘察速度超过" + timeSpead + "米/小时";
|
if (max > timeMaxSpead) {
|
item.setLevel(RecordType.exceptionLevel3.getId());
|
desc = "最大勘察速度超过" + timeMaxSpead + "米/小时";
|
}
|
setException(item, hole, companyId, desc, RecordType.exceptionType2.getId());
|
return item;
|
|
} else {
|
setException(item, hole, companyId, "未查询到岩土数据异常", RecordType.exceptionType3.getId());
|
return item;
|
}
|
}
|
|
/**
|
* 设置异常信息
|
*
|
* @param item
|
* @param hole
|
* @param companyId
|
* @param desc
|
* @param type 异常类型
|
*/
|
private void setException(HandleException item, Hole hole, String companyId, String desc, String type) {
|
item.setIds(IdGenerate.nextId());
|
item.setCompanyId(companyId);
|
item.setHandleStatus(RecordType.exceptionStatus0.getId());
|
item.setHoleId(hole.getIds());
|
item.setHoleCode(hole.getCode());
|
item.setMapTime(hole.getMapTime());
|
item.setProjectId(hole.getProjectId());
|
item.setType(type);
|
item.setIsDelete(false);
|
item.setDescription(desc);
|
}
|
|
/**
|
* 首页汇总
|
*/
|
public ResponseResult indexCollect() {
|
IndexCollectVo resultData = new IndexCollectVo();
|
|
// =======================项目======================
|
Long allProjectNum = projectMapper.selectAllProjectNum();
|
Long projectNum = projectMapper.selectProjectNum();
|
|
// =======================企业=======================
|
Long allCompanyNum = companyMapper.selectAllCompanyNum();
|
Long companyNum = companyMapper.selectCompanyNum();
|
|
// =======================勘测点=======================
|
Long allHoleNum = holeMapper.selectAllHoleNum();
|
Long holeNum = holeMapper.selectHoleNum();
|
|
// =======================进尺=======================
|
List<HoleYantu> yantuList1 = holeYantuMapper.selectHoleYantuByProject0();
|
List<HoleYantu> yantuList2 = holeYantuMapper.selectHoleYantuByProject1();
|
/**
|
* 在施进尺总量
|
* 没有在施进尺总量
|
* 总进尺总量 = 在施进尺总量 + 没有在施进尺总量
|
*/
|
double yatuNum = 0.00;
|
if (ObjectUtil.isNotEmpty(yantuList1)) {
|
for (HoleYantu item : yantuList1) {
|
double num = NumberUtils.sub(item.getEndDepth(), item.getBeginDepth());
|
yatuNum += num;
|
}
|
}
|
double tempNum = 0.00;
|
if (ObjectUtil.isNotEmpty(yantuList2)) {
|
for (HoleYantu item : yantuList2) {
|
double num = NumberUtils.sub(item.getEndDepth(), item.getBeginDepth());
|
tempNum += num;
|
}
|
}
|
Double allYantuNum = yatuNum + tempNum;
|
|
// =======================异常=======================
|
Long allExceptionNum = handleExceptionMapper.selectAllExceptionNum();
|
Long exceptionNum = handleExceptionMapper.selectExceptionNum();
|
|
resultData.setAllProjectNum(allProjectNum);
|
resultData.setProjectNum(projectNum);
|
resultData.setAllCompanyNum(allCompanyNum);
|
resultData.setCompanyNum(companyNum);
|
resultData.setAllHoleNum(allHoleNum);
|
resultData.setHoleNum(holeNum);
|
resultData.setAllJinChiNum(NumberUtils.formatDouble(yatuNum));
|
resultData.setJinChiNum(NumberUtils.formatDouble(allYantuNum));
|
resultData.setAllExceptionNum(allExceptionNum);
|
resultData.setExceptionNum(exceptionNum);
|
|
return ResponseResult.success(resultData);
|
}
|
|
/**
|
* 首页项目数量汇总
|
*/
|
public ResponseResult indexProjectNumsCollect(String startTime, String endTime) {
|
List<Company> companyData = companyMapper.selectCompanProjectNums(startTime,endTime);
|
return ResponseResult.success(companyData);
|
}
|
|
|
/**
|
* 扫描汇总统计
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public void scanCollectStatistics() {
|
|
List<CollectStatistics> resultList = statisticsMapper.selectCollectStatistic();
|
|
if (!ObjectUtils.isEmpty(resultList)){
|
for (CollectStatistics item : resultList) {
|
|
String companyId = item.getCompanyId();
|
|
int holeNum = 0;
|
int exceptionProject = 0;
|
double yatuNum = 0.00;
|
|
// 查询企业下面的项目
|
Project project = new Project();
|
project.setCompanyId(companyId);
|
|
List<Project> projects = projectMapper.selectProjectList(project);
|
|
if (!ObjectUtils.isEmpty(projects)){
|
for (Project pro : projects) {
|
String projectId = pro.getIds();
|
|
// =======================勘探点数量=======================
|
int num1 = holeMapper.selectHoleNumByProjectId(projectId);
|
holeNum += num1;
|
|
// =======================异常项目=======================
|
int num2 = handleExceptionMapper.selectExceptionNumByProjectId(projectId);
|
exceptionProject += num2;
|
|
// =======================进尺总量=======================
|
List<HoleYantu> yantuList = holeYantuMapper.selectHoleYantuByProjectId(projectId);
|
if (ObjectUtil.isNotEmpty(yantuList)) {
|
for (HoleYantu yantu : yantuList) {
|
double num3 = NumberUtils.sub(yantu.getEndDepth(), yantu.getBeginDepth());
|
yatuNum += num3;
|
}
|
}
|
}
|
}
|
// =======================异常数量=======================
|
int exceptionNum = handleExceptionMapper.selectExceptionNumByCompanyId(companyId);
|
|
item.setIds(IdGenerate.nextId());
|
item.setHoleNum((long) holeNum);
|
item.setExceptionProject((long) exceptionProject);
|
item.setExceptionNum((long) exceptionNum);
|
item.setJinchiNum(yatuNum);
|
}
|
}
|
insertCollectStatistics(resultList);
|
}
|
|
/**
|
* 新增扫描汇总表
|
* ==============因为是定时任务，先清空表里面的数据，再新增=====================
|
*/
|
private void insertCollectStatistics(List<CollectStatistics> statistics) {
|
if (!ObjectUtils.isEmpty(statistics)){
|
statisticsMapper.emptyTable();
|
for (CollectStatistics item : statistics) {
|
if (StringUtils.isNotEmpty(item.getIds())){
|
statisticsMapper.insertCollectStatistics(item);
|
}else {
|
statisticsMapper.updateCollectStatistics(item);
|
}
|
}
|
}
|
}
|
|
|
/**
|
* 上传异常处理意见接口
|
*/
|
public ResponseResult uploadHandle(HandleOpinion handleOpinion) {
|
|
if (!dataSourceService.checkSecretKey(handleOpinion.getSecretKey())){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
handleOpinion.setIds(IdGenerate.nextId());
|
int i = handleOpinionMapper.insertHandleOpinion(handleOpinion);
|
if (i > 0){
|
return ResponseResult.success("上传成功！");
|
}
|
return ResponseResult.error("上传失败！");
|
}
|
|
|
/**
|
* 获取项目所有异常数据接口
|
* @param exceptionVo
|
* @return
|
*/
|
public ResponseResult getProjectException(ExceptionVo exceptionVo) {
|
if (!dataSourceService.checkSecretKey(exceptionVo.getSecretKey())){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
|
List<ExceptionResponseVo> resultList = new ArrayList<>();
|
ExceptionResponseVo responseVo;
|
|
HandleException param = new HandleException();
|
param.setProjectId(exceptionVo.getProjectID());
|
param.setHandleStatus(exceptionVo.getHandleStatus());
|
List<HandleException> list = handleExceptionService.selectHandleExceptionList(param);
|
|
if (!ObjectUtils.isEmpty(list)){
|
for (HandleException item : list) {
|
responseVo = new ExceptionResponseVo();
|
responseVo.setDescription(item.getDescription());
|
responseVo.setHandleStatus(item.getHandleStatus());
|
responseVo.setHoleCode(item.getHoleCode());
|
responseVo.setHoleID(item.getHoleId());
|
responseVo.setIds(item.getIds());
|
responseVo.setLevel(item.getLevel());
|
responseVo.setType(item.getType());
|
responseVo.setHandleList(getExceptionHandle(item.getProjectId()));
|
|
resultList.add(responseVo);
|
}
|
}
|
return ResponseResult.success("获取项目所有异常数据成功!" , resultList);
|
}
|
|
|
/**
|
* 根据项目序列号，获取ExceptionHandle信息
|
*/
|
private List<ExceptionHandle> getExceptionHandle(String projectID){
|
List<ExceptionHandle> resultList = new ArrayList<>();
|
ExceptionHandle exceptionHandle = new ExceptionHandle();
|
|
HandleOpinion param = new HandleOpinion();
|
param.setProjectId(projectID);
|
List<HandleOpinion> list = handleOpinionMapper.selectHandleOpinionList(param);
|
|
if (!ObjectUtils.isEmpty(list)){
|
for (HandleOpinion item : list) {
|
exceptionHandle.setCreateTime(item.getCreateTime());
|
exceptionHandle.setExceptionID(item.getExceptionId());
|
exceptionHandle.setGroupName(item.getGroupname());
|
exceptionHandle.setIds(item.getIds());
|
exceptionHandle.setOpinion(item.getOpinion());
|
exceptionHandle.setUserName(item.getUsername());
|
|
resultList.add(exceptionHandle);
|
}
|
}
|
return resultList;
|
}
|
|
|
/**
|
* 获取异常详情接口
|
*/
|
public ResponseResult getExceptionDetail(String secretKey, String exceptionID) {
|
if (!dataSourceService.checkSecretKey(secretKey)){
|
return ResponseResult.error("平台秘钥不存在");
|
}
|
if (StringUtils.isEmpty(exceptionID)){
|
return ResponseResult.error("exceptionID不能为空");
|
}
|
|
ExceptionDetailVo resultData = new ExceptionDetailVo();
|
List<ExceptionDetailRecordVo> detailRecordVos = new ArrayList<>();
|
|
HandleException handleException = handleExceptionMapper.selectHandleExceptionById(exceptionID);
|
|
HandleOpinion opinion = new HandleOpinion();
|
opinion.setExceptionId(exceptionID);
|
List<HandleOpinion> handleOpinions = handleOpinionMapper.selectHandleOpinionList(opinion);
|
|
/**
|
* 异常详情的结构说明如下
|
* 距离异常会返回该勘探点下所有记录的beginDepth-type（除layerType、layerName）共9个字段值
|
* 时间异常会返回所有岩土类型记录的beginDepth-speed共12个字段值，第一条岩土记录的速度为0，后面每一条记录的速度=和上一条记录的深度差/时间差所得；
|
* 人员异常会返回当前所属项目前后5小时（规则设定）当前描述员所做其他项目的记录，beginDepthprojectName（除layerType、layerName、speed）共14个字段值
|
*/
|
if (!ObjectUtils.isEmpty(handleException)){
|
String holeId = handleException.getHoleId();
|
String type = handleException.getType();
|
// 距离异常
|
if (RecordType.exceptionType1.getId().equals(type)){
|
detailRecordVos = getDistanceDetail(holeId);
|
}
|
// 时间异常
|
if (RecordType.exceptionType2.getId().equals(type)){
|
detailRecordVos = getTimeDetail(holeId);
|
}
|
// 人员异常
|
if (RecordType.exceptionType5.getId().equals(type)){
|
detailRecordVos = getPersonDetail(holeId);
|
}
|
}
|
|
BeanUtil.copyProperties(handleException, handleException);
|
resultData.setHandleList(handleOpinions);
|
resultData.setRecordList(detailRecordVos);
|
return ResponseResult.success("获取成功",resultData);
|
}
|
|
|
/**
|
* 距离异常
|
*/
|
private List<ExceptionDetailRecordVo> getDistanceDetail(String hole){
|
List<ExceptionDetailRecordVo> recordVos = new ArrayList<>();
|
ExceptionDetailRecordVo detailRecordVo;
|
|
List<ExceptionDistanceVo> distanceVos = handleExceptionService.holeDistanceDetails(hole);
|
if (!ObjectUtils.isEmpty(distanceVos)){
|
for (ExceptionDistanceVo item : distanceVos) {
|
detailRecordVo = new ExceptionDetailRecordVo();
|
detailRecordVo.setBeginDepth(item.getBeginDepth());
|
detailRecordVo.setCode(item.getCode());
|
detailRecordVo.setDistance(item.getDistance());
|
detailRecordVo.setEndDepth(item.getEndDepth());
|
detailRecordVo.setIds(item.getIds());
|
detailRecordVo.setGpsTime(item.getGpsTime());
|
detailRecordVo.setLongitude(item.getLng());
|
detailRecordVo.setLatitude(item.getLat());
|
detailRecordVo.setType(item.getRecordType());
|
recordVos.add(detailRecordVo);
|
}
|
}
|
return recordVos;
|
}
|
|
/**
|
* 时间异常
|
*/
|
private List<ExceptionDetailRecordVo> getTimeDetail(String hole){
|
List<ExceptionDetailRecordVo> recordVos = new ArrayList<>();
|
ExceptionDetailRecordVo detailRecordVo;
|
|
List<ExceptionTimeVo> timeVos = handleExceptionService.holeTimeDetails(hole);
|
if (!ObjectUtils.isEmpty(timeVos)){
|
for (ExceptionTimeVo item : timeVos) {
|
|
detailRecordVo = new ExceptionDetailRecordVo();
|
detailRecordVo.setBeginDepth(item.getBeginDepth());
|
detailRecordVo.setCode(item.getCode());
|
detailRecordVo.setEndDepth(item.getEndDepth());
|
detailRecordVo.setIds(item.getIds());
|
detailRecordVo.setGpsTime(item.getGpsTime());
|
detailRecordVo.setLongitude(item.getLongitude());
|
detailRecordVo.setLatitude(item.getLatitude());
|
detailRecordVo.setType(item.getRecordType());
|
detailRecordVo.setLayerType(item.getFrequencyType());
|
detailRecordVo.setLayerName(item.getLayerName());
|
detailRecordVo.setSpeed(item.getSpead());
|
|
recordVos.add(detailRecordVo);
|
}
|
}
|
return recordVos;
|
}
|
|
/**
|
* TODO 人员异常
|
*/
|
private List<ExceptionDetailRecordVo> getPersonDetail(String hole){
|
List<ExceptionDetailRecordVo> recordVos = new ArrayList<>();
|
|
|
return recordVos;
|
}
|
|
|
}
|
