package com.terra.system.service.data;
|
|
import cn.hutool.core.collection.ListUtil;
|
import com.terra.system.entity.all.BaseEntity;
|
import com.terra.common.entity.all.StaticData;
|
import com.terra.system.entity.data.*;
|
import com.terra.system.entity.sys.UserEntity;
|
import com.terra.system.helper.*;
|
import com.terra.system.mapper.all.BasicMapper;
|
import com.terra.system.mapper.data.UploadMapper;
|
import com.terra.system.service.all.BaseQueryService;
|
import com.terra.system.service.all.BaseUploadService;
|
import com.terra.system.service.sys.DepService;
|
import org.apache.commons.io.FileUtils;
|
import javax.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.io.File;
|
import java.lang.reflect.Field;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.nio.file.Paths;
|
import java.sql.Timestamp;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* 数据上传服务类
|
*
|
* @author WWW
|
*/
|
@Service
|
public class UploadService extends BaseUploadService implements UploadMapper {
|
@Resource
|
UploadMapper uploadMapper;
|
|
@Resource
|
FmeService fmeService;
|
|
@Resource
|
MetaService metaService;
|
|
@Resource
|
DepService depService;
|
|
@Resource
|
DirService dirService;
|
|
@Override
|
public List<CoordEntity> selectCoords(String zoning) {
|
return uploadMapper.selectCoords(zoning);
|
}
|
|
@Override
|
public Integer selectCount4Coord(String epsgCode) {
|
return uploadMapper.selectCount4Coord(epsgCode);
|
}
|
|
@Override
|
public List<DirEntity> selectProject() {
|
return uploadMapper.selectProject();
|
}
|
|
@Override
|
public List<FmeLogEntity> selectFmeLog(String parentid) {
|
return uploadMapper.selectFmeLog(parentid);
|
}
|
|
/**
|
* 插入文件
|
*/
|
public void insertFiles(UserEntity ue, List<MetaFileEntity> list, HttpServletRequest req) {
|
checkMetaFiles(ue, list);
|
List<MetaFileEntity> xlsList = getExcelFiles(list);
|
loadData(list);
|
copyFiles(list);
|
insertMetas(list);
|
if (xlsList.size() > 0) {
|
String guid = excelLoader(xlsList, req);
|
}
|
}
|
|
/**
|
* 检查元数据文件
|
*/
|
private void checkMetaFiles(UserEntity ue, List<MetaFileEntity> list) {
|
Timestamp createTime = WebHelper.getCurrentTimestamp();
|
String tempPath = pathHelper.getConfig().getTempPath();
|
|
for (MetaFileEntity mf : list) {
|
mf.setCreateUser(ue.getId());
|
mf.setCreateTime(createTime);
|
mf.setDepcode(ue.getDepcode());
|
mf.setPath(tempPath + File.separator + mf.getPath());
|
mf.setMsg(null);
|
|
File f = new File(mf.getPath());
|
if (!f.exists()) {
|
mf.setMsg("文件丢失");
|
}
|
if (f.exists() && StringHelper.isNull(mf.getGuid())) {
|
mf.setGuid(FileHelper.getFileMd5(f.getPath()));
|
}
|
|
MetaEntity old = metaService.selectByGuid(mf.getGuid(), getDirCode(mf), null);
|
if (null != old) {
|
mf.setMsg("已存在");
|
}
|
}
|
}
|
|
/**
|
* 获取目录编码
|
*/
|
private String getDirCode(MetaFileEntity mf) {
|
if (StringHelper.isEmpty(mf.getDircode())) {
|
return null;
|
}
|
|
return StringHelper.getRightLike(mf.getDircode().substring(0, 2));
|
}
|
|
/**
|
* 获取Excel元数据文件
|
*/
|
private List<MetaFileEntity> getExcelFiles(List<MetaFileEntity> list) {
|
List<MetaFileEntity> xlsList = new ArrayList<>();
|
for (MetaFileEntity mf : list) {
|
if (null == mf.getMsg() && isExcel(mf)) {
|
xlsList.add(mf);
|
}
|
}
|
if (xlsList.isEmpty()) {
|
return xlsList;
|
}
|
|
String xlsBasePath = getXlsPath(xlsList.get(0).getPath());
|
for (int i = 0, c = xlsList.size(); i < c; i++) {
|
MetaFileEntity mf = xlsList.get(i);
|
String xlsPath = copyXlsFile(xlsBasePath, i, mf);
|
mf.setXlsPath(xlsPath);
|
}
|
|
return xlsList;
|
}
|
|
/**
|
* 是/否为Excel
|
*/
|
private boolean isExcel(MetaFileEntity mf) {
|
return StaticData.XLS.equals(mf.getExtName()) || StaticData.XLSX.equals(mf.getExtName());
|
}
|
|
/**
|
* 获取Xls目录
|
*/
|
private String getXlsPath(String filePath) {
|
String tempPath = pathHelper.getConfig().getTempPath() + File.separator;
|
String subPath = filePath.substring(tempPath.length());
|
subPath = tempPath + subPath.substring(0, subPath.indexOf(File.separator)).replace("_zip", "") + "_xls";
|
|
File f = new File(subPath);
|
if (!f.exists() || !f.isDirectory()) {
|
f.mkdirs();
|
}
|
|
return subPath;
|
}
|
|
/**
|
* 复制Xls文件
|
*/
|
private String copyXlsFile(String xlsBasePath, int i, MetaFileEntity mf) {
|
try {
|
String xlsPath = xlsBasePath + File.separator + i;
|
|
File file = new File(xlsPath);
|
if (!file.exists() || !file.isDirectory()) {
|
file.mkdirs();
|
}
|
file = new File(mf.getPath());
|
|
File newFile = new File(xlsPath + File.separator + FileHelper.getFileName(file.getPath()));
|
FileUtils.copyFile(file, newFile);
|
|
return newFile.getPath();
|
} catch (Exception ex) {
|
log.error(ex.getMessage(), ex);
|
return null;
|
}
|
}
|
|
/**
|
* 加载数据
|
*/
|
private void loadData(List<MetaFileEntity> list) {
|
for (MetaFileEntity mf : list) {
|
if (null != mf.getMsg() || StringHelper.isEmpty(mf.getEntity())) {
|
continue;
|
}
|
if (StaticData.SHP.equals(mf.getExtName()) || StaticData.GDB.equals(mf.getExtName())) {
|
loadSpatialData(mf);
|
}
|
}
|
}
|
|
/**
|
* 加载空间数据
|
*/
|
public void loadSpatialData(MetaFileEntity mf) {
|
BasicMapper basicMapper = ClassHelper.getBasicMapper(mf.getEntity());
|
if (null == basicMapper) {
|
return;
|
}
|
|
String tabName = BaseQueryService.getTabName(basicMapper);
|
String className = ClassHelper.getClassName(basicMapper);
|
Class clazz = ClassHelper.getEntityClass(className);
|
if (null == clazz || null == tabName) {
|
return;
|
}
|
|
File file = new File(mf.getPath());
|
if (!file.exists()) {
|
mf.setMsg("文件丢失");
|
return;
|
}
|
|
MetaEntity old = metaService.selectByGuid(mf.getGuid(), getDirCode(mf), tabName);
|
if (null != old) {
|
mf.setMsg("已存在");
|
return;
|
}
|
|
List<?> list;
|
if (StaticData.SHP.equals(mf.getExtName())) {
|
list = ShpHelper.readData(clazz, mf.getPath(), true);
|
} else {
|
list = GdbHelper.readData(clazz, mf.getPath(), mf.getTab(), true);
|
}
|
if (null == list || list.isEmpty()) {
|
return;
|
}
|
mf.setRecords(list.size());
|
setCreateInfo(list, mf);
|
|
int rows = batchInserts(basicMapper, list);
|
if (rows > 0) {
|
mf.setEntity(mf.getTab());
|
mf.setTab(tabName);
|
mf.setRows(rows);
|
}
|
}
|
|
/**
|
* 批量插入
|
*/
|
private <T> int batchInserts(BasicMapper basicMapper, List<T> list) {
|
int rows = 0;
|
//int count = (int) Math.ceil(list.size() / StaticData.D100)
|
List<List<T>> subLists = ListUtil.partition(list, StaticData.I50);
|
for (List<T> sub : subLists) {
|
try {
|
rows += basicMapper.insertBatch(sub);
|
} catch (Exception ex) {
|
log.error(ex);
|
}
|
}
|
|
return rows;
|
}
|
|
/**
|
* 设置创建信息
|
*/
|
private <T> void setCreateInfo(List<T> list, MetaFileEntity mf) {
|
try {
|
if (!(list.get(0) instanceof BaseEntity)) {
|
return;
|
}
|
|
for (T t : list) {
|
BaseEntity be = (BaseEntity) t;
|
be.setEventid(StringHelper.getGuid());
|
be.setParentid(mf.getEventid());
|
be.setDirid(mf.getDircode());
|
be.setDepid(mf.getDepcode());
|
be.setVerid(mf.getVerid());
|
be.setCreateuser(mf.getCreateUser());
|
be.setCreatetime(mf.getCreateTime());
|
}
|
} catch (Exception ex) {
|
log.error(ex.getMessage(), ex);
|
}
|
}
|
|
/**
|
* 复制文件
|
*/
|
private void copyFiles(List<MetaFileEntity> list) {
|
List<String> gdbList = new ArrayList<>();
|
for (MetaFileEntity mf : list) {
|
if (null != mf.getMsg()) {
|
continue;
|
}
|
|
switch (mf.getExtName()) {
|
case StaticData.MPT:
|
copyMultiFile(mf, StaticData.MPT_EXT);
|
break;
|
case StaticData.JPG:
|
copyMultiFile(mf, StaticData.JPG_EXT);
|
break;
|
case StaticData.IMG:
|
copyMultiFile(mf, StaticData.IMG_EXT);
|
break;
|
case StaticData.TIF:
|
copyMultiFile(mf, StaticData.TIF_EXT);
|
break;
|
case StaticData.TIFF:
|
copyMultiFile(mf, StaticData.TIFF_EXT);
|
break;
|
case StaticData.SHP:
|
copyMultiFile(mf, StaticData.SHP_EXT);
|
break;
|
case StaticData.OSGB:
|
copyFolderFile(mf);
|
break;
|
case StaticData.GDB:
|
if (gdbList.contains(mf.getPath())) {
|
String path = findPathByGuid(list, mf);
|
if (null != path) {
|
mf.setPath(path);
|
continue;
|
}
|
}
|
|
gdbList.add(mf.getPath());
|
copyFolderFile(mf);
|
break;
|
default:
|
copySingleFile(mf);
|
break;
|
}
|
}
|
}
|
|
/**
|
* 复制单个文件
|
*/
|
private int copySingleFile(MetaFileEntity mf) {
|
File file = new File(mf.getPath());
|
if (!file.exists()) {
|
mf.setMsg("文件丢失");
|
return -1;
|
}
|
|
MetaEntity old = metaService.selectByGuid(mf.getGuid(), null, null);
|
if (null != old) {
|
// mf.setMsg("已存在")
|
setOldMeta(mf, old);
|
file.delete();
|
return 0;
|
}
|
|
String uploadPath = pathHelper.getUploadFullPath();
|
String targetPath = uploadPath + File.separator + mf.getGuid() + mf.getExtName();
|
String subPath = FileHelper.getRelativePath(targetPath);
|
|
File newFile = new File(targetPath);
|
if (newFile.exists()) {
|
mf.setPath(subPath);
|
file.delete();
|
return 0;
|
}
|
|
file.renameTo(newFile);
|
mf.setPath(subPath);
|
|
return 1;
|
}
|
|
/**
|
* 设置旧元数据信息
|
*/
|
private void setOldMeta(MetaFileEntity mf, MetaEntity old) {
|
mf.setPath(old.getPath());
|
mf.setTab(old.getTab());
|
mf.setRows(old.getRows());
|
mf.setEntity(old.getEventid());
|
}
|
|
/**
|
* 复制多个文件
|
*/
|
private void copyMultiFile(MetaFileEntity mf, List<String> extList) {
|
String path = mf.getPath();
|
int status = copySingleFile(mf);
|
if (status < 1) {
|
for (int i = 0, c = extList.size(); i < c; i++) {
|
String subPath = path.replace(mf.getExtName(), extList.get(i));
|
File file = new File(subPath);
|
if (file.exists()) {
|
file.delete();
|
}
|
}
|
return;
|
}
|
|
String uploadPath = pathHelper.getConfig().getUploadPath();
|
for (int i = 0, c = extList.size(); i < c; i++) {
|
String sourcePath = path.replace(mf.getExtName(), extList.get(i));
|
File file = new File(sourcePath);
|
if (!file.exists()) {
|
continue;
|
}
|
|
String targetPath = uploadPath + File.separator + mf.getPath().replace(mf.getExtName(), extList.get(i));
|
File newFile = new File(targetPath);
|
if (newFile.exists()) {
|
continue;
|
}
|
|
file.renameTo(newFile);
|
}
|
}
|
|
/**
|
* 复制文件夹文件
|
*/
|
private void copyFolderFile(MetaFileEntity mf) {
|
File file = new File(mf.getPath());
|
if (!file.exists()) {
|
mf.setMsg("文件丢失");
|
return;
|
}
|
|
MetaEntity old = metaService.selectByGuid(mf.getGuid(), null, null);
|
if (null != old) {
|
// mf.setMsg("已存在")
|
setOldMeta(mf, old);
|
FileHelper.deleteFiles(file);
|
return;
|
}
|
|
String uploadPath = pathHelper.getUploadFullPath();
|
String targetPath = uploadPath + File.separator + mf.getGuid() + mf.getExtName();
|
String subPath = FileHelper.getRelativePath(targetPath);
|
|
File newFile = new File(targetPath);
|
if (newFile.exists() && newFile.isDirectory()) {
|
mf.setPath(subPath);
|
FileHelper.deleteFiles(file);
|
return;
|
}
|
|
try {
|
// newFile.mkdirs()
|
FileUtils.moveDirectory(file, newFile);
|
} catch (Exception ex) {
|
log.error(ex);
|
}
|
mf.setPath(subPath);
|
}
|
|
/**
|
* 根据GUID查找路径
|
*/
|
private String findPathByGuid(List<MetaFileEntity> list, MetaFileEntity mf) {
|
for (MetaFileEntity meta : list) {
|
if (meta.getGuid().equals(mf.getGuid()) && !meta.getPath().equals(mf.getPath())) {
|
return meta.getPath();
|
}
|
}
|
|
return null;
|
}
|
|
/**
|
* 创建文件链接
|
*/
|
private void createFileLink(String source, String target) {
|
String cmd = String.format("cmd /c mklink \"%s\" \"%s\"", target, source);
|
WebHelper.exec(cmd);
|
}
|
|
/**
|
* 插入元数据
|
*/
|
private void insertMetas(List<MetaFileEntity> list) {
|
int metaId = insertParentMeta(list);
|
|
List<String> guids = new ArrayList<>();
|
for (MetaFileEntity mf : list) {
|
if (null != mf.getMsg()) {
|
continue;
|
}
|
|
MetaEntity me = createMeta(mf, metaId);
|
if (StaticData.NGDB.equals(me.getType())) {
|
if (guids.contains(me.getGuid())) {
|
me.setIsmeta((short) -1);
|
} else {
|
guids.add(me.getGuid());
|
}
|
}
|
|
metaService.insert(me);
|
String err = mf.getRows() < mf.getRecords() ? "(" + (mf.getRecords() - mf.getRows()) + " 条失败)" : "";
|
mf.setMsg(me.getId() > 0 ? String.format("成功%s", err) : "失败");
|
}
|
}
|
|
/**
|
* 创建元数据
|
*/
|
private MetaEntity createMeta(MetaFileEntity mf, int metaId) {
|
MetaEntity me = new MetaEntity();
|
me.setMetaid(metaId);
|
me.setEventid(mf.getEventid());
|
me.setDircode(mf.getDircode());
|
me.setDepcode(mf.getDepcode());
|
me.setVerid(mf.getVerid());
|
me.setName(mf.getName());
|
me.setType(mf.getType());
|
me.setGuid(mf.getGuid());
|
me.setPath(mf.getPath());
|
me.setSizes(mf.getSizes());
|
if (mf.getRows() > 0) {
|
me.setTab(mf.getTab());
|
}
|
if (!StringHelper.isEmpty(mf.getEntity())) {
|
me.setLayer(mf.getEntity());
|
}
|
me.setRows(mf.getRows());
|
me.setCreateUser(mf.getCreateUser());
|
me.setCreateTime(mf.getCreateTime());
|
|
return me;
|
}
|
|
/**
|
* 插入父元数据
|
*/
|
private int insertParentMeta(List<MetaFileEntity> list) {
|
for (MetaFileEntity mf : list) {
|
if (null != mf.getMsg() || !mf.getIsMeta()) {
|
continue;
|
}
|
|
MetaEntity me = createMeta(mf, 0);
|
me.setIsmeta((short) 1);
|
metaService.insert(me);
|
mf.setMsg(me.getId() > 0 ? "成功" : "失败");
|
|
return me.getId();
|
}
|
|
return 0;
|
}
|
|
/**
|
* Excel入库
|
*/
|
private String excelLoader(List<MetaFileEntity> xlsList, HttpServletRequest req) {
|
try {
|
MetaFileEntity xlsMeta = getExcelMeta(xlsList);
|
if (null != xlsMeta) {
|
return fmeService.excelLoader(xlsMeta, req);
|
}
|
} catch (Exception ex) {
|
log.error(ex.getMessage(), ex);
|
}
|
|
return null;
|
}
|
|
/**
|
* 获取Excel的元数据
|
*/
|
private MetaFileEntity getExcelMeta(List<MetaFileEntity> xlsList) {
|
if (null == xlsList || xlsList.isEmpty()) {
|
return null;
|
}
|
|
List<String> pathList = new ArrayList<>();
|
List<String> dirList = new ArrayList<>();
|
List<String> pidList = new ArrayList<>();
|
|
for (int i = 0, c = xlsList.size(); i < c; i++) {
|
MetaFileEntity mf = xlsList.get(i);
|
if ("成功".equals(mf.getMsg()) && null != mf.getXlsPath()) {
|
pathList.add(mf.getXlsPath());
|
dirList.add(mf.getDircode());
|
pidList.add(mf.getEventid());
|
}
|
}
|
|
MetaFileEntity first = xlsList.get(0);
|
MetaFileEntity meta = new MetaFileEntity();
|
meta.setPath(StringHelper.join(pathList, ","));
|
meta.setEpsgCode(first.getEpsgCode());
|
meta.setName(StringHelper.join(dirList, ";"));
|
meta.setDepcode(first.getDepcode());
|
meta.setVerid(first.getVerid());
|
meta.setCreateUser(first.getCreateUser());
|
meta.setEventid(StringHelper.join(pidList, ";"));
|
|
return meta;
|
}
|
|
/**
|
* 插入KML文件
|
*/
|
public void insertKml(UserEntity ue, List<MetaFileEntity> list) {
|
checkMetaFiles(ue, list);
|
loadKml(list);
|
copyFiles(list);
|
insertMetas(list);
|
}
|
|
/**
|
* 加载Kml
|
*/
|
private void loadKml(List<MetaFileEntity> list) {
|
for (MetaFileEntity mf : list) {
|
if (null != mf.getMsg() || StringHelper.isEmpty(mf.getEntity()) || !StaticData.KML.equals(mf.getExtName())) {
|
continue;
|
}
|
|
String wkt = readKml(mf.getPath());
|
if (StringHelper.isEmpty(wkt)) {
|
continue;
|
}
|
|
loadKmlData(mf, wkt);
|
}
|
}
|
|
/**
|
* 读取KML
|
*/
|
private String readKml(String path) {
|
try {
|
List<String> list = Files.readAllLines(Paths.get(path), StandardCharsets.UTF_8);
|
for (String str : list) {
|
if (!str.contains("<coordinates>")) {
|
continue;
|
}
|
|
return getWktFromCoordinates(str);
|
}
|
|
return null;
|
} catch (Exception ex) {
|
log.error(ex.getMessage(), ex);
|
return null;
|
}
|
}
|
|
/**
|
* 获取KWT
|
*/
|
private String getWktFromCoordinates(String coords) {
|
String[] strs = coords.replace("\t", "").replace("<coordinates>", "").replace("</coordinates>", "").split(" ");
|
if (strs.length == 0) {
|
return null;
|
}
|
|
// MULTILINESTRING((108.99843373100003 34.736292580000054,108.99818970700005 34.73764945000005,108.99831780400007 34.738880547000065,108.99812184300004 34.739564029000064))
|
StringBuilder sb = new StringBuilder();
|
sb.append("MULTILINESTRING((");
|
for (String str : strs) {
|
if (StringHelper.isEmpty(str)) {
|
continue;
|
}
|
|
String[] vals = str.split(StaticData.COMMA);
|
sb.append(vals[0]).append(" ").append(vals[1]).append(StaticData.COMMA);
|
}
|
sb.deleteCharAt(sb.length() - 1);
|
sb.append("))");
|
|
return sb.toString();
|
}
|
|
/**
|
* 加载Kml数据
|
*/
|
private void loadKmlData(MetaFileEntity mf, String wkt) {
|
BasicMapper basicMapper = ClassHelper.getBasicMapper(mf.getEntity());
|
if (null == basicMapper) {
|
return;
|
}
|
|
String tabName = BaseQueryService.getTabName(basicMapper);
|
String className = ClassHelper.getClassName(basicMapper);
|
Class clazz = ClassHelper.getEntityClass(className);
|
if (null == clazz || null == tabName) {
|
return;
|
}
|
|
String stage = getPipeStage(tabName);
|
String name = FileHelper.getName(mf.getPath());
|
List<?> list = createKmlEntity(clazz, wkt, name, mf, stage);
|
if (null == list || list.isEmpty()) {
|
return;
|
}
|
mf.setRecords(list.size());
|
setCreateInfo(list, mf);
|
|
int rows = batchInserts(basicMapper, list);
|
if (rows > 0) {
|
mf.setEntity(mf.getTab());
|
mf.setTab(tabName);
|
mf.setRows(rows);
|
}
|
}
|
|
/**
|
* 创建KML实体类
|
*/
|
private <T> List<T> createKmlEntity(Class clazz, String wkt, String name, MetaFileEntity mf, String stage) {
|
try {
|
T t = (T) clazz.newInstance();
|
|
setEntityVal(clazz.getSuperclass(), t, "geom", null == wkt ? "null" : String.format("ST_GeomFromText('%s')", wkt));
|
setEntityVal(clazz, t, "pipename", name);
|
setEntityVal(clazz, t, "projname", name);
|
setEntityVal(clazz, t, "medium", mf.getMedium());
|
setEntityVal(clazz, t, "pipestage", stage);
|
|
List<T> list = new ArrayList<>();
|
list.add(t);
|
|
return list;
|
} catch (Exception ex) {
|
log.error(ex.getMessage(), ex);
|
return null;
|
}
|
}
|
|
/**
|
* 设置实体值
|
*/
|
private <T> void setEntityVal(Class clazz, T t, String field, String val) throws Exception {
|
Field pField = clazz.getDeclaredField(field);
|
pField.setAccessible(true);
|
pField.set(t, val);
|
}
|
|
/**
|
* 获取管道阶段
|
*/
|
private String getPipeStage(String tab) {
|
switch (tab) {
|
case "si.pl_pipeline_f":
|
return "可研阶段";
|
case "si.pl_pipeline_b":
|
return "初设阶段";
|
case "si.pl_pipeline_d":
|
return "施工图阶段";
|
case "si.pl_pipeline_a":
|
return "竣工图阶段";
|
default:
|
return null;
|
}
|
}
|
}
|
