package com.landtool.lanbase.modules.res.controller;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.apache.commons.lang.StringEscapeUtils;
|
import org.apache.commons.lang.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.ui.Model;
|
import org.springframework.web.bind.annotation.RequestBody;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.landtool.lanbase.common.annotation.LogAction;
|
import com.landtool.lanbase.common.utils.DateUtils;
|
import com.landtool.lanbase.common.utils.HttpOperateUtils;
|
import com.landtool.lanbase.common.utils.JpinyinUtils;
|
import com.landtool.lanbase.config.SysTemPropertyConfig;
|
import com.landtool.lanbase.modules.api.utils.DeleteFileUtils;
|
import com.landtool.lanbase.modules.org.entity.OrgUnit;
|
import com.landtool.lanbase.modules.org.service.OrgUnitService;
|
import com.landtool.lanbase.modules.org.service.OrgUserService;
|
import com.landtool.lanbase.modules.res.entity.Res_Catalog;
|
import com.landtool.lanbase.modules.res.entity.Res_Ext3D;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtBaseMap;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtBusinessLayer;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtDataBase;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtDataSource;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtFileSource;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtIntegrate;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtInterFaceService;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtMapUrl;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtSpaceServerWithBLOBs;
|
import com.landtool.lanbase.modules.res.entity.Res_ExtThemeMap;
|
import com.landtool.lanbase.modules.res.entity.Res_FileSource_Way;
|
import com.landtool.lanbase.modules.res.entity.Res_Files;
|
import com.landtool.lanbase.modules.res.entity.Res_MainInfo;
|
import com.landtool.lanbase.modules.res.entity.Res_SpacesParam;
|
import com.landtool.lanbase.modules.res.entity.UserDefined.MainInfoJoinRegister;
|
import com.landtool.lanbase.modules.res.service.ResCatalogService;
|
import com.landtool.lanbase.modules.res.service.ResExt3DService;
|
import com.landtool.lanbase.modules.res.service.ResExtBaseMapService;
|
import com.landtool.lanbase.modules.res.service.ResExtBusinessLayerService;
|
import com.landtool.lanbase.modules.res.service.ResExtDataBaseService;
|
import com.landtool.lanbase.modules.res.service.ResExtDataSourceService;
|
import com.landtool.lanbase.modules.res.service.ResExtFileSourceService;
|
import com.landtool.lanbase.modules.res.service.ResExtIntegrateService;
|
import com.landtool.lanbase.modules.res.service.ResExtInterFaceService;
|
import com.landtool.lanbase.modules.res.service.ResExtMapUrlService;
|
import com.landtool.lanbase.modules.res.service.ResExtSpaceServerService;
|
import com.landtool.lanbase.modules.res.service.ResExtThemeMapService;
|
import com.landtool.lanbase.modules.res.service.ResFileSourceWayService;
|
import com.landtool.lanbase.modules.res.service.ResFilesService;
|
import com.landtool.lanbase.modules.res.service.ResMainInfoService;
|
import com.landtool.lanbase.modules.res.service.ResSpacesParamService;
|
import com.landtool.lanbase.modules.sys.controller.AbstractController;
|
import com.landtool.lanbase.modules.sys.service.SysFieldvalueService;
|
|
/**
|
* 功能描述：资源管理 - 资源注册
|
*/
|
@Controller
|
@RequestMapping("/res/ResManage/NewResRegister")
|
public class NewResRegisterController extends AbstractController {
|
@Autowired
|
private SysTemPropertyConfig sysConfig;
|
@Autowired
|
private ResMainInfoService resMainInfoService;
|
@Autowired
|
private ResExtDataBaseService resExtDataBaseService;
|
@Autowired
|
private ResExtDataSourceService resExtDataSourceService;
|
@Autowired
|
private ResExtInterFaceService resExtInterFaceService;
|
@Autowired
|
private ResExtFileSourceService resExtFileSourceService;
|
@Autowired
|
private ResExtIntegrateService resExtIntegrateService;
|
@Autowired
|
private ResExtBaseMapService resExtBaseMapService;
|
@Autowired
|
private ResExtMapUrlService resExtMapUrlService;
|
@Autowired
|
private ResExtThemeMapService resExtThemeMapService;
|
@Autowired
|
private ResExtSpaceServerService resExtSpaceServerService;
|
@Autowired
|
private ResExt3DService resExt3DService;
|
@Autowired
|
private ResExtBusinessLayerService resExtBusinessLayerService;
|
@Autowired
|
private ResFilesService resFilesService;
|
@Autowired
|
private ResFileSourceWayService resFileSourceWayService;
|
|
@Autowired
|
private ResCatalogService resCatalogService;
|
|
@Autowired
|
private OrgUserService orgUserService;
|
|
@Autowired
|
private OrgUnitService orgUnitService;
|
|
@Autowired
|
private SysFieldvalueService FieldUtils;
|
|
@Autowired
|
private ResSpacesParamService resSpacesParamService;
|
|
/**
|
* 数据库表资源拓展页面
|
*/
|
@RequestMapping("/ExtDataBase")
|
public String ExtDataBase(Model model) {
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
return "ResManage/NewResRegister/ExtDataBase";
|
}
|
|
/**
|
* 接口服务资源拓展页面
|
*/
|
@RequestMapping("/ExtInterFaceService")
|
public String ExtInterFaceService(Integer resMainInfoId, Model model) {
|
Res_ExtInterFaceService res_extInterFaceService;
|
if (resMainInfoId != null) {
|
res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(resMainInfoId);//获取接口服务拓展信息
|
if (res_extInterFaceService != null) {
|
model.addAttribute("Res_ExtInterFaceService", res_extInterFaceService);
|
Res_MainInfo res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
model.addAttribute("resMainInfo", res_mainInfo);
|
} else {
|
res_extInterFaceService = new Res_ExtInterFaceService();
|
model.addAttribute("Res_ExtInterFaceService", res_extInterFaceService);
|
model.addAttribute("resMainInfo", new Res_MainInfo());
|
}
|
} else {
|
res_extInterFaceService = new Res_ExtInterFaceService();
|
model.addAttribute("Res_ExtInterFaceService", res_extInterFaceService);
|
model.addAttribute("resMainInfo", new Res_MainInfo());
|
}
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
model.addAttribute("content", res_extInterFaceService.getHelpurl());
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
model.addAttribute("esbWebServiceHost", sysConfig.getEsbWebServiceHost());
|
model.addAttribute("esbHost", sysConfig.getEsbHost());
|
model.addAttribute("esbUrl", sysConfig.getEsbUrl());
|
|
return "ResManage/NewResRegister/ExtInterFaceService";
|
}
|
|
/**
|
* 数据文件资源拓展页面
|
*/
|
@RequestMapping("/ExtFileSource")
|
public String ExtFileSource(Model model) {
|
String unit = "";
|
model.addAttribute("unitConvert", "5");
|
unit = "KB";
|
Res_ExtFileSource resExtFileSource1 = new Res_ExtFileSource();
|
model.addAttribute("Res_ExtFileSource", resExtFileSource1);
|
model.addAttribute("resMainInfo", new Res_MainInfo());
|
|
model.addAttribute("unit", unit);
|
// 获取文档类型列表
|
LinkedHashMap<String, String> filetypelist = FieldUtils.getFieldListByKey("FileType");
|
model.addAttribute("filetypelist", filetypelist);
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
model.addAttribute("ncSyncStorageUrl", sysConfig.getNcStorageUrl().substring(0, sysConfig.getNcStorageUrl().length() - 9) + "jobs/");
|
model.addAttribute("readNcFileURL", sysConfig.getReadNcFileURL());
|
|
return "ResManage/NewResRegister/ExtFileSource";
|
}
|
|
/**
|
* 数据文件下的 展现方式
|
*/
|
@RequestMapping("/ExtPresentationMode")
|
public String ExtPresentationMode(Integer resMainInfoId, Model model) {
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
List<Res_FileSource_Way> list = null;
|
if (resMainInfoId != null) {
|
resFileSourceWayService.selectById(resMainInfoId);
|
}
|
model.addAttribute("FileSourceWay", list);
|
return "ResManage/NewResRegister/ExtPresentationMode";
|
}
|
|
/**
|
* 业务集成资源拓展页面
|
*/
|
@RequestMapping("/ExtIntegrate")
|
public String ExtIntegrate(Model model) {
|
Integer isSetChart = 0;//是否显示模型设置按钮（0不显示1显示）
|
String serverUrl = "";
|
String resolutionBen = "";
|
String resolutionEnd = "";
|
Res_ExtIntegrate resExtIntegrate1 = new Res_ExtIntegrate();
|
model.addAttribute("Res_ExtIntegrate", resExtIntegrate1);
|
model.addAttribute("resMainInfo", new Res_MainInfo());
|
model.addAttribute("isSetChart", isSetChart);
|
model.addAttribute("serverUrl", serverUrl);
|
model.addAttribute("resolutionBen", resolutionBen);
|
model.addAttribute("resolutionEnd", resolutionEnd);
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
|
return "ResManage/NewResRegister/ExtIntegrate";
|
}
|
|
/**
|
* 基础底图资源拓展页面
|
*/
|
@RequestMapping("/ExtBaseMap")
|
public String ExtBaseMap(Integer resMainInfoId, Model model) {
|
Res_ExtMapUrl resExtMapUrl = new Res_ExtMapUrl();
|
Res_ExtBaseMap resExtBaseMap;
|
|
LinkedHashMap<String, String> typeandurlList = FieldUtils.getFieldListByKey("TypeAndURL");//获取地理参考模型列表
|
model.addAttribute("typeandurlList", typeandurlList);
|
String typeandurlListJson = "";
|
for (Map.Entry<String, String> entry : typeandurlList.entrySet()) {
|
if (typeandurlListJson != "") typeandurlListJson += ",";
|
typeandurlListJson += "{key:'" + entry.getKey() + "',value:'" + entry.getValue() + "'}";
|
}
|
model.addAttribute("typeandurlListJson", "[" + typeandurlListJson + "]");
|
if (resMainInfoId != null) {
|
List<Res_ExtMapUrl> resExtMapUrlList = resExtMapUrlService.selectByCondition(resMainInfoId);
|
if (resExtMapUrlList.size() > 0) {
|
resExtMapUrl = resExtMapUrlList.get(0);
|
}
|
resExtBaseMap = resExtBaseMapService.selectByPrimaryKey(resMainInfoId);
|
if (resExtBaseMap != null) {
|
if (resExtBaseMap.getRefmarkinfid() != null) {
|
Res_MainInfo title = resMainInfoService.selectByPrimaryKey(resExtBaseMap.getRefmarkinfid());
|
if (title != null) {
|
model.addAttribute("refmarkinfname", title.getTitle());
|
}
|
}
|
Res_MainInfo res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
model.addAttribute("resMainInfo", res_mainInfo);
|
|
String[] arr = new String[2];
|
arr[0] = "null";
|
arr[1] = "null";
|
if (resExtBaseMap.getDisplaylev() != null) {
|
arr = resExtBaseMap.getDisplaylev().split("-");
|
}
|
model.addAttribute("xianshibiliStart", (arr[0] == null || arr[0].trim().equals("null")) ? "" : arr[0]);
|
model.addAttribute("xianshibiliEnd", (arr[1] == null || arr[1].trim().equals("null")) ? "" : arr[1]);
|
model.addAttribute("resExtBaseMap", resExtBaseMap);
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
} else {
|
resExtBaseMap = new Res_ExtBaseMap();
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
model.addAttribute("resExtBaseMap", resExtBaseMap);
|
model.addAttribute("xianshibiliStart", "");
|
model.addAttribute("xianshibiliEnd", "");
|
}
|
} else {
|
resExtBaseMap = new Res_ExtBaseMap();
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
model.addAttribute("resExtBaseMap", resExtBaseMap);
|
model.addAttribute("xianshibiliStart", "");
|
model.addAttribute("xianshibiliEnd", "");
|
}
|
|
model.addAttribute("resExtMapUrl", resExtMapUrl);
|
LinkedHashMap<String, String> PublishSoftList = FieldUtils.getFieldListByKey("PublishSoft");// 获取发布平台字典列表
|
LinkedHashMap<String, String> BaseMapTypeList = FieldUtils.getFieldListByKey("BaseMapType");// 获取底图类型字典列表
|
LinkedHashMap<String, String> ImageAccuracyList = FieldUtils.getFieldListByKey("ImageAccuracy");// 获取影像精度字典列表
|
model.addAttribute("PublishSoftList", PublishSoftList);
|
model.addAttribute("BaseMapTypeList", BaseMapTypeList);
|
model.addAttribute("ImageAccuracyList", ImageAccuracyList);
|
model.addAttribute("esbHost", sysConfig.getEsbHost());
|
model.addAttribute("esbUrl", sysConfig.getEsbUrl());
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
String oldesbids = resExtBaseMap != null ? resExtMapUrlService.queryRsbidsByResourceid(resMainInfoId) : "";
|
model.addAttribute("oldesbids", oldesbids);
|
model.addAttribute("ipHost", sysConfig.getIpHost());
|
model.addAttribute("gisHost", sysConfig.getGisHost());
|
|
return "ResManage/NewResRegister/ExtBaseMap";
|
}
|
|
/**
|
* 基础底图--关联标注图页面
|
*/
|
@RequestMapping("/GuanLianBiaoZhuTu")
|
public String GuanLianBiaoZhuTu(Model model) {
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
return "/ResManage/NewResRegister/GuanLianBiaoZhuTu";
|
}
|
|
/**
|
* 基础底图--获取关联标注图标注底图目录树
|
* @param resMainInfo
|
* @param parentid
|
*/
|
@RequestMapping("/getBaseMapForBZTree")
|
@ResponseBody
|
public String getBaseMapForBZTree(Res_MainInfo resMainInfo, String parentid) {
|
StringBuilder sb = new StringBuilder();
|
Map<String, Object> map = new HashMap<>();
|
map.put("title", resMainInfo.getTitle());
|
map.put("parentid", parentid);
|
List<Res_Catalog> resCatalogs = resExtBaseMapService.getBaseMapForBZNode(map);
|
|
// 循环构造子目录节点
|
for (Res_Catalog resCatalog : resCatalogs) {
|
Map<String, Object> nodemap = new HashMap<>();
|
nodemap.put("title", resMainInfo.getTitle());
|
nodemap.put("parentid", resCatalog.getCatlogid());
|
int childCount = resExtBaseMapService.getBaseMapForBZTree(nodemap).size();
|
if (childCount > 0) {
|
if (!"".equals(sb.toString())) {
|
sb.append(',');
|
}
|
sb.append("{id: " + resCatalog.getCatlogid() + ",name:'" + resCatalog.getTitle() + "',title:'" + resCatalog.getTitle() + "',isParent: true,iconOpen:'/image/classicons/folderOpen.png',iconClose:'/image/classicons/folder.png'}");
|
} else {
|
if (!getBaseMapForBZTreeNode(nodemap).isEmpty()) {
|
if (!"".equals(sb.toString())) {
|
sb.append(',');
|
}
|
sb.append("{id: " + resCatalog.getCatlogid() + ",name:'" + resCatalog.getTitle() + "',title:'" + resCatalog.getTitle() + "',isParent: true,iconOpen:'/image/classicons/folderOpen.png',iconClose:'/image/classicons/folder.png'}");
|
sb.append(getBaseMapForBZTreeNode(nodemap));
|
}
|
}
|
}
|
|
List<Res_MainInfo> list = resExtBaseMapService.getBaseMapForBZTree(map);
|
// 循环构造资源节点
|
for (Res_MainInfo resMainInfo1 : list) {
|
if (!"".equals(sb.toString())) {
|
sb.append(',');
|
}
|
sb.append("{id: 'ZiYuan_" + resMainInfo1.getResourceid() + "',name:'" + resMainInfo1.getTitle() + "', title: '" + resMainInfo1.getDatasources() + "',isParent:false,icon:'/image/classicons/KJ_JCDT.png'}");
|
}
|
System.out.println(sb.toString());
|
return "[" + sb.toString() + "]";
|
}
|
|
public String getBaseMapForBZTreeNode(Map<String, Object> map) {
|
StringBuilder sb = new StringBuilder();
|
List<Res_Catalog> resCatalogs = resExtBaseMapService.getBaseMapForBZNode(map);
|
// 循环构造子目录节点
|
for (Res_Catalog resCatalog : resCatalogs) {
|
Map<String, Object> nodemap = new HashMap<>();
|
nodemap = map;
|
nodemap.put("parentid", resCatalog.getCatlogid());
|
int childCount = resExtBaseMapService.getBaseMapForBZTree(nodemap).size();
|
if (childCount > 0) {
|
if (!"".equals(sb.toString())) {
|
sb.append(',');
|
}
|
sb.append("{id: " + resCatalog.getCatlogid() + ",name:'" + resCatalog.getTitle() + "',title:'" + resCatalog.getTitle() + "',isParent: true}");
|
} else {
|
if (!getBaseMapForBZTreeNode(nodemap).isEmpty()) {
|
if (!"".equals(sb.toString())) {
|
sb.append(',');
|
}
|
sb.append("{id: " + resCatalog.getCatlogid() + ",name:'" + resCatalog.getTitle() + "',title:'" + resCatalog.getTitle() + "',isParent: true,icon:'/image/classicons/defaulticon.png'}");
|
sb.append(getBaseMapForBZTreeNode(nodemap));
|
}
|
}
|
}
|
System.out.println(sb.toString());
|
return sb.toString();
|
}
|
|
/**
|
* 专题地图资源拓展页面
|
*/
|
@RequestMapping("/ExtThemeMap")
|
public String ExtThemeMap(Integer resMainInfoId, Model model) {
|
Res_ExtMapUrl resExtMapUrl = new Res_ExtMapUrl();
|
Res_ExtThemeMap resExtThemeMap;
|
|
LinkedHashMap<String, String> typeandurlList = FieldUtils.getFieldListByKey("TypeAndURL");//获取地理参考模型列表
|
model.addAttribute("typeandurlList", typeandurlList);
|
String typeandurlListJson = "";
|
for (Map.Entry<String, String> entry : typeandurlList.entrySet()) {
|
if (typeandurlListJson != "") typeandurlListJson += ",";
|
typeandurlListJson += "{key:'" + entry.getKey() + "',value:'" + entry.getValue() + "'}";
|
}
|
model.addAttribute("typeandurlListJson", "[" + typeandurlListJson + "]");
|
|
if (resMainInfoId != null) {
|
List<Res_ExtMapUrl> resExtMapUrlList = resExtMapUrlService.selectByCondition(resMainInfoId);
|
if (resExtMapUrlList.size() > 0) {
|
resExtMapUrl = resExtMapUrlList.get(0);
|
}
|
resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resMainInfoId);
|
if (resExtThemeMap != null) {
|
Res_MainInfo res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
model.addAttribute("resMainInfo", res_mainInfo);
|
model.addAttribute("resExtThemeMap", resExtThemeMap);
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
|
if (resExtThemeMap.getDefaultlayerset() != null) {
|
Res_MainInfo res_mainInfo1 = resMainInfoService.selectByPrimaryKey(resExtThemeMap.getDefaultlayerset());
|
String name = res_mainInfo1.getTitle();
|
model.addAttribute("baseMapLayerName", name);
|
}
|
|
LinkedHashMap<Integer, String> tucengList = new LinkedHashMap<Integer, String>();
|
if (resExtThemeMap.getSublayerset() != null && !resExtThemeMap.getSublayerset().isEmpty()) {
|
String[] tuceng = resExtThemeMap.getSublayerset().split(",");
|
for (int i = 0; i < tuceng.length; i++) {
|
Res_MainInfo resMainInfo = resMainInfoService.selectByPrimaryKey(Integer.parseInt(tuceng[i]));
|
if (resMainInfo != null) {
|
tucengList.put(resMainInfo.getResourceid(), resMainInfo.getTitle());
|
}
|
}
|
}
|
model.addAttribute("tucengList", tucengList);
|
} else {
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
resExtThemeMap = new Res_ExtThemeMap();
|
model.addAttribute("resExtThemeMap", resExtThemeMap);
|
model.addAttribute("tucengList", new LinkedHashMap<Integer, String>());
|
}
|
} else {
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
resExtThemeMap = new Res_ExtThemeMap();
|
model.addAttribute("resExtThemeMap", resExtThemeMap);
|
model.addAttribute("tucengList", new LinkedHashMap<Integer, String>());
|
}
|
|
model.addAttribute("resExtMapUrl", resExtMapUrl);
|
LinkedHashMap<String, String> PublishSoftList = FieldUtils.getFieldListByKey("PublishSoft");//获取发布平台字典列表
|
LinkedHashMap<String, String> typeList = FieldUtils.getFieldListByKey("ThemeMapType");//获取发布平台字典列表
|
model.addAttribute("PublishSoftList", PublishSoftList);
|
model.addAttribute("typeList", typeList);
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
model.addAttribute("esbHost", sysConfig.getEsbHost());
|
model.addAttribute("esbUrl", sysConfig.getEsbUrl());
|
String oldesbids = resExtThemeMap != null ? resExtMapUrlService.queryRsbidsByResourceid(resMainInfoId) : "";
|
model.addAttribute("oldesbids", oldesbids);
|
model.addAttribute("ipHost", sysConfig.getIpHost());
|
model.addAttribute("gisHost", sysConfig.getGisHost());
|
|
return "ResManage/NewResRegister/ExtThemeMap";
|
}
|
|
/**
|
* 空间分析资源拓展页面
|
*/
|
@RequestMapping("/ExtSpaceServer")
|
public String ExtSpaceServer(Model model) {
|
Res_ExtSpaceServerWithBLOBs resExtSpaceServer = new Res_ExtSpaceServerWithBLOBs();
|
model.addAttribute("resExtSpaceServer", resExtSpaceServer);
|
model.addAttribute("resMainInfo", new Res_MainInfo());
|
model.addAttribute("content", resExtSpaceServer.getHelpurl());
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("jspwebroot", sysConfig.getPubzyWebRoot().replace("javapubzy/", ""));
|
return "ResManage/NewResRegister/ExtSpaceServer";
|
}
|
|
/**
|
* 空间分析--空间服务参数页面
|
*/
|
@RequestMapping("/ExtSpaceServerParams")
|
public String ExtSpaceServerParams(Integer resMainInfoId, Model model) {
|
List<Res_SpacesParam> res_spacesParams = new ArrayList<>();
|
res_spacesParams = resSpacesParamService.selectByResSourceId(resMainInfoId);
|
model.addAttribute("res_spacesParams", res_spacesParams);
|
|
return "ResManage/NewResRegister/ExtSpaceServerParams";
|
}
|
|
/**
|
* 空间服务参数查看页面
|
* @param model
|
* @param paramid
|
* @param resourceid
|
*/
|
@RequestMapping("/SpaceParameters")
|
public String SpaceParameters(Model model, Integer paramid, Integer resourceid) {
|
model.addAttribute("resourceid", resourceid);
|
model.addAttribute("paramid", paramid);
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
return "ResManage/ResRegister/SpaceParameters";
|
}
|
|
/**
|
* 空间服务参数编辑页面
|
* @param model
|
* @param paramid
|
* @param resourceid
|
*/
|
@RequestMapping("/SpaceParameters_Edit")
|
public String SpaceParametersEdit(Model model, Integer paramid, Integer resourceid) {
|
Res_SpacesParam resSpacesParam = new Res_SpacesParam();
|
resSpacesParam.setResourceid(resourceid);
|
if (paramid != null) {
|
resSpacesParam = resSpacesParamService.selectByPrimaryKey(paramid);
|
}
|
model.addAttribute("resSpacesParam", resSpacesParam);
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
return "ResManage/ResRegister/SpaceParameters_Edit";
|
}
|
|
/**
|
* 三维模型资源拓展页面
|
*/
|
@RequestMapping("/Ext3D")
|
public String Ext3D(Model model) {
|
Res_Ext3D res_ext3D1 = new Res_Ext3D();
|
model.addAttribute("resExt3d", res_ext3D1);
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
model.addAttribute("ipHost", sysConfig.getIpHost());
|
model.addAttribute("gisHost", sysConfig.getGisHost());
|
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("ipHost", sysConfig.getIpHost());
|
model.addAttribute("gisHost", sysConfig.getGisHost());
|
return "ResManage/NewResRegister/Ext3D";
|
}
|
|
/**
|
* 业务图层资源拓展页面
|
*/
|
@RequestMapping("/ExtBusinessLayer")
|
public String ExtBusinessLayer(Integer resMainInfoId, Model model) {
|
Res_ExtMapUrl resExtMapUrl = new Res_ExtMapUrl();
|
Res_ExtBusinessLayer resExtBusinessLayer;
|
|
LinkedHashMap<String, String> typeandurlList = FieldUtils.getFieldListByKey("TypeAndURL");// 获取地理参考模型列表
|
model.addAttribute("typeandurlList", typeandurlList);
|
String typeandurlListJson = "";
|
|
for (Map.Entry<String, String> entry : typeandurlList.entrySet()) {
|
if (typeandurlListJson != "") typeandurlListJson += ",";
|
typeandurlListJson += "{key:'" + entry.getKey() + "',value:'" + entry.getValue() + "'}";
|
}
|
model.addAttribute("typeandurlListJson", "[" + typeandurlListJson + "]");
|
|
if (resMainInfoId != null) {
|
List<Res_ExtMapUrl> resExtMapUrlList = resExtMapUrlService.selectByCondition(resMainInfoId);
|
if (resExtMapUrlList.size() > 0) {
|
resExtMapUrl = resExtMapUrlList.get(0);
|
}
|
resExtBusinessLayer = resExtBusinessLayerService.selectByPrimaryKey(resMainInfoId);
|
if (resExtBusinessLayer != null) {
|
Res_MainInfo res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
model.addAttribute("resMainInfo", res_mainInfo);
|
model.addAttribute("resExtBusinessLayer", resExtBusinessLayer);
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
} else {
|
resExtBusinessLayer = new Res_ExtBusinessLayer();
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
model.addAttribute("resExtBusinessLayer", resExtBusinessLayer);
|
}
|
} else {
|
resExtBusinessLayer = new Res_ExtBusinessLayer();
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
model.addAttribute("resExtBusinessLayer", resExtBusinessLayer);
|
}
|
|
model.addAttribute("resExtMapUrl", resExtMapUrl);
|
LinkedHashMap<String, String> PublishSoftList = FieldUtils.getFieldListByKey("PublishSoft");// 获取发布平台字典列表
|
model.addAttribute("PublishSoftList", PublishSoftList);
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
model.addAttribute("esbHost", sysConfig.getEsbHost());
|
model.addAttribute("esbUrl", sysConfig.getEsbUrl());
|
String oldesbids = resExtBusinessLayer != null ? resExtMapUrlService.queryRsbidsByResourceid(resMainInfoId) : "";
|
model.addAttribute("oldesbids", oldesbids);
|
model.addAttribute("ipHost", sysConfig.getIpHost());
|
model.addAttribute("gisHost", sysConfig.getGisHost());
|
|
return "ResManage/NewResRegister/ExtBusinessLayer";
|
}
|
|
/**
|
* ESB代理通用页面
|
*/
|
@RequestMapping("/ExtMapUrl")
|
public String ExtMapUrl(Integer resMainInfoId, Model model) {
|
Res_ExtMapUrl resExtMapUrl = resExtMapUrlService.selectByCondition(resMainInfoId).size() > 0 ? resExtMapUrlService.selectByCondition(resMainInfoId).get(0) : new Res_ExtMapUrl();
|
model.addAttribute("resExtMapUrl", resExtMapUrl);
|
if (resMainInfoId != null) {
|
Res_MainInfo res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
model.addAttribute("resMainInfo", res_mainInfo);
|
} else {
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
model.addAttribute("resMainInfo", res_mainInfo);
|
}
|
return "ResManage/NewResRegister/ExtMapUrl";
|
}
|
|
/**
|
* 资源向导编辑页面
|
*/
|
@RequestMapping("/ResEdit")
|
public String Edit(Model model, Long resMainInfoId) {
|
if (resMainInfoId != null) {
|
Res_MainInfo resMainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId.intValue());
|
HashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
model.addAttribute("resourceclass", ResourceTypeList.get(resMainInfo.getResourceclass()));
|
}
|
String pubzyWebRoot = sysConfig.getPubzyWebRoot();
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
model.addAttribute("pubzyWebRoot", pubzyWebRoot);
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("jspwebroot", pubzyWebRoot.replace("javapubzy/", ""));// 临时处理
|
|
return "ResManage/NewResRegister/Edit";
|
}
|
|
/**
|
* 资源类型选择页面
|
*/
|
@RequestMapping("/ResResourceClass")
|
public String ResResourceClass(Model model) {
|
String pubzyWebRoot = sysConfig.getPubzyWebRoot();
|
model.addAttribute("pubzyWebRoot", pubzyWebRoot);
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("jspwebroot", pubzyWebRoot.replace("javapubzy/", ""));// 临时处理
|
return "ResManage/NewResRegister/ResResourceClass";
|
}
|
|
/**
|
* 基本信息
|
*/
|
@RequestMapping("/MainInfo")
|
public String MainInfo(HttpServletRequest request, Model model, Long resMainInfoId) throws IOException {
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
Res_Catalog res_catalog = new Res_Catalog();
|
String newDate = sdf.format(new Date());
|
String Imagelujin = null;
|
int auditstatus = -1;// 审核状态
|
// 获取当前登录人id name 还有对应的单位id name
|
Long userid = getUserId();
|
|
// 修改
|
if (resMainInfoId != null) {
|
res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId.intValue());
|
String Pubdate = sdf.format(res_mainInfo.getPubdate());
|
if (res_mainInfo.getProductiontime() != null) {
|
String productiontimes = sdf.format(res_mainInfo.getProductiontime());
|
model.addAttribute("productiontime", productiontimes);
|
}
|
model.addAttribute("Pubdate", Pubdate);
|
if (res_mainInfo.getCatlogid() != null) {
|
res_catalog = resCatalogService.selectByPrimaryKey(res_mainInfo.getCatlogid());
|
if (res_catalog != null) {
|
model.addAttribute("catlogtitle", res_catalog.getTitle());
|
}
|
}
|
if (res_mainInfo.getImgurl() != null && res_mainInfo.getImgurl() != "") {
|
if (res_mainInfo.getImgurl().startsWith("Atkas")) {//图集
|
Imagelujin = "/image/" + res_mainInfo.getImgurl();
|
} else {
|
StringBuffer url = request.getRequestURL();
|
String ip = "/uploadPath/";
|
Imagelujin = ip + res_mainInfo.getImgurl();
|
}
|
}
|
// modified by qufangxu 信创环境下，若 res_mainInfo.getAdministrativeid() = ' ',会返回单点登录页面，具体原因未知。 解决办法：提前去除空格、制表符
|
String administrativeid = (String) res_mainInfo.getAdministrativeid();// 数据覆盖范围--行政区划Id
|
String finalValue = null;
|
if (StringUtils.isNotEmpty(administrativeid)){
|
finalValue = administrativeid.trim();
|
}
|
if (StringUtils.isNotEmpty(finalValue)) {
|
String getRegionInfourl = sysConfig.getApiServer() + "/api/org/region/getById/" + administrativeid;
|
String jsonStr = HttpOperateUtils.httpGet(getRegionInfourl.trim());
|
if (jsonStr != null && !jsonStr.isEmpty()) {
|
JSONObject item = JSONObject.parseObject(jsonStr);
|
String regionname = item.getString("regionname");
|
model.addAttribute("administrativename", regionname);
|
}
|
}
|
// 审核状态
|
if (res_mainInfo.getAuditstatus() != null) {
|
auditstatus = res_mainInfo.getAuditstatus();
|
}
|
model.addAttribute("chinesename", orgUserService.queryObject(res_mainInfo.getCreateuserid()).getChinesename());
|
if (res_mainInfo.getPubunitid() == 0) {
|
OrgUnit orgunit = orgUserService.getDefaultUnit(res_mainInfo.getCreateuserid());
|
model.addAttribute("unitname", orgunit.getUnitname());
|
res_mainInfo.setPubunitid(orgunit.getUnitid().intValue());
|
} else {
|
OrgUnit orgunit = orgUnitService.getUnitById(res_mainInfo.getPubunitid().longValue());
|
model.addAttribute("unitname", orgunit.getUnitname());
|
}
|
} else {
|
//新增
|
OrgUnit orgunit = orgUserService.getDefaultUnit(userid);
|
String unitname = "";
|
if (orgunit.getUnitid() != null) {
|
res_mainInfo.setPubunitid(orgunit.getUnitid().intValue());
|
unitname = orgunit.getUnitname();
|
}
|
res_mainInfo.setCreateuserid(userid);
|
// modified by qufangxu
|
res_mainInfo.setInsteadaudit(0);
|
model.addAttribute("loginname", getUser().getLoginname());
|
model.addAttribute("unitname", unitname);
|
model.addAttribute("Pubdate", newDate);
|
model.addAttribute("chinesename", getUser().getChinesename());
|
}
|
HashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
//获取数据来源列表
|
LinkedHashMap<String, String> DataSourceList = FieldUtils.getDataSourceList();
|
HashMap<String, String> SharProtocolList = FieldUtils.getFieldListByKey("SharProtocol");// 获取共享协议列表
|
List<String> list = resMainInfoService.selectTopHotSearch();
|
String[] KeywordsList = new String[list.size()];// 获取关键字列表
|
for (int i = 0; i < list.size(); i++) {
|
KeywordsList[i] = list.get(i);
|
}
|
//换地址
|
if (res_mainInfo != null && res_mainInfo.getDesurl() != null && res_mainInfo.getDesurl().indexOf("diydes") != -1 && res_mainInfo.getDesurl().indexOf(res_mainInfo.getResourceid().toString()) != -1) {
|
String url = sysConfig.getUploadRootPath() + res_mainInfo.getDesurl();
|
res_mainInfo.setDesurl(url);
|
}
|
model.addAttribute("datasourcelist", DataSourceList);
|
model.addAttribute("mainInfo", res_mainInfo);
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
model.addAttribute("ResourceTypeList", ResourceTypeList);
|
model.addAttribute("Imagelujin", Imagelujin);
|
model.addAttribute("auditstatus", auditstatus);
|
model.addAttribute("SharProtocolList", SharProtocolList);
|
model.addAttribute("KeywordsList", KeywordsList);
|
|
HashMap<String, String> UpdateTimesList = FieldUtils.getFieldListByKey("UpdateTimes");// 获取更新频率列表
|
model.addAttribute("UpdateTimesList", UpdateTimesList);
|
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
//判断当前用户是否是管理员，是管理员或是未提交的资源才可以修改资源相关信息
|
model.addAttribute("admin", true);
|
} else {
|
model.addAttribute("admin", false);
|
}
|
return "ResManage/NewResRegister/MainInfo";
|
}
|
|
/**
|
* 访问附件管理数据图层信息页面
|
*/
|
@RequestMapping("/ResFiles")
|
public String ResFiles(int resMainInfoId, Model datamodel) {
|
List<Res_Files> List = resFilesService.selectDataListForResourceid(resMainInfoId);
|
return "ResManage/NewResRegister/ResFiles";
|
}
|
|
/**
|
* 插入资源编辑页面内容
|
*/
|
@RequestMapping("ziYuanInsert")
|
@ResponseBody
|
@LogAction("资源管理,资源发布,资源新增,新增|zy")
|
public String ziYuanInsert(MainInfoJoinRegister mainInfoJoinRegister) {
|
Res_MainInfo resMainInfo = mainInfoJoinRegister.getResMainInfo();
|
String shortPinYin = JpinyinUtils.changeToGetShortPinYin((String) resMainInfo.getTitle());// 获取拼音首字母
|
resMainInfo.setPingyinfiirst(shortPinYin);
|
resMainInfo.setAuditstatus(0);// 设置资源状态为未提交
|
resMainInfo.setResourcestatus(0);// 设置资源服务状态为正常
|
resMainInfo.setEspproxy(0);// 设置是否代理为0：false
|
resMainInfo.setDisplayby2d(0);// 设置是否支持二维展示为0：不支持
|
resMainInfo.setDisplayby3d(0);// 设置是否支持三维展示为0“不支持
|
resMainInfo.setPubdate(DateUtils.getFunllDate(resMainInfo.getPubdate()));
|
if (resMainInfo.getDesurl() != null && resMainInfo.getDesurl().indexOf("diydes") != -1) {//换地址
|
String url = resMainInfo.getDesurl().replace(sysConfig.getUploadRootPath(), "");
|
resMainInfo.setDesurl(url);
|
}
|
int result = resMainInfoService.insertSelective(resMainInfo);
|
if (result == 1) {//新增成功，插入拓展表信息
|
String leixin = resMainInfo.getResourceclass();
|
//alert ykm 2019/02/26
|
if(leixin.equals("KJ_SWMX") || leixin.equals("KJ_SWDX") || leixin.equals("KJ_SWYX")) leixin = "KJ_SW";
|
switch (leixin) {
|
case "SJKB":
|
saveDataBase(mainInfoJoinRegister.getResExtDataBase());
|
break;
|
case "JKFW":
|
saveInterFaceService(mainInfoJoinRegister.getResExtInterFaceService());
|
saveFileData(mainInfoJoinRegister.getResFiles(), mainInfoJoinRegister.getSavedsizenum(), mainInfoJoinRegister.getFiletype());
|
break;
|
case "SJWJ":
|
saveExtFileSource(mainInfoJoinRegister.getResExtFileSource(), mainInfoJoinRegister.getSavedsizenum());
|
saveFileSourceWay(mainInfoJoinRegister.getResMainInfo(), mainInfoJoinRegister.getExtMapUrlStr());
|
break;
|
case "YWJC":
|
saveExtIntegrate(mainInfoJoinRegister.getResExtIntegrate());
|
break;
|
case "KJ_JCDT":
|
saveBaseMap(mainInfoJoinRegister.getResExtBaseMap(), mainInfoJoinRegister.getXianshibiliStart(), mainInfoJoinRegister.getXianshibiliEnd(), mainInfoJoinRegister.getExtMapUrlStr());
|
break;
|
case "KJ_ZTDT":
|
saveThemeMap(mainInfoJoinRegister.getResExtThemeMap(), mainInfoJoinRegister.getExtMapUrlStr());
|
break;
|
case "KJ_KJFX":
|
saveSpaceServer(mainInfoJoinRegister.getResExtSpaceServerWithBLOBs());
|
saveFileData(mainInfoJoinRegister.getResFiles(), mainInfoJoinRegister.getSavedsizenum(), mainInfoJoinRegister.getFiletype());
|
break;
|
// case "KJ_SWMX":
|
case "KJ_SW": //三维类型，三维模型，三维地形，三维影像
|
save3D(mainInfoJoinRegister.getResExt3D());
|
break;
|
case "KJ_YWTC":
|
saveBusinessLayer(mainInfoJoinRegister.getResExtBusinessLayer(), mainInfoJoinRegister.getExtMapUrlStr());
|
break;
|
}
|
resMainInfo.setOrderid(resMainInfo.getResourceid());
|
resMainInfoService.updateByPrimaryKeySelective(resMainInfo);
|
Object resourceClass = resMainInfo.getResourceclass();
|
}
|
return "{'result':'" + result + "','ziyuanId':'" + resMainInfo.getResourceid() + "','ziyuanClass':'" + resMainInfo.getResourceclass() + "'}";
|
}
|
|
//保存数据文件
|
@ResponseBody
|
public int saveDataBase(Res_ExtDataBase record) {
|
Res_ExtDataBase resExtDataBase = resExtDataBaseService.selectByMainInfoId(record.getResourceid());
|
if (resExtDataBase == null) {
|
//添加
|
Res_ExtDataSource res_extDataSource = resExtDataSourceService.selectByPrimaryKey(record.getDatasourceid());
|
if (!res_extDataSource.getDatabasetype().equals("Oracle")) {
|
if (record.getSpacename() != null) {
|
record.setSpacename(null);
|
}
|
}
|
return resExtDataBaseService.insertSelective(record);
|
} else {
|
//更新
|
Res_ExtDataSource res_extDataSource = resExtDataSourceService.selectByPrimaryKey(record.getDatasourceid());
|
if (!res_extDataSource.getDatabasetype().equals("Oracle")) {
|
if (record.getSpacename() != null) {
|
record.setSpacename(null);
|
}
|
}
|
return resExtDataBaseService.updateByPrimaryKey(record);
|
}
|
}
|
|
//保存接口服务
|
@ResponseBody
|
public int saveInterFaceService(Res_ExtInterFaceService entity) {
|
Res_ExtInterFaceService res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(entity.getResourceid());
|
int result = 0;
|
if (res_extInterFaceService == null) {
|
resExtInterFaceService.insertSelective(entity);//添加
|
} else {
|
resExtInterFaceService.updateByPrimaryKeySelective(entity);//更新
|
}
|
return result;
|
}
|
|
//保存数据文件
|
@ResponseBody
|
public int saveExtFileSource(Res_ExtFileSource record, double savedsizenum) {
|
record.setFilesize(savedsizenum);
|
record.setServerurl(StringEscapeUtils.unescapeHtml(record.getServerurl()));
|
Res_ExtFileSource resExtFileSource = resExtFileSourceService.selectByPrimaryKey(record.getResourceid());
|
if (resExtFileSource == null) {
|
// 添加
|
if (record.getDownloadmodel().equals("FTP")) { // 把不属于FTP的字段设置为空
|
record.setGettype(null);
|
} else if (record.getDownloadmodel().equals("HTTP")) {
|
record.setFtpusername(null);
|
record.setFtppwd(null);
|
}
|
if (record.getSourcetype().equals("文件")) {
|
replaceRoute(record.getServerurl(), "temp");
|
record.setServerurl(record.getServerurl().replace("temp/", ""));
|
}
|
return resExtFileSourceService.insertSelective(record);
|
} else {
|
// 更新
|
if (record.getSourcetype().equals("文件")) {
|
replaceRoute(record.getServerurl(), "temp");
|
if (!record.getServerurl().equals("") && !resExtFileSource.getServerurl().equals("") && resExtFileSource.getStoragemode().equals("本地")) {
|
String path = resExtFileSource.getServerurl();
|
path = sysConfig.getUploadPath() + path;
|
File file = new File(path);
|
if (file.exists()) {
|
DelectEquealFile(record.getServerurl(), resExtFileSource.getServerurl());
|
}
|
}
|
record.setServerurl(record.getServerurl().replace("temp/", ""));
|
}
|
if (record.getDownloadmodel().equals("FTP")) {
|
record.setGettype(null);
|
} else if (record.getDownloadmodel().equals("HTTP")) {
|
record.setFtpusername(null);
|
record.setFtppwd(null);
|
}
|
// 如果文件资源类型改变则把原有的文件删除
|
if (!record.getSourcetype().equals(resExtFileSource.getSourcetype()) || record.getStoragemode().equals("远程")) {
|
String path = resExtFileSource.getServerurl();
|
if (resExtFileSource.getSourcetype().equals("文件夹") && resExtFileSource.getStoragemode().equals("本地")) {
|
path = sysConfig.getUploadPath() + path;
|
File file = new File(path);
|
if (file.exists()) {
|
DeleteFileUtils.deletefileUtils(path);
|
}
|
}
|
if (resExtFileSource.getSourcetype().equals("文件") && resExtFileSource.getStoragemode().equals("本地")) {
|
path = sysConfig.getUploadPath() + path;
|
File file = new File(path);
|
if (file.exists()) {
|
DeleteFileUtils.deletefileUtils(path);
|
}
|
}
|
}
|
return resExtFileSourceService.updateByPrimaryKey(record);
|
}
|
}
|
|
//保存业务集成
|
@ResponseBody
|
public int saveExtIntegrate(Res_ExtIntegrate record) {
|
Res_ExtIntegrate resExtIntegrate = resExtIntegrateService.selectByPrimaryKey(record.getResourceid());
|
if (record.getServerurl() != null && record.getServerurl().length() > 0) {
|
record.setServerurl(StringEscapeUtils.unescapeHtml(record.getServerurl()));
|
}
|
if (resExtIntegrate == null) {
|
//添加
|
if (record.getIntegratetype().equals("页面集成")) {
|
String showmodel = record.getShowmodel();
|
int id = record.getResourceid();
|
String url = record.getServerurl();
|
String type = record.getIntegratetype();
|
Res_ExtIntegrate res_extIntegrate = new Res_ExtIntegrate();
|
res_extIntegrate.setResourceid(id);
|
res_extIntegrate.setIntegratetype(type);
|
res_extIntegrate.setServerurl(url);
|
res_extIntegrate.setShowmodel(showmodel);
|
res_extIntegrate.setResolution(record.getResolution());
|
return resExtIntegrateService.insertSelective(res_extIntegrate);
|
}
|
if (record.getIntegratetype().equals("数据集成")) {
|
if (record.getShowmodel() != null) {
|
record.setShowmodel(null);
|
record.setResolution(null);
|
}
|
return resExtIntegrateService.insertSelective(record);
|
}
|
} else {
|
//更新
|
if (record.getIntegratetype().equals("页面集成")) {
|
String showmodel = record.getShowmodel();
|
int id = record.getResourceid();
|
String url = record.getServerurl();
|
String type = record.getIntegratetype();
|
Res_ExtIntegrate res_extIntegrate = new Res_ExtIntegrate();
|
res_extIntegrate.setResourceid(id);
|
res_extIntegrate.setIntegratetype(type);
|
res_extIntegrate.setServerurl(url);
|
res_extIntegrate.setShowmodel(showmodel);
|
res_extIntegrate.setResolution(record.getResolution());
|
return resExtIntegrateService.updateByPrimaryKeyWithBLOBs(res_extIntegrate);
|
}
|
if (record.getIntegratetype().equals("数据集成")) {
|
if (resExtIntegrate.getShowmodel() != null) { //集成类型改变，如果数据库的值不为空则清空
|
record.setShowmodel(null);
|
record.setResolution(null);
|
}
|
if (resExtIntegrate.getChartmodel() != null) {
|
record.setChartmodel(resExtIntegrate.getChartmodel());
|
}
|
if (resExtIntegrate.getChartheight() != null) {
|
record.setChartheight(resExtIntegrate.getChartheight());
|
}
|
if (resExtIntegrate.getChartwidth() != null) {
|
record.setChartwidth(resExtIntegrate.getChartwidth());
|
}
|
return resExtIntegrateService.updateByPrimaryKeyWithBLOBs(record);
|
}
|
}
|
return 0;
|
}
|
|
//保存基础底图
|
@ResponseBody
|
public int saveBaseMap(Res_ExtBaseMap record, String xianshibiliStart, String xianshibiliEnd, String extMapUrlStr) {
|
// 插入资源支持协议与地址表
|
resExtMapUrlService.deleteAndInsertMapUrlArray(record.getResourceid(), extMapUrlStr);
|
// 判断 id是否存在 存在就更新 不存在就 添加
|
Res_ExtBaseMap resExtBaseMap = resExtBaseMapService.selectByPrimaryKey(record.getResourceid());
|
if (!xianshibiliStart.isEmpty() && !xianshibiliEnd.isEmpty()) {
|
record.setDisplaylev(xianshibiliStart + "-" + xianshibiliEnd);
|
}
|
record.setResourceid(record.getResourceid());
|
if (resExtBaseMap == null) {
|
// 添加
|
if (!record.getBasemaptype().equals("影像")) { // 判断底图类型是否是影像，不是则令影像精度为空
|
record.setImageaccuracy(null);
|
}
|
return resExtBaseMapService.insertSelective(record);
|
} else {
|
// 更新
|
if (!record.getBasemaptype().equals("影像")) { // 判断底图类型是否是影像，不是则令影像精度为空
|
record.setImageaccuracy(null);
|
}
|
return resExtBaseMapService.updateByPrimaryKey(record);
|
}
|
}
|
|
//保存专题地图
|
@ResponseBody
|
public int saveThemeMap(Res_ExtThemeMap record, String extMapUrlStr) {
|
// 插入资源支持协议与地址表
|
resExtMapUrlService.deleteAndInsertMapUrlArray(record.getResourceid(), extMapUrlStr);
|
Res_ExtThemeMap resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(record.getResourceid());
|
if (resExtThemeMap == null) {
|
//添加
|
if (!record.getLegendurl().isEmpty()) {
|
replaceRoute("temp/ResExtThemMapServer/" + record.getLegendurl(), "temp/");
|
}
|
return resExtThemeMapService.insertSelective(record);
|
} else {
|
//更新
|
String path = sysConfig.getUploadPath() + "ResExtThemMapServer/" + resExtThemeMap.getLegendurl();
|
File file = new File(path);
|
if (file.exists()) {
|
file.delete();
|
}
|
if (!record.getLegendurl().isEmpty()) {
|
replaceRoute("temp/ResExtThemMapServer/" + record.getLegendurl(), "temp/");
|
}
|
return resExtThemeMapService.updateByPrimaryKeyWithBLOBs(record);
|
}
|
}
|
|
//保存空间分析
|
@ResponseBody
|
public int saveSpaceServer(Res_ExtSpaceServerWithBLOBs record) {
|
Res_ExtSpaceServerWithBLOBs resExtSpaceServerWithBLOBs = resExtSpaceServerService.selectByPrimaryKey(record.getResourceid());
|
if (record.getHelpurl().length() != 0) {
|
record.setHelpurl(StringEscapeUtils.unescapeHtml(record.getHelpurl()));
|
}
|
if (resExtSpaceServerWithBLOBs == null) {
|
//添加
|
return resExtSpaceServerService.insertSelective(record);
|
} else {
|
//更新
|
return resExtSpaceServerService.updateByPrimaryKeyWithBLOBs(record);
|
}
|
}
|
|
//保存三维模型
|
@ResponseBody
|
public int save3D(Res_Ext3D record) {
|
Res_Ext3D res_ext3D = resExt3DService.selectByPrimaryKey(record.getResourceid());
|
if (res_ext3D == null) {
|
//添加
|
return resExt3DService.insertSelective(record);
|
} else {
|
//更新
|
return resExt3DService.updateByPrimaryKeySelective(record);
|
}
|
}
|
|
//保存业务图层
|
@ResponseBody
|
public int saveBusinessLayer(Res_ExtBusinessLayer record, String extMapUrlStr) {
|
// 插入资源支持协议与地址表
|
resExtMapUrlService.deleteAndInsertMapUrlArray(record.getResourceid(), extMapUrlStr);
|
// 判断 id是否存在 存在就更新 不存在就 添加
|
Res_ExtBusinessLayer resExtBusinessLayer = resExtBusinessLayerService.selectByPrimaryKey(record.getResourceid());
|
if (resExtBusinessLayer == null) {
|
// 添加
|
return resExtBusinessLayerService.insertSelective(record);
|
} else {
|
// 更新
|
return resExtBusinessLayerService.updateByPrimaryKeySelective(record);
|
}
|
}
|
|
//保存相关附件
|
@ResponseBody
|
public int saveFileData(Res_Files record, double savedsizenum, String filetype) {
|
record.setFilesize(savedsizenum);
|
record.setFiletype(filetype);
|
replaceRoute(record.getServerurl(), "temp");
|
record.setServerurl(record.getServerurl().replace("temp/", ""));
|
return resFilesService.insertSelective(record);
|
}
|
|
//保存数据文件展现方式
|
@ResponseBody
|
public int saveFileSourceWay(Res_MainInfo resMainInfo, String extMapUrlStr) {
|
// 删除id 对应的所有文件展示方式
|
try {
|
if (resMainInfo.getResourceid() != null) {
|
resFileSourceWayService.deleteByPrimaryKey(resMainInfo.getResourceid());
|
}
|
if (!extMapUrlStr.equals("")) {
|
String[] extMapUrlArray = extMapUrlStr.split("\\|");
|
// 插入资源支持协议与地址表
|
for (int i = 0; i < extMapUrlArray.length; i++) {
|
String[] extMapUrlArray2 = extMapUrlArray[i].split(",");
|
String Showway = extMapUrlArray2[0];
|
String url = extMapUrlArray2[1];
|
String remark = extMapUrlArray2[2];
|
Res_FileSource_Way resFileSourceWay = new Res_FileSource_Way();
|
resFileSourceWay.setShowway(Showway);
|
resFileSourceWay.setUrl(url);
|
resFileSourceWay.setRemark(remark);
|
resFileSourceWay.setResourceid(resMainInfo.getResourceid());
|
resFileSourceWay.setCreatedate(new Date());
|
resFileSourceWayService.insertSelective(resFileSourceWay);
|
}
|
}
|
return 1;
|
} catch (Exception e) {
|
return 0;
|
}
|
}
|
|
//替换路径
|
private void replaceRoute(@RequestBody String lujin, String replaceStr) {
|
String oldFileUrl = sysConfig.getUploadPath() + lujin.replace("/", "\\");
|
File oldFile = new File(oldFileUrl);
|
String NewFileUrl = sysConfig.getUploadPath() + lujin.replace(replaceStr, "").replace("/", "\\");
|
NewFileUrl = NewFileUrl.substring(0, NewFileUrl.lastIndexOf("\\")) + "\\";
|
File NewFile = new File(NewFileUrl);
|
if (!NewFile.exists()) { // 当前地址不为空，判断该路径是否存在，不存在则创建新的文件夹
|
File newfilePath = new File(NewFile + "\\"); // 创建对应的年月文件夹
|
newfilePath.mkdirs();
|
}
|
com.landtool.lanbase.common.utils.FileUtils.moveTotherFolders(oldFileUrl, NewFileUrl);
|
if (oldFile.exists()) {
|
oldFile.delete();
|
}
|
}
|
|
//删除相同文件
|
private void DelectEquealFile(@RequestBody String NEWString, String OLDString) {
|
String oldourl = OLDString.substring(OLDString.lastIndexOf("/"), OLDString.length());
|
String newurl = NEWString.substring(NEWString.lastIndexOf("/"), NEWString.length());
|
if (!oldourl.equals(newurl)) {
|
File OLDFile = new File(sysConfig.getUploadPath() + OLDString.replace("/", "\\"));
|
System.out.println(OLDFile);
|
OLDFile.delete();
|
}
|
}
|
|
/**
|
* 地图范围框选页面
|
*
|
* @param ResourceClass 资源类型（KJ_JCDT: 基础底图 KJ_ZTDT: 专题地图）
|
*/
|
@RequestMapping("/obtainExtentMapViewer")
|
public String obtainExtentMapViewer(String ResourceClass, Model model) {
|
model.addAttribute("ResourceClass", ResourceClass);//资源类型
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("obtainExtentMapUrl", sysConfig.getObtainExtentMapUrl());//框选地图底图URL
|
return "ResManage/NewResRegister/obtainExtentMapViewer";
|
}
|
}
|
