package com.landtool.lanbase.modules.res.controller;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.json.JSONUtil;
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
import com.github.pagehelper.Page;
|
import com.github.pagehelper.PageHelper;
|
import com.google.gson.JsonObject;
|
import com.landtool.lanbase.common.annotation.LogAction;
|
import com.landtool.lanbase.common.map.EsbToken;
|
import com.landtool.lanbase.common.utils.*;
|
import com.landtool.lanbase.config.SysTemPropertyConfig;
|
import com.landtool.lanbase.modules.api.utils.Excel;
|
import com.landtool.lanbase.modules.api.utils.JDBCUtils;
|
import com.landtool.lanbase.modules.api.utils.PageBean;
|
import com.landtool.lanbase.modules.log.service.LogActionService;
|
import com.landtool.lanbase.modules.org.entity.OrgUnit;
|
import com.landtool.lanbase.modules.org.entity.OrgUser;
|
import com.landtool.lanbase.modules.org.service.OrgUnitService;
|
import com.landtool.lanbase.modules.org.service.OrgUserService;
|
import com.landtool.lanbase.modules.res.entity.DataBaseLeftDataSource.DataBaseLeftDataSource;
|
import com.landtool.lanbase.modules.res.entity.JSONModels.BiaoJieGou;
|
import com.landtool.lanbase.modules.res.entity.JSONModels.ZiDuanPeiZi;
|
import com.landtool.lanbase.modules.res.entity.*;
|
import com.landtool.lanbase.modules.res.entity.UserDefined.DingYue;
|
import com.landtool.lanbase.modules.res.entity.UserDefined.MainInfoJoinAudit;
|
import com.landtool.lanbase.modules.res.entity.UserDefined.MainInfoJoinJcdt;
|
import com.landtool.lanbase.modules.res.entity.UserDefined.UserDef_ZYML_ChaXunQu;
|
import com.landtool.lanbase.modules.res.entity.ViewModels.FileSourceList;
|
import com.landtool.lanbase.modules.res.entity.ZiYuanTongJi.*;
|
import com.landtool.lanbase.modules.res.service.*;
|
import com.landtool.lanbase.modules.sys.controller.AbstractController;
|
import com.landtool.lanbase.modules.sys.service.SysFieldvalueService;
|
import io.swagger.models.auth.In;
|
import org.apache.commons.io.FileUtils;
|
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.beans.factory.annotation.Value;
|
import org.springframework.core.env.Environment;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.ui.Model;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RequestParam;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
import org.springframework.web.multipart.MultipartFile;
|
import springfox.documentation.spring.web.json.Json;
|
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.*;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.net.URLDecoder;
|
import java.net.URLEncoder;
|
import java.sql.Timestamp;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Date: 2018-03-02 11:34
|
* @Description:主表逻辑操作
|
*/
|
@Controller
|
@RequestMapping("/res")
|
public class ResMainInfoController extends AbstractController {
|
@Autowired
|
private ResMainInfoService resMainInfoService;
|
|
@Autowired
|
private ResCatalogService resCatalogService;
|
|
@Autowired
|
private ResExtBaseMapService resExtBaseMapService;
|
|
@Autowired
|
private ResExtBusinessLayerService resExtBusinessLayerService;
|
|
@Autowired
|
private ResExtSpaceServerService resExtSpaceServerService;
|
|
@Autowired
|
private ResExtThemeMapService resExtThemeMapService;
|
|
@Autowired
|
private ResExtIntegrateService resExtIntegrateService;
|
|
@Autowired
|
private ResExtFileSourceService resExtFileSourceService;
|
|
@Autowired
|
private ResActionRecordService resActionRecordService;
|
|
@Autowired
|
private ResExtInterFaceService resExtInterFaceService;
|
|
@Autowired
|
private ResExtDataBaseService resExtDataBaseService;
|
|
@Autowired
|
private ResExt3DService resExt3DService;
|
|
@Autowired
|
private ResExtDataSourceService resExtDataSourceService;
|
|
@Autowired
|
private SysTemPropertyConfig sysConfig;
|
|
@Autowired
|
public ResApplyRecommendService resApplyRecommendService;
|
|
@Autowired
|
private SysFieldvalueService FieldUtils;
|
|
@Autowired
|
private OrgUserService orgUserService;
|
|
@Autowired
|
private OrgUnitService orgUnitService;
|
|
@Autowired
|
private ResFileSourceWayService resFileSourceWayService;
|
|
@Autowired
|
private ResSubscriptionsService resSubscriptionsService;
|
|
@Autowired
|
private ResExtMapUrlService resExtMapUrlService;
|
|
@Autowired
|
private ResAuditService resAuditService;
|
|
@Autowired
|
private ResBusinessRefService resBusinessRefService;
|
|
@Autowired
|
private ResQueryAroundService resQueryAroundService;
|
|
@Autowired
|
private ResEvaluationService resEvaluationService;
|
|
@Autowired
|
private ResDiyLayerInfoService resDiyLayerInfoService;
|
|
@Autowired
|
private Environment env;
|
|
@Autowired
|
private ResFilesService resFileService;
|
|
@Autowired
|
public ZiYuanMuLuService ziYuanMuLuService;
|
|
@Autowired
|
private ResProblemFeedbackService resProblemFeedbackService;
|
|
@Autowired
|
private LogActionService logActionService;
|
|
|
private String wenjianjiaPath() {
|
return sysConfig.getUploadPath() + "FileSource\\wenjianjia\\";
|
}
|
|
private String wenjianPath() {
|
return sysConfig.getUploadPath() + "FileSource\\wenjian\\";
|
}
|
|
public static String strMuLu = "";
|
|
/**
|
* 访问资源编辑页面(ResRegister.Controller)
|
*/
|
@RequestMapping("ZiYuan/AddZiYuanBasic")
|
public String ziYuanEditJump(Model model, Long resMainInfoId) {
|
if (resMainInfoId != null) {
|
Res_MainInfo resMainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId.intValue());
|
// 获取资源类型列表
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");
|
model.addAttribute("resourceclass", ResourceTypeList.get(resMainInfo.getResourceclass()));
|
}
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
return "FuWuZiYuan/ZiYuan_Edit";
|
}
|
|
/**
|
* 访问资源基本信息新增页面
|
*/
|
@RequestMapping("ZiYuan/AddZiYuanChildren")
|
public String addZiYuanChildren(HttpServletRequest request, Model model, Long resMainInfoId) throws IOException {
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
Res_Catalog res_catalog = new Res_Catalog();
|
String Imagelujin = null;
|
// 修改
|
if (resMainInfoId != null) {
|
res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId.intValue());
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
String Pubdate = sdf.format(res_mainInfo.getPubdate());
|
model.addAttribute("Pubdate", Pubdate);
|
if (res_mainInfo.getCatlogid() != null) {
|
res_catalog = resCatalogService.selectByPrimaryKey(res_mainInfo.getCatlogid());
|
}
|
if (res_mainInfo.getImgurl() != null && res_mainInfo.getImgurl() != "") {
|
StringBuffer url = request.getRequestURL();
|
String ip = "/ZiYuanIcon/";
|
Imagelujin = ip + res_mainInfo.getImgurl();
|
}
|
// 数据覆盖范围--行政区划Id
|
// modified by qufangxu 信创环境下，若 res_mainInfo.getAdministrativeid() = ' ',会返回单点登录页面，具体原因未知。 解决办法：提前去除空格、制表符
|
String administrativeid = (String) res_mainInfo.getAdministrativeid();
|
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);
|
}
|
}
|
}
|
// 获取资源类型列表
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");
|
model.addAttribute("mainInfo", res_mainInfo);
|
model.addAttribute("rescatalog", res_catalog);
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
model.addAttribute("ResourceTypeList", ResourceTypeList);
|
model.addAttribute("Imagelujin", Imagelujin);
|
return "FuWuZiYuan/AddZiYuanChildren";
|
}
|
|
/**
|
* 访问查看页面
|
*/
|
@RequestMapping("ZiYuan/ZiYuanSelect")
|
public String ziYuanSelect(Model model, Long resMainInfoId) {
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
return "FuWuZiYuan/ZiYuanSelect";
|
}
|
|
/**
|
* 访问资源元数据新增页面
|
*/
|
@RequestMapping("ZiYuan/AddZiYuanYSJ")
|
public String addZiYuanYSJ() {
|
return "FuWuZiYuan/AddZiYuanYSJ";
|
}
|
|
/**
|
* 插入资源编辑页面内容
|
*/
|
@RequestMapping("ziYuanInsert")
|
@ResponseBody
|
@LogAction("资源管理,资源发布,资源新增,新增|zy")
|
public String ziYuanInsert(Res_MainInfo resMainInfo, String GUANJIANZI) {
|
// 获取拼音首字母
|
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);
|
resMainInfo.setOrderid(resMainInfo.getResourceid());
|
resMainInfoService.updateByPrimaryKeySelective(resMainInfo);
|
|
Object resourceClass = resMainInfo.getResourceclass();
|
return "{'result':'" + result + "','ziyuanId':'" + resMainInfo.getResourceid() + "','ziyuanClass':'" + resourceClass.toString() + "'}";
|
}
|
|
/**
|
* 更新资源编辑页面内容
|
*/
|
@RequestMapping("ziYuanUpdaate")
|
@ResponseBody
|
@LogAction("资源管理,资源发布,资源修改,修改|zy")
|
public String ziYuanUpdaate(Res_MainInfo resMainInfo) {
|
// 获取拼音首字母
|
String shortPinYin = JpinyinUtils.changeToGetShortPinYin((String) resMainInfo.getTitle());
|
resMainInfo.setPingyinfiirst(shortPinYin);
|
// 更新基本信息时间
|
Timestamp audittime = new Timestamp(new Date().getTime());// 获取当前时间
|
// 更新委托批复
|
if (resMainInfo.getInsteadaudit() == null) {
|
resMainInfo.setInsteadaudit(0);
|
}
|
//换地址
|
if (resMainInfo.getDesurl() != null && resMainInfo.getDesurl().indexOf("diydes") != -1) {
|
String url = resMainInfo.getDesurl().replace(sysConfig.getUploadRootPath(), "");
|
resMainInfo.setDesurl(url);
|
}
|
resMainInfo.setPubdate(DateUtils.getFunllDate(resMainInfo.getPubdate()));
|
resMainInfo.setLasteditdate(audittime);
|
int result = resMainInfoService.updateByPrimaryKeySelective(resMainInfo);
|
|
return "{'result':'" + result + "','ziyuanId':'" + resMainInfo.getResourceid() + "'}";
|
}
|
|
/**
|
* 更新资源编辑页面内容
|
*/
|
@RequestMapping("ziYuanSubmit")
|
@ResponseBody
|
@LogAction("资源管理,资源发布,资源修改,修改")
|
public String ziYuanSubmit(Res_MainInfo resMainInfo) {
|
int result;
|
Res_MainInfo model = resMainInfoService.selectByPrimaryKey(resMainInfo.getResourceid());
|
// 更新委托批复
|
if (resMainInfo.getInsteadaudit() == null) {
|
resMainInfo.setInsteadaudit(0);
|
}
|
if (model.getResourcestatus() == 3) { // 资源提交。如果资源状态为注销则改为正常
|
resMainInfo.setResourcestatus(0);
|
}
|
boolean isExistExt = hasExistExtZiYuan(resMainInfo.getResourceid(), model.getResourceclass());// 是否存在扩展信息
|
if (isExistExt) {
|
String shortPinYin = JpinyinUtils.changeToGetShortPinYin((String) resMainInfo.getTitle());// 获取拼音首字母
|
resMainInfo.setPingyinfiirst(shortPinYin);
|
resMainInfo.setAuditstatus(1);
|
|
result = resMainInfoService.updateByPrimaryKeySelective(resMainInfo);
|
} else {// 如果不存在扩展信息提示填写扩展信息
|
return "{'result':'" + 2 + "','ziyuanId':'" + resMainInfo.getResourceid() + "'}";
|
}
|
return "{'result':'" + result + "','ziyuanId':'" + resMainInfo.getResourceid() + "'}";
|
}
|
|
/**
|
* 检测资源拓展信息是否存在
|
*
|
* @param resourceId
|
* @param resourceClass
|
* @return
|
*/
|
public boolean hasExistExtZiYuan(Integer resourceId, String resourceClass) {
|
// LinkedHashMap<String, String> ResourceTypeList =
|
// FieldUtils.getFieldListByKey("ResourceType",
|
// sysConfig.getApiServer();//获取资源类型列表
|
// String resourceType = ResourceTypeList.get(resourceClass);
|
if (resourceClass == null) resourceClass = "";
|
// alert ykm 2019/02/26
|
if (resourceClass.equals("KJ_SWMX") || resourceClass.equals("KJ_SWDX") || resourceClass.equals("KJ_SWYX"))
|
resourceClass = "KJ_SW";
|
switch (resourceClass) {
|
case "KJ_JCDT":// 基础底图
|
Res_ExtBaseMap res_ExtBaseMap = resExtBaseMapService.selectByPrimaryKey(resourceId);
|
return res_ExtBaseMap != null;
|
case "KJ_YWTC":// 业务图层
|
Res_ExtBusinessLayer res_ExtBusinessLayer = resExtBusinessLayerService.selectByPrimaryKey((resourceId));
|
return res_ExtBusinessLayer != null;
|
case "KJ_KJFX":// 空间分析
|
Res_ExtSpaceServer res_ExtSpaceServer = resExtSpaceServerService.selectByPrimaryKey(resourceId);
|
return res_ExtSpaceServer != null;
|
case "KJ_ZTDT":// 专题地图
|
Res_ExtThemeMap res_ExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resourceId);
|
return res_ExtThemeMap != null;
|
// case "专题应用程序":
|
// Res_ExtApp res_ExtApp =
|
// resExtAppService.selectByPrimaryKey(resourceId);
|
// return res_ExtApp != null;
|
case "YWJC":// 业务集成
|
Res_ExtIntegrate res_ExtIntegrate = resExtIntegrateService.selectByPrimaryKey(resourceId);
|
return res_ExtIntegrate != null;
|
case "SJWJ":// 数据文件
|
Res_ExtFileSource res_ExtFileSource = resExtFileSourceService.selectByPrimaryKey(resourceId);
|
return res_ExtFileSource != null;
|
case "SJKB":// 数据库表
|
Res_ExtDataBase res_extDataBase = resExtDataBaseService.selectByMainInfoId(resourceId);
|
return res_extDataBase != null;
|
case "JKFW":// 接口服务
|
Res_ExtInterFaceService res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(resourceId);
|
return res_extInterFaceService != null;
|
// case "KJ_SWMX":// 三维模型
|
case "KJ_SW":// 三维类，三维模型、三维地形、三维影像
|
Res_Ext3D res_ext3D = resExt3DService.selectByPrimaryKey(resourceId);
|
return res_ext3D != null;
|
default:
|
return false;
|
}
|
}
|
|
/**
|
* 资源查询页面
|
*/
|
@RequestMapping("ZiYuan/Index")
|
public String index(String Message, Model model) {
|
// 获取下拉框目录
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
model.addAttribute("ResourceTypeList", ResourceTypeList);
|
String ResourceTypeListJson = "";
|
for (Map.Entry<String, String> entry : ResourceTypeList.entrySet()) {
|
if (ResourceTypeListJson != "") ResourceTypeListJson += ",";
|
ResourceTypeListJson += "{key:'" + entry.getKey() + "',value:'" + entry.getValue() + "'}";
|
}
|
if (Message != null) {
|
model.addAttribute("Message", Message);
|
}
|
model.addAttribute("ResourceTypeListJson", "[" + ResourceTypeListJson + "]");
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
// 资源类型饼状统计图
|
List<GroupByZiYuanLeiXing> resourceclassList = resMainInfoService.selectResMainInfoGroupByLeiXing();
|
String ZYLXJson = "";
|
String ZYLXLend = "";
|
int ZYLXCount = 0;
|
// 多于4个类型的话数据显示前7个资源数量最多的类型，后面的都以其它统计
|
if (resourceclassList.size() > 4) {
|
int counter = 0;
|
for (int i = 4; i < resourceclassList.size(); i++) {
|
counter += resourceclassList.get(i).getCount();
|
}
|
for (int i = 0; i < 4; i++) {
|
GroupByZiYuanLeiXing item = resourceclassList.get(i);
|
String leixing = ResourceTypeList.get(item.getResourceclass());
|
ZYLXJson += (ZYLXJson == "" ? "" : ",") + "{ value: " + item.getCount() + ", name: '" + leixing + "'}";
|
ZYLXLend += (ZYLXLend == "" ? "" : ",") + "'" + leixing + "'";
|
ZYLXCount += item.getCount();
|
}
|
ZYLXJson += (ZYLXJson == "" ? "" : ",") + "{ value: " + counter + ", name: '" + "其它" + "'}";
|
ZYLXLend += (ZYLXLend == "" ? "" : ",") + " '" + "其它" + "'";
|
ZYLXCount += counter;
|
}
|
// 少于等于4个类型就全部显示
|
else {
|
for (int i = 0; i < resourceclassList.size(); i++) {
|
GroupByZiYuanLeiXing item = resourceclassList.get(i);
|
String leixing = ResourceTypeList.get(item.getResourceclass());
|
ZYLXJson += (ZYLXJson == "" ? "" : ",") + "{ value: " + item.getCount() + ", name: '" + leixing + "'}";
|
ZYLXLend += (ZYLXLend == "" ? "" : ",") + "'" + leixing + "'";
|
ZYLXCount += item.getCount();
|
}
|
}
|
model.addAttribute("ZYLXJson", "[" + ZYLXJson + "]");
|
model.addAttribute("ZYLXLend", "[" + ZYLXLend + "]");
|
model.addAttribute("ZYLXCount", ZYLXCount);
|
|
// 行政区划饼状统计图
|
List<GroupByXingZhengQuHua> administrativeidList = resMainInfoService.selectResMainInfoGroupByXingZhengQuHua();
|
String XZQHJson = "";
|
String XZQHLend = "";
|
int XZQHCount = 0;
|
String jsonStr = "";
|
String getRegionInfourl = sysConfig.getApiServer() + "/api/org/region/queryList";
|
try {
|
jsonStr = HttpOperateUtils.httpGet(getRegionInfourl.trim());
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
JSONArray XZQHItem = JSONObject.parseArray(jsonStr);
|
if (administrativeidList.size() > 5) {
|
int XZcounter = 0;
|
for (int i = 5; i < administrativeidList.size(); i++) {
|
XZcounter += administrativeidList.get(i).getCount();
|
}
|
for (int i = 0; i < 5; i++) {
|
GroupByXingZhengQuHua item = administrativeidList.get(i);
|
String quhua = item.getAdministrativeid().trim();
|
if (quhua.length() > 0) {
|
if (!quhua.substring(2, quhua.length()).equals("0000")) {
|
quhua = quhua.substring(0, 2) + "0000"; // 下级市区归属到省
|
}
|
} else {
|
continue;
|
} // 为空跳过
|
for (int j = 0; j < XZQHItem.size(); j++) {
|
JSONObject temp = (JSONObject) XZQHItem.get(j);
|
String regionid = temp.getString("regionid");
|
if (regionid.equals(quhua)) {
|
quhua = temp.getString("regionname");
|
break;
|
}
|
}
|
XZQHJson += (XZQHJson == "" ? "" : ",") + "{ value: " + item.getCount() + ", name: '" + quhua + "'}";
|
XZQHLend += (XZQHLend == "" ? "" : ",") + "'" + quhua + "'";
|
XZQHCount += item.getCount();
|
}
|
XZQHJson += (XZQHJson == "" ? "" : ",") + "{ value: " + XZcounter + ", name: '" + "其它" + "'}";
|
XZQHLend += (XZQHLend == "" ? "" : ",") + " '" + "其它" + "'";
|
XZQHCount += XZcounter;
|
} else {
|
for (int i = 0; i < administrativeidList.size(); i++) {
|
GroupByXingZhengQuHua item = administrativeidList.get(i);
|
String quhua = item.getAdministrativeid().trim();
|
if (quhua.length() > 0) {
|
if (!quhua.substring(2, quhua.length()).equals("0000")) {
|
quhua = quhua.substring(0, 2) + "0000"; // 下级市区归属到省
|
}
|
} else {
|
continue;
|
} // 为空跳过
|
for (int j = 0; j < XZQHItem.size(); j++) {
|
JSONObject temp = (JSONObject) XZQHItem.get(j);
|
String regionid = temp.getString("regionid");
|
if (regionid.equals(quhua)) {
|
quhua = temp.getString("regionname");
|
break;
|
}
|
}
|
XZQHJson += (XZQHJson == "" ? "" : ",") + "{ value: " + item.getCount() + ", name: '" + quhua + "'}";
|
XZQHLend += (XZQHLend == "" ? "" : ",") + "'" + quhua + "'";
|
XZQHCount += item.getCount();
|
}
|
}
|
model.addAttribute("XZQHJson", "[" + XZQHJson + "]");
|
model.addAttribute("XZQHLend", "[" + XZQHLend + "]");
|
model.addAttribute("XZQHCount", XZQHCount);
|
|
// 共享协议饼状统计图
|
LinkedHashMap<String, String> GongXiangXieYiList = FieldUtils.getFieldListByKey("SharProtocol");// 获取共享协议列表
|
List<GroupByGongXiangXieYi> sharprotocolList = resMainInfoService.selectResMainInfoGroupByGongXiangXieYi();
|
String GXXYJson = "";
|
String GXXYLend = "";
|
int GXXYCount = 0;
|
for (int i = 0; i < sharprotocolList.size(); i++) {
|
GroupByGongXiangXieYi item = sharprotocolList.get(i);
|
String xieyi = item.getSharprotocol();
|
GXXYJson += (GXXYJson == "" ? "" : ",") + "{ value: " + item.getCount() + ", name: '" + xieyi + "'}";
|
GXXYLend += (GXXYLend == "" ? "" : ",") + "'" + xieyi + "'";
|
GXXYCount += item.getCount();
|
}
|
model.addAttribute("GXXYJson", "[" + GXXYJson + "]");
|
model.addAttribute("GXXYLend", "[" + GXXYLend + "]");
|
model.addAttribute("GXXYCount", GXXYCount);
|
|
// 按单位统计柱状图
|
List<GroupByDanWei> pubunitidList = resMainInfoService.selectResMainInfoGroupByDanWei();
|
String DWJson = "";
|
String DWLend = "";
|
String UnitStr = "";
|
for (int i = 0; i < pubunitidList.size(); i++) {
|
GroupByDanWei item = pubunitidList.get(i);
|
String id = item.getPubunitid();
|
String getUnitInfourl = sysConfig.getApiServer() + "/api/org/unit/getInfoById/" + id;
|
try {
|
UnitStr = HttpOperateUtils.httpGet(getUnitInfourl.trim());
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
JSONObject UnitData = JSONObject.parseObject(UnitStr);
|
String temp = UnitData.getString("unitname");
|
DWJson += (DWJson == "" ? "" : ",") + item.getCount();
|
DWLend += (DWLend == "" ? "" : ",") + "'" + temp + "'";
|
}
|
model.addAttribute("DWJson", "[" + DWJson + "]");
|
model.addAttribute("DWLend", "[" + DWLend + "]");
|
return "FuWuZiYuan/Index";
|
}
|
|
/**
|
* 所属目录目录树
|
*/
|
@RequestMapping("ZiYuan/MuLuShu")
|
public String muLuShu() {
|
return "ResManage/ResRegister/MuLuShu";
|
}
|
|
/**
|
* 行政区划目录树
|
*/
|
@RequestMapping("ZiYuan/AreaTree")
|
public String areaTree(Model model) {
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
return "FuWuZiYuan/AreaTree";
|
}
|
|
/**
|
* 资源图文列表
|
*/
|
@RequestMapping("ZiYuan/ZiYuanDataList")
|
public String ziYuanDataList(Res_MainInfo resMainInfo, Model model, PageBean pageBean) {
|
//update：dsh(2018/12/05)
|
Page<Res_MainInfo> page = PageHelper.startPage(pageBean.getPage(), 15);
|
List<Res_MainInfo> ziYuanMuLuList = resMainInfoService.selectResMainInfo(resMainInfo);
|
int countNums = (int) ((Page) ziYuanMuLuList).getTotal();
|
PageBean<Res_MainInfo> pageData = new PageBean<>(pageBean.getPage(), pageBean.getLimit(), countNums);
|
pageData.setItems(ziYuanMuLuList);
|
List<SimpleZiYuan> simpleZiYuans = new ArrayList<>();
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");
|
for (Integer j = 0; j < ziYuanMuLuList.size(); j++) {
|
Res_MainInfo zy = ziYuanMuLuList.get(j);
|
SimpleZiYuan model1 = new SimpleZiYuan();
|
model1.setResourceid(zy.getResourceid());
|
model1.setTitle(zy.getTitle());
|
model1.setCreateuserid(zy.getCreateuserid());
|
String chinesename = orgUserService.getChinesename(zy.getCreateuserid());// 查询发布人id对应的 name
|
String unitname = orgUnitService.getUnitName((long) zy.getPubunitid());
|
model1.setCreateusername(chinesename);
|
model1.setDatasources(zy.getDatasources());
|
model1.setPubunitid(zy.getPubunitid());
|
model1.setPubunitname(unitname);
|
model1.setKeywords(zy.getKeywords());
|
model1.setSecuritylev(zy.getSecuritylev());
|
model1.setResourceclass(ResourceTypeList.get(zy.getResourceclass()));
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
model1.setPubdate(sdf.format(zy.getPubdate()));
|
simpleZiYuans.add(model1);
|
}
|
model.addAttribute("ZyList", simpleZiYuans);
|
model.addAttribute("Count", countNums);
|
model.addAttribute("Page", pageBean.getPage());
|
return "FuWuZiYuan/ZiYuanDataList";
|
}
|
|
@RequestMapping("ZiYuan/JcdtDataList")
|
public String jcdtDataList(MainInfoJoinJcdt resMainInfo, Model model, PageBean pageBean) {
|
//update：dsh(2018/12/05)
|
Page<MainInfoJoinJcdt> page = PageHelper.startPage(pageBean.getPage(), 15);
|
List<MainInfoJoinJcdt> ziYuanMuLuList = resMainInfoService.selectJcdtList(resMainInfo);
|
int countNums = (int) ((Page) ziYuanMuLuList).getTotal();
|
PageBean<MainInfoJoinJcdt> pageData = new PageBean<>(pageBean.getPage(), pageBean.getLimit(), countNums);
|
pageData.setItems(ziYuanMuLuList);
|
List<SimpleZiYuan> simpleZiYuans = new ArrayList<>();
|
for (Integer j = 0; j < ziYuanMuLuList.size(); j++) {
|
MainInfoJoinJcdt zy = ziYuanMuLuList.get(j);
|
SimpleZiYuan model1 = new SimpleZiYuan();
|
model1.setResourceid(zy.getResourceid());
|
model1.setTitle(zy.getTitle());
|
model1.setCreateuserid(zy.getCreateuserid());
|
model1.setDatasources(zy.getDatasources());
|
model1.setPubunitid(zy.getPubunitid());
|
model1.setKeywords(zy.getKeywords());
|
model1.setSecuritylev(zy.getSecuritylev());
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");
|
model1.setResourceclass(ResourceTypeList.get(zy.getResourceclass()));
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
model1.setPubdate(sdf.format(zy.getPubdate()));
|
simpleZiYuans.add(model1);
|
}
|
model.addAttribute("ZyList", simpleZiYuans);
|
model.addAttribute("Count", countNums);
|
model.addAttribute("Page", pageBean.getPage());
|
return "FuWuZiYuan/JcdtDataList";
|
}
|
|
@RequestMapping("ZiYuan/ZiYuanList")
|
public String ziYuanList(Model model) {
|
// 获取下拉框目录
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
List<String> DATASOURCES = resMainInfoService.selectDATASOURCES();
|
Timestamp audittime = new Timestamp(new Date().getTime());
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
|
List<Res_Catalog> MuLuList = resCatalogService.selectResCatalogToParentid(0);
|
String year = sdf.format(audittime);
|
model.addAttribute("year", year);
|
model.addAttribute("DATASOURCESList", DATASOURCES);
|
model.addAttribute("ResourceTypeList", ResourceTypeList);
|
model.addAttribute("MuLuList", MuLuList);
|
String ResourceTypeListJson = "";
|
for (Map.Entry<String, String> entry : ResourceTypeList.entrySet()) {
|
if (ResourceTypeListJson != "") ResourceTypeListJson += ",";
|
ResourceTypeListJson += "{key:'" + entry.getKey() + "',value:'" + entry.getValue() + "'}";
|
}
|
model.addAttribute("ResourceTypeListJson", "[" + ResourceTypeListJson + "]");
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
return "FuWuZiYuan/ZiYuanList";
|
}
|
|
@RequestMapping("ZiYuan/JcdtList")
|
public String jcdtList(Model model) {
|
// 获取下拉框目录
|
LinkedHashMap<String, String> BaseMapTypeList = FieldUtils.getFieldListByKey("BaseMapType");// 获取底图类型字典列表
|
List<String> DATASOURCES = resMainInfoService.selectDATASOURCES();
|
Timestamp audittime = new Timestamp(new Date().getTime());
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
|
List<Res_Catalog> MuLuList = resCatalogService.selectResCatalogToParentid(0);
|
|
String year = sdf.format(audittime);
|
model.addAttribute("year", year);
|
model.addAttribute("DATASOURCESList", DATASOURCES);
|
model.addAttribute("BaseMapTypeList", BaseMapTypeList);
|
model.addAttribute("MuLuList", MuLuList);
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/");
|
return "FuWuZiYuan/JcdtList";
|
}
|
|
/**
|
* 查询资源目录id
|
*/
|
@ResponseBody
|
@RequestMapping("selectZiYuan")
|
public Res_MainInfo selectZiYuan(int resMainInfoId) {
|
return resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
}
|
|
/**
|
* 查询资源列表功能
|
*/
|
@ResponseBody
|
@RequestMapping("ZiYuan/selectResMainInfojoinCatalog")
|
@LogAction("资源管理,资源发布,资源列表查询,查询")
|
public Result selectResMainInfojoinCatalog(Res_MainInfo resMainInfo, PageBean pageBean) {
|
Page<Res_MainInfo> page = PageHelper.startPage(pageBean.getPage(), pageBean.getLimit());
|
if (!SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
resMainInfo.setExistPermission(getUserId().toString());
|
}
|
|
//alert ykm 2019/01/14
|
if (resMainInfo.getCreateuserid() == null && resMainInfo.getFaburen() != null && !resMainInfo.getFaburen().equals("")) {
|
String name = getUserIds(resMainInfo.getFaburen());
|
resMainInfo.setFaburen(name);
|
}
|
if (resMainInfo.getCreateuserid() != null) {
|
resMainInfo.setFaburen(null);
|
}
|
|
List<Res_MainInfo> mainInfoJoinCatalogList = resMainInfoService.selectAllMainInfo(resMainInfo);
|
int countNums = (int) ((Page) mainInfoJoinCatalogList).getTotal();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
PageBean<Res_MainInfo> pageData = new PageBean<>(pageBean.getPage(), pageBean.getLimit(), countNums);
|
pageData.setItems(mainInfoJoinCatalogList);
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
StringBuilder rsb = new StringBuilder();
|
String leixin = "";
|
|
//修改因英文单引号 '和双引号" 导致的错误 alert ykm 2019/01/08
|
List<Map<String, Object>> maps = new LinkedList<>();
|
for (Integer i = 0; i < mainInfoJoinCatalogList.size(); i++) {
|
leixin = ResourceTypeList.get(mainInfoJoinCatalogList.get(i).getResourceclass());
|
String chinesename = orgUserService.getChinesename(mainInfoJoinCatalogList.get(i).getCreateuserid());
|
String unitname = orgUnitService.getUnitName((long) mainInfoJoinCatalogList.get(i).getPubunitid());
|
String mulu = GetBianMu(mainInfoJoinCatalogList.get(i).getCatlogid() == null ? 0 : mainInfoJoinCatalogList.get(i).getCatlogid());
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("resourceid", mainInfoJoinCatalogList.get(i).getResourceid());
|
map.put("title", mainInfoJoinCatalogList.get(i).getTitle());
|
map.put("mulu", mulu);
|
map.put("resourceclass", leixin);
|
map.put("pubdate", sdf.format(mainInfoJoinCatalogList.get(i).getPubdate()));
|
map.put("unitname", unitname);
|
map.put("chinesename", chinesename);
|
map.put("auditstatus", mainInfoJoinCatalogList.get(i).getAuditstatus());
|
//add by zsx 2020/10/11
|
map.put("resourcestatus", mainInfoJoinCatalogList.get(i).getResourcestatus());
|
maps.add(map);
|
}
|
return Result.ok().put("topics", maps).put("totalCount", countNums);
|
}
|
|
/**
|
* 查询资源所属目录
|
*
|
* @param Catlogid
|
* @return
|
*/
|
private String GetBianMu(int Catlogid) {
|
String str = "";
|
strMuLu = "";
|
if (Catlogid > 0) {
|
Res_Catalog zymlBianMu = resCatalogService.selectByPrimaryKey(Catlogid);
|
String str2 = CheckBianMu(zymlBianMu);
|
String[] res = str2.split(">");
|
for (int i = res.length - 1; i >= 0; i--) {
|
if (i == 0) {
|
str += res[i];
|
} else {
|
str += res[i] + " > ";
|
}
|
}
|
}
|
return str;
|
}
|
|
/**
|
* 递归获取资源目录名称
|
*
|
* @param zymlBianMu
|
* @return
|
*/
|
private String CheckBianMu(Res_Catalog zymlBianMu) {
|
if (zymlBianMu != null) {
|
strMuLu += zymlBianMu.getTitle() + ">";
|
if (zymlBianMu.getParentid() == 0) {
|
return strMuLu;
|
} else {
|
zymlBianMu = resCatalogService.selectByPrimaryKey(zymlBianMu.getParentid());
|
CheckBianMu(zymlBianMu);
|
}
|
}
|
return strMuLu;
|
}
|
|
@ResponseBody
|
@RequestMapping("ZiYuan/GetMuLu")
|
public String getMuLu(int id) {
|
List<Res_Catalog> List = resCatalogService.selectResCatalogToParentid(id);
|
String result = "{";
|
result += "Count:" + List.size() + ",list:[";
|
for (Res_Catalog model : List) {
|
result += "{ ZIYUANMULUID:" + model.getCatlogid() + ",ZIYUANMC:'" + model.getTitle() + "'},";
|
}
|
if (List.size() > 0) {
|
result = result.substring(0, result.length() - 1);
|
}
|
result += "]}";
|
return result;
|
}
|
|
/**
|
* 资源编辑页面
|
*
|
* @return
|
*/
|
@RequestMapping("ZiYuan_Edit")
|
public String ZiYuan_Edit() {
|
return "FuWuZiYuan/ZiYuan_Edit";
|
}
|
|
/**
|
* 查询目录结构
|
*/
|
@ResponseBody
|
@RequestMapping("selectMuLu")
|
public String selectDirectoryStructure(int id) {
|
List<Res_Catalog> resCatalogList = resCatalogService.selectResCatalogToParentid(id);
|
String resCatalogJson = "";
|
for (Res_Catalog resCatalog : resCatalogList) {
|
int childCount = resCatalogService.selectResCatalogIsExistsSon(resCatalog.getCatlogid(),null);
|
resCatalogJson += (resCatalogJson.length() > 0 ? "," : "") + "{id:" + resCatalog.getCatlogid() + ", code: '" + resCatalog.getCatlogcode() + "', name:'" + resCatalog.getTitle() + "', pId:" + resCatalog.getParentid() + ", rpId:" + resCatalog.getParentid();
|
if (resCatalog.getIcon() == null || resCatalog.getIcon().length() == 0) {
|
resCatalogJson += (childCount > 0 ? ",isParent:true,iconOpen:'/image/classicons/folderOpen.png',iconClose:'/image/classicons/folder.png'" : ",icon:'/image/classicons/defaulticon.png'") + "}";
|
} else {
|
resCatalogJson += (",isParent:true,icon:'" + "/uploadPath/" + resCatalog.getIcon()) + "'}";
|
}
|
}
|
return "[" + resCatalogJson + "]";
|
}
|
|
/**
|
* 访问查看页面编辑
|
*/
|
@RequestMapping("ZiYuan/ziYuanSelect_Edit")
|
public String ziYuanSelect_Edit(Model model, int resMainInfoId) throws IOException {
|
// 收藏，用来判断登录的用户是否有收藏这个资源
|
Res_ActionRecord resActionRecord = new Res_ActionRecord();
|
|
Long userId = getUserId();
|
|
resActionRecord.setUserid(userId);
|
resActionRecord.setResourceid(resMainInfoId);
|
resActionRecord.setActiontype("收藏");
|
Res_ActionRecord res_actionRecord = resActionRecordService.getUserActionRecord(resActionRecord);
|
if (res_actionRecord != null) {
|
model.addAttribute("actionid", res_actionRecord.getActionid());
|
}
|
|
// 统计该资源的收藏次数
|
Res_ActionRecord resActionRecord1 = new Res_ActionRecord();
|
resActionRecord1.setActiontype("收藏");
|
resActionRecord1.setResourceid(resMainInfoId);
|
int countResult = resActionRecordService.selectResourceCount(resActionRecord1);
|
model.addAttribute("shoucangcount", countResult);
|
|
// 统计该资源的浏览次数
|
Res_ActionRecord resActionRecord2 = new Res_ActionRecord();
|
resActionRecord2.setActiontype("浏览");
|
resActionRecord2.setResourceid(resMainInfoId);
|
int countResult1 = resActionRecordService.selectResourceCount(resActionRecord2);
|
model.addAttribute("liulancount", countResult1);
|
|
// 统计该资源的调用次数
|
Res_ActionRecord resActionRecord3 = new Res_ActionRecord();
|
resActionRecord3.setActiontype("调用");
|
resActionRecord3.setResourceid(resMainInfoId);
|
int countResult2 = resActionRecordService.selectResourceCount(resActionRecord3);
|
model.addAttribute("diaoyongcount", countResult2);
|
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
// 修改
|
res_mainInfo = resMainInfoService.selectByPrimaryKey(resMainInfoId);
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
String Pubdate = sdf.format(res_mainInfo.getPubdate());
|
// 判断所属目录
|
strMuLu = "";
|
res_mainInfo.setCatlogcode(GetBianMu(res_mainInfo.getCatlogid()));
|
// 判断发布单位
|
String unitname = orgUnitService.getUnitName((long) res_mainInfo.getPubunitid());
|
model.addAttribute("unitname", unitname);
|
// res_mainInfo.setPubunitid(unitid);
|
// 判断数据覆盖范围
|
// modified by qufangxu 信创环境下，若 res_mainInfo.getAdministrativeid() = ' ',会返回单点登录页面，具体原因未知。 解决办法：提前去除空格、制表符
|
String administrativeid = (String) res_mainInfo.getAdministrativeid();
|
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");
|
res_mainInfo.setAdministrativeid(regionname);
|
}
|
}
|
// LinkedHashMap<String, String> ResourceTypeList =
|
// FieldUtils.getFieldListByKey("ResourceType",
|
// sysConfig.getApiServer();//获取资源类型列表
|
// 获取是否有在申请表有申请RES_APPLYRECOMMEND
|
Res_ApplyRecommend res_applyRecommend = new Res_ApplyRecommend();
|
res_applyRecommend.setAppuserid(getUserId().toString());
|
res_applyRecommend.setIsrecommend(0);
|
res_applyRecommend.setResourceid(resMainInfoId);
|
Res_ApplyRecommend applyRecommend = resApplyRecommendService.selectByResApplyRecommend(res_applyRecommend);
|
String isApply = "True";// 先设为True
|
if (applyRecommend != null && applyRecommend.getAuditresult() == 1) {
|
isApply = "False";
|
}
|
|
// 判断资源类型
|
String leixin = res_mainInfo.getResourceclass();
|
if (leixin == null) leixin = "";
|
// 判断该类型对应那张表，然后查询对应的表的字段
|
// alert ykm 2019/02/26
|
if (leixin.equals("KJ_SWMX") || leixin.equals("KJ_SWDX") || leixin.equals("KJ_SWYX")) leixin = "KJ_SW";
|
switch (leixin) {
|
case "KJ_JCDT":// 基础底图
|
Res_ExtBaseMap resExtBaseMap = resExtBaseMapService.selectByPrimaryKey(resMainInfoId);
|
if (resExtBaseMap != null) {
|
model.addAttribute("resExtBaseMap", resExtBaseMap);
|
} else {
|
Res_ExtBaseMap resExtBaseMap1 = new Res_ExtBaseMap();
|
model.addAttribute("resExtBaseMap", resExtBaseMap1);
|
}
|
break;
|
case "KJ_YWTC":// 业务图层
|
Res_ExtBusinessLayer resExtBusinessLayer = resExtBusinessLayerService.selectByPrimaryKey(resMainInfoId);
|
if (resExtBusinessLayer != null) {
|
model.addAttribute("resExtBusinessLayer", resExtBusinessLayer);
|
} else {
|
Res_ExtBusinessLayer resExtBusinessLayer1 = new Res_ExtBusinessLayer();
|
model.addAttribute("resExtBusinessLayer", resExtBusinessLayer1);
|
}
|
break;
|
case "KJ_KJFX":// 空间分析
|
Res_ExtSpaceServerWithBLOBs resExtSpaceServerWithBLOBs = resExtSpaceServerService.selectByPrimaryKey(resMainInfoId);
|
if (resExtSpaceServerWithBLOBs != null) {
|
model.addAttribute("resExtSpaceServerWithBLOBs", resExtSpaceServerWithBLOBs);
|
} else {
|
Res_ExtSpaceServerWithBLOBs resExtSpaceServerWithBLOBs1 = new Res_ExtSpaceServerWithBLOBs();
|
model.addAttribute("resExtSpaceServerWithBLOBs", resExtSpaceServerWithBLOBs1);
|
}
|
break;
|
case "KJ_ZTDT":// 专题地图
|
Res_ExtThemeMap resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resMainInfoId);
|
if (resExtThemeMap != null) {
|
model.addAttribute("resExtThemeMap", resExtThemeMap);
|
} else {
|
Res_ExtThemeMap resExtThemeMap1 = new Res_ExtThemeMap();
|
model.addAttribute("resExtThemeMap", resExtThemeMap1);
|
}
|
break;
|
// case "专题应用程序":
|
// Res_ExtApp resExtApp =
|
// resExtAppService.selectByPrimaryKey(resMainInfoId);
|
// if (resExtApp != null) {
|
// model.addAttribute("resExtApp", resExtApp);
|
// } else {
|
// Res_ExtApp resExtApp1 = new Res_ExtApp();
|
// model.addAttribute("resExtApp", resExtApp1);
|
// }
|
// break;
|
case "YWJC":// 业务集成
|
Res_ExtIntegrate resExtIntegrate = resExtIntegrateService.selectByPrimaryKey(resMainInfoId);
|
if (resExtIntegrate != null) {
|
model.addAttribute("resExtIntegrate", resExtIntegrate);
|
} else {
|
Res_ExtIntegrate resExtIntegrate1 = new Res_ExtIntegrate();
|
model.addAttribute("resExtIntegrate", resExtIntegrate1);
|
}
|
break;
|
case "SJWJ":// 数据文件
|
Res_ExtFileSource resExtFileSource = resExtFileSourceService.selectByPrimaryKey(resMainInfoId);
|
if (resExtFileSource != null) {
|
LinkedHashMap<String, String> filetypelist = FieldUtils.getFieldListByKey("FileType");
|
resExtFileSource.setFiletype(filetypelist.get(resExtFileSource.getFiletype()));
|
model.addAttribute("resExtFileSource", resExtFileSource);
|
} else {
|
Res_ExtFileSource resExtFileSource1 = new Res_ExtFileSource();
|
model.addAttribute("resExtFileSource", resExtFileSource1);
|
}
|
break;
|
case "SJKB":// 数据库表
|
Res_ExtDataBase res_extDataBase = resExtDataBaseService.selectByMainInfoId(resMainInfoId);
|
if (res_extDataBase != null) {
|
Res_ExtDataSource res_extDataSource = resExtDataSourceService.selectByPrimaryKey(res_extDataBase.getDatasourceid());
|
model.addAttribute("resExtDataBase", res_extDataBase);
|
model.addAttribute("resExtDataSource", res_extDataSource);
|
} else {
|
res_extDataBase = new Res_ExtDataBase();
|
Res_ExtDataSource res_extDataSource = new Res_ExtDataSource();
|
model.addAttribute("resExtDataBase", res_extDataBase);
|
model.addAttribute("resExtDataSource", res_extDataSource);
|
}
|
break;
|
case "JKFW":// 接口服务
|
Res_ExtInterFaceService res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(resMainInfoId);
|
if (res_extInterFaceService != null) {
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
} else {
|
res_extInterFaceService = new Res_ExtInterFaceService();
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
}
|
break;
|
// case "KJ_SWMX":// 三维模型
|
case "KJ_SW":// 三维，三维模型，三维影像，三维地形
|
Res_Ext3D res_ext3D = resExt3DService.selectByPrimaryKey(resMainInfoId);
|
if (res_ext3D != null) {
|
model.addAttribute("resExt3D", res_ext3D);
|
} else {
|
res_ext3D = new Res_Ext3D();
|
model.addAttribute("resExt3D", res_ext3D);
|
}
|
break;
|
}
|
model.addAttribute("Pubdate", Pubdate);
|
model.addAttribute("mainInfo", res_mainInfo);
|
model.addAttribute("resMainInfoId", resMainInfoId);
|
model.addAttribute("resourceType", leixin);
|
model.addAttribute("WuQZ", isApply);
|
|
return "FuWuZiYuan/ZiYuanSelect_Edit";
|
}
|
|
/**
|
* 删除主表信息
|
*/
|
@ResponseBody
|
@RequestMapping("deleteByPrimaryKey")
|
@LogAction("资源管理,资源发布,资源删除,删除|zy")
|
public int deleteByPrimaryKey(int resourceid, String title) {
|
// 先查询id对应的资源类型是哪一个
|
Res_MainInfo resMainInfo = resMainInfoService.selectByPrimaryKey(resourceid);
|
String leixin = resMainInfo.getResourceclass();
|
if (leixin == null) leixin = "";
|
// 判断该类型对应那张表，然后先删除从表在删除主表
|
//alert ykm 2019/02/26
|
if (leixin.equals("KJ_SWMX") || leixin.equals("KJ_SWDX") || leixin.equals("KJ_SWYX")) leixin = "KJ_SW";
|
switch (leixin) {
|
case "KJ_JCDT":// 基础底图
|
Res_ExtBaseMap resExtBaseMap = resExtBaseMapService.selectByPrimaryKey(resourceid);
|
if (resExtBaseMap != null) {
|
resExtBaseMapService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
case "KJ_YWTC":// 业务图层
|
Res_ExtBusinessLayer resExtBusinessLayer = resExtBusinessLayerService.selectByPrimaryKey(resourceid);
|
if (resExtBusinessLayer != null) {
|
resExtBusinessLayerService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
case "KJ_KJFX":// 空间分析
|
Res_ExtSpaceServerWithBLOBs resExtSpaceServerWithBLOBs = resExtSpaceServerService.selectByPrimaryKey(resourceid);
|
if (resExtSpaceServerWithBLOBs != null) {
|
resExtSpaceServerService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
case "KJ_ZTDT":// 专题地图
|
Res_ExtThemeMap resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resourceid);
|
if (resExtThemeMap != null) {
|
resExtThemeMapService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
// case "专题应用程序":
|
// Res_ExtApp resExtApp =
|
// resExtAppService.selectByPrimaryKey(resourceid);
|
// if (resExtApp != null) {
|
// resExtAppService.deleteByPrimaryKey(resourceid);
|
// }
|
// break;
|
case "YWJC":// 业务集成
|
Res_ExtIntegrate resExtIntegrate = resExtIntegrateService.selectByPrimaryKey(resourceid);
|
if (resExtIntegrate != null) {
|
resExtIntegrateService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
case "SJWJ":// 数据文件
|
Res_ExtFileSource resExtFileSource = resExtFileSourceService.selectByPrimaryKey(resourceid);
|
if (resExtFileSource != null) {
|
resExtFileSourceService.deleteByPrimaryKey(resourceid);
|
}
|
//展现方式
|
List<Res_FileSource_Way> resFileSourceWay = resFileSourceWayService.selectById(resourceid);
|
if (resFileSourceWay != null && resFileSourceWay.size() > 0) {
|
resFileSourceWayService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
case "SJKB":// 数据库表
|
Res_ExtDataBase res_extDataBase = resExtDataBaseService.selectByMainInfoId(resourceid);
|
if (res_extDataBase != null) {
|
resExtDataBaseService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
case "JKFW":// 接口服务
|
Res_ExtInterFaceService res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(resourceid);
|
if (res_extInterFaceService != null) {
|
resExtInterFaceService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
// case "KJ_SWMX":// 三维模型
|
case "KJ_SW":// 三维，三维模型，三维地形，三维影像
|
Res_Ext3D res_ext3D = resExt3DService.selectByPrimaryKey(resourceid);
|
if (res_ext3D != null) {
|
resExt3DService.deleteByPrimaryKey(resourceid);
|
}
|
break;
|
}
|
//资源附件
|
List<Res_Files> resFileList = resFileService.selectDataListForResourceid(resourceid);
|
if (resFileList != null && resFileList.size() > 0) {
|
resFileService.deleteByResourceid(resourceid);
|
}
|
//资源协议与地址
|
List<Res_ExtMapUrl> resExtMapUrlList = resExtMapUrlService.selectByCondition(resourceid);
|
if (resExtMapUrlList != null && resExtMapUrlList.size() > 0) {
|
resExtMapUrlService.deleteByResourceId(resourceid);
|
}
|
//资源操作记录
|
int resActionRecordCount = resActionRecordService.selectCountByResourceid(resourceid);
|
if (resActionRecordCount > 0) {
|
resActionRecordService.deleteByResourceid(resourceid);
|
}
|
//资源申请/推荐
|
int resApplyRecommendCount = resApplyRecommendService.selectCountByResourceid(resourceid);
|
if (resApplyRecommendCount > 0) {
|
resApplyRecommendService.deleteByResourceid(resourceid);
|
}
|
//资源发布注销变更审核
|
int resAuditCount = resAuditService.selectCountByResourceid(resourceid);
|
if (resAuditCount > 0) {
|
resAuditService.deleteByResourceid(resourceid);
|
}
|
//业务关联分析
|
int resBusinessrefCount = resBusinessRefService.selectCountByResourceid(resourceid);
|
if (resBusinessrefCount > 0) {
|
resBusinessRefService.deleteByResourceid(resourceid);
|
}
|
//业务关联周边查询
|
int resQueryAroundCount = resQueryAroundService.selectCountByResourceid(resourceid);
|
if (resQueryAroundCount > 0) {
|
resQueryAroundService.deleteByResourceid(resourceid);
|
}
|
//资源评价
|
int resEvaluationCount = resEvaluationService.selectCountByResourceid(resourceid);
|
if (resEvaluationCount > 0) {
|
resEvaluationService.deleteByResourceid(resourceid);
|
}
|
|
//删除资源操作日志表数据 alert ykm 2019/03/19
|
int resaction = resActionRecordService.selectCountByResourceid(resourceid);
|
if (resaction > 0) {
|
resActionRecordService.deleteByResourceid(resourceid);
|
}
|
|
//自定义图层未实现
|
return resMainInfoService.deleteByPrimaryKey(resourceid);
|
}
|
|
/**
|
* 访问资源审核页面
|
*/
|
/* 插入资源编辑页面内容 */
|
@RequestMapping("ZiYuanShenHe/Index")
|
public String ziYuanShenHeIndex(Model model) {
|
// 获取下拉框目录
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
model.addAttribute("ResourceTypeList", ResourceTypeList);
|
return "ZiYuanShenHe/Index";
|
}
|
|
@RequestMapping("ziYuanLiuLanInsert")
|
@ResponseBody
|
public String ziYuanLiuLanInsert() {
|
Res_ActionRecord resActionRecord = new Res_ActionRecord();
|
resActionRecord.setResourceid(1);
|
resActionRecord.setUserid(getUserId());
|
resActionRecord.setAppid(1);
|
Timestamp audittime = new Timestamp(new Date().getTime());
|
resActionRecord.setActiontime(audittime);
|
resActionRecord.setActiontype("浏览");
|
int result = resActionRecordService.insertSelective(resActionRecord);
|
|
return "" + result;
|
}
|
|
/**
|
* 查询资源审核列表功能(修改请到ResAuditController)
|
*/
|
@ResponseBody
|
@RequestMapping("selectResMainInfojoinAudit")
|
public String selectResMainInfojoinAudit(Res_MainInfo resMainInfo, PageBean pageBean) {
|
PageHelper.startPage(pageBean.getPage(), pageBean.getLimit());
|
List<MainInfoJoinAudit> mainInfoJoinAuditList = resMainInfoService.selectResMainInfojoinAudit(resMainInfo);
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
int countNums = (int) ((Page) mainInfoJoinAuditList).getTotal();
|
PageBean<MainInfoJoinAudit> pageData = new PageBean<>(pageBean.getPage(), pageBean.getLimit(), countNums);
|
pageData.setItems(mainInfoJoinAuditList);
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
StringBuilder rsb = new StringBuilder();
|
rsb.append("{'totalCount':'" + countNums + "','topics':[");
|
for (Integer i = 0; i < mainInfoJoinAuditList.size(); i++) {
|
if (i != 0) {
|
rsb.append(",");
|
}
|
String resourceclass = ResourceTypeList.get(mainInfoJoinAuditList.get(i).getResourceclass());
|
if (resourceclass == null) {
|
resourceclass = "";
|
}
|
rsb.append("{'resourceid':'" + mainInfoJoinAuditList.get(i).getResourceid() + "','title':'" + mainInfoJoinAuditList.get(i).getTitle() + "','resourceclass':'" + resourceclass + "','pubunitid':'" + mainInfoJoinAuditList.get(i).getPubunitid() + "','pubdate':'" + sdf.format(mainInfoJoinAuditList.get(i).getPubdate()) + "','audituserid':'" + mainInfoJoinAuditList.get(i).getAudituserid() + "','auditstatus':'" + mainInfoJoinAuditList.get(i).getAuditstatus() + "'}");
|
}
|
rsb.append("]}");
|
return rsb.toString();
|
}
|
|
/**
|
* 资源注销 审核状态，为提交审核通过，则资源服务状态改为正常；如是注销，则修改审核状态为未提交（可以修改保存、提交、审核）；
|
*
|
* @param resourceid
|
* @return
|
*/
|
@ResponseBody
|
@RequestMapping("ZiYuan/SignOutResource")
|
@LogAction("资源管理,资源发布,资源修改（注销）,修改")
|
public String signOutResource(int resourceid) {
|
Res_MainInfo resMainInfo = resMainInfoService.selectByPrimaryKey(resourceid);// 获取资源信息
|
int resourcestatus = 3;// 资源服务状态(0正常/1异常/3注销)
|
resMainInfo.setResourcestatus(resourcestatus);// 设置资源状态为注销
|
resMainInfo.setAuditstatus(0); // 设置资源状态为未提交
|
int auditResult = resMainInfoService.updateByPrimaryKeySelective(resMainInfo);// 更新数据
|
|
return "{success:true,msg:\"注销成功！\"}";
|
}
|
|
/**
|
* 处理文件上传
|
*
|
* @param request
|
* @param file
|
* @param model
|
* @return
|
*/
|
@ResponseBody
|
@RequestMapping("testuploadimg")
|
public String download(HttpServletRequest request, @RequestParam("myFile") MultipartFile file, Model model) {
|
if (file.isEmpty()) {
|
return "No File";
|
}
|
String[] imgTypeArr = new String[]{"jpg", "png", "gif", "bmp", "jpeg"};
|
String imgType = file.getContentType();// 获取文件格式
|
boolean IsImg = false;// 文件格式检查状态
|
// 判断上传文件格式
|
for (int i = 0; i < imgTypeArr.length; i++) {
|
if (imgType.toLowerCase().endsWith(imgTypeArr[i])) {
|
IsImg = true;
|
break;
|
}
|
}
|
|
if (IsImg) {
|
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
|
|
String name = file.getOriginalFilename();
|
System.out.println("FileName:" + name);
|
|
String fileType = name.substring(name.lastIndexOf("."));
|
|
// image的名称
|
String Filename = uuid + fileType;
|
System.out.println("FileType:" + Filename);
|
|
String size = FileUtils.byteCountToDisplaySize(file.getSize());
|
System.out.println("FileSize:" + size);
|
//数据库保存 MainInfo/asdf.jpg
|
//path是本地地址
|
String path = sysConfig.getUploadPath() + "MainInfo\\";
|
File desFile = new File(path + Filename);
|
|
String info = desFile.getAbsolutePath();
|
System.out.println("info:" + info);
|
try {
|
FileUtils.copyInputStreamToFile(file.getInputStream(), desFile);
|
//返回网络地址，然后存储在数据库
|
return "MainInfo/" + Filename;
|
} catch (IOException e) {
|
e.printStackTrace();
|
return "0";
|
}
|
}
|
|
return "-1";
|
}
|
|
/**
|
* 查询所有的资源
|
*/
|
@ResponseBody
|
@RequestMapping("ZiYuan/getAll")
|
public String getAll() {
|
List<Res_MainInfo> list = resMainInfoService.getAll();
|
StringBuilder str = new StringBuilder();
|
str.append("[");
|
for (int i = 0; i < list.size(); i++) {
|
if (i != 0) {
|
str.append(",");
|
}
|
str.append("{");
|
str.append("'title':'" + list.get(i).getTitle() + "',");
|
str.append("'resourceid':'" + list.get(i).getResourceid() + "',");
|
str.append("}");
|
}
|
str.append("]");
|
return str.toString();
|
}
|
|
/**
|
* 查询所有的资源，根据发布时间排序
|
*/
|
@ResponseBody
|
@RequestMapping("ZiYuan/getAllOrderByTime")
|
public Result getAllOrderByTime() {
|
List<Res_MainInfo> list = resMainInfoService.selectAllOrderByTime();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
List<Map<String, Object>> maps = new LinkedList<>();
|
for (int i = 0; i < list.size(); i++) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("title", list.get(i).getTitle());
|
map.put("fulltitle", list.get(i).getTitle());
|
map.put("resourceid", list.get(i).getResourceid());
|
map.put("pubdate", sdf.format(list.get(i).getPubdate()));
|
maps.add(map);
|
}
|
return Result.ok().put("result", maps);
|
}
|
|
// 导出excel
|
@ResponseBody
|
@RequestMapping("ZiYuan/excel")
|
public String excel(HttpServletResponse response, Res_MainInfo resMainInfo) {
|
List<Res_MainInfo> mainInfoJoinCatalogList = resMainInfoService.selectResMainInfojoinCatalog(resMainInfo);
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
StringBuilder rsb = new StringBuilder();
|
String leixin = "";
|
// rsb.append("{'totalCount':'" + "");
|
// rsb.append("','topics':[");
|
|
List<Map<String, Object>> maps = new LinkedList<>();
|
for (Integer i = 0; i < mainInfoJoinCatalogList.size(); i++) {
|
leixin = ResourceTypeList.get(mainInfoJoinCatalogList.get(i).getResourceclass());
|
String chinesename = orgUserService.getChinesename(mainInfoJoinCatalogList.get(i).getCreateuserid()); // obj.getString("chinesename");
|
String unitname = orgUnitService.getUnitName((long) mainInfoJoinCatalogList.get(i).getPubunitid()); // obj1.getString("unitname");
|
String mulu = GetBianMu(mainInfoJoinCatalogList.get(i).getCatlogid() == null ? 0 : mainInfoJoinCatalogList.get(i).getCatlogid());
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("resourceid", mainInfoJoinCatalogList.get(i).getResourceid());
|
map.put("title", mainInfoJoinCatalogList.get(i).getTitle());
|
map.put("mulu", mulu);
|
map.put("resourceclass", leixin);
|
map.put("pubdate", sdf.format(mainInfoJoinCatalogList.get(i).getPubdate()));
|
map.put("pubunitid", unitname);
|
map.put("createuserid", chinesename);
|
maps.add(map);
|
}
|
|
String a[] = {"资源id", "资源名称", "所属目录编码", "资源类型", "发布时间", "发布单位", "发布添加人"};
|
try {
|
String Filename = Excel.going(response, a, JSON.toJSONString(maps, SerializerFeature.WriteMapNullValue), sysConfig.getUploadPath() + "excel\\");
|
String path2 = "/uploadPath/excel/";
|
String desFile = path2 + Filename;
|
System.out.println(desFile);
|
return desFile;
|
} catch (IOException e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
// 获取最新的6条热门搜索
|
@ResponseBody
|
@GetMapping("/getTopHotSearch")
|
public Result getTopHotSearch() {
|
StringBuilder str = new StringBuilder();
|
List<String> list = resMainInfoService.selectTopHotSearch();
|
str.append("[");
|
|
List<Map<String, Object>> maps = new LinkedList<>();
|
|
for (int i = 0; i < list.size(); i++) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("keyword", list.get(i));
|
maps.add(map);
|
}
|
return Result.ok().put("result", maps);
|
}
|
|
/**
|
* 发布时间 http://127.0.0.1:8082/res/ziyuanmulu/index?Menu=ZYZX&menuId=07在这个页面当中调用了
|
*/
|
@ResponseBody
|
@RequestMapping("/ZiYuan/getZiYuanFaBuQingKuangChartData")
|
public String getZiYuanFaBuQingKuangChartData(String Method) {
|
String ResultJson = "";
|
String preJcdtSeries = "";
|
String preYwtcSeries = "";
|
String preZtdtSeries = "";
|
String preWdcgSeries = "";
|
String preQtSeries = "";
|
String nowJcdtSeries = "";
|
String nowYwtcSeries = "";
|
String nowZtdtSeries = "";
|
String nowWdcgSeries = "";
|
String nowQtSeries = "";
|
String Legend = "[{\"name\":\"基础底图\", \"icon\": \"rect\"},{\"name\":\"业务图层\", \"icon\": \"rect\"},{\"name\":\"专题地图\", \"icon\": \"rect\"},{\"name\":\"数据文件\", \"icon\": \"rect\"},{\"name\":\"其它\", \"icon\": \"rect\"}]";
|
if (Method.equals("Month")) {
|
String monstr = "[";
|
Date nowDate = new Date();
|
int nowmon = nowDate.getMonth(); // 记录当前的月份，并且生成X轴的字符
|
int lastmon = 0;
|
if (nowmon == 12) {
|
lastmon = 13;
|
} else {
|
lastmon = nowmon + 1;
|
}
|
for (int j = nowmon; j >= 1; j--) {
|
monstr = monstr + "\"" + j + "月\"" + ",";
|
}
|
for (int i = 12; i >= lastmon; i--) {
|
monstr = monstr + "\"去年" + i + "月\"" + ",";
|
}
|
|
monstr = monstr.substring(0, monstr.length() - 1);
|
monstr = monstr + "]";
|
int Year = nowDate.getYear();
|
int LastYear = Year - 1;
|
List<GroupByPubDate> preMonthList = resMainInfoService.selectResMainInfoGroupByPubDate(LastYear);
|
List<GroupByPubDate> nowMonthList = resMainInfoService.selectResMainInfoGroupByPubDate(Year);
|
String[] zylxList = new String[]{"KJ_JCDT", "KJ_YWTC", "KJ_ZTDT", "SJWJ", "QT"};
|
// 去年的月份资源拼接
|
if (nowmon != 12) {
|
// 去年资源发布数据统计，如果现在是12月则不统计去年的
|
for (int i = 0; i < zylxList.length; i++) {
|
int j = 0;
|
switch (zylxList[i]) {
|
case "KJ_JCDT":
|
preJcdtSeries = Screen(preJcdtSeries, lastmon, preMonthList, "KJ_JCDT");
|
break;
|
case "KJ_YWTC":
|
preJcdtSeries = Screen(preJcdtSeries, lastmon, preMonthList, "KJ_YWTC");
|
break;
|
case "KJ_ZTDT":
|
preJcdtSeries = Screen(preJcdtSeries, lastmon, preMonthList, "KJ_ZTDT");
|
break;
|
case "SJWJ":
|
preJcdtSeries = Screen(preJcdtSeries, lastmon, preMonthList, "SJWJ");
|
break;
|
default:
|
preQtSeries = ScreenOther(preQtSeries, lastmon, preMonthList);
|
break;
|
}
|
}
|
}
|
// 今年的资源拼接
|
for (int i = 0; i < zylxList.length; i++) {
|
String item = zylxList[i];
|
// 今年的资源发布情况数据统计
|
int j = 0;
|
switch (item) {
|
case "KJ_JCDT":
|
nowJcdtSeries = MontageResource(nowJcdtSeries, nowmon, nowMonthList, "KJ_JCDT");
|
break;
|
case "KJ_YWTC":
|
nowJcdtSeries = MontageResource(nowJcdtSeries, nowmon, nowMonthList, "KJ_YWTC");
|
break;
|
case "KJ_ZTDT":
|
nowJcdtSeries = MontageResource(nowJcdtSeries, nowmon, nowMonthList, "KJ_ZTDT");
|
break;
|
case "SJWJ":
|
nowJcdtSeries = MontageResource(nowJcdtSeries, nowmon, nowMonthList, "SJWJ");
|
break;
|
default:
|
nowQtSeries = MontageResourceOther(nowQtSeries, nowmon, nowMonthList);
|
break;
|
}
|
}
|
ResultJson = "{\"Legend\": " + Legend + ", \"xAxis\": " + monstr + ", \"Series\": {\"JcdtSeries\":[" + preJcdtSeries + nowJcdtSeries + "], \"YwtcSeries\": [" + preYwtcSeries + nowYwtcSeries + "], \"ZtdtSeries\": [" + preZtdtSeries + nowZtdtSeries + "],\"WdcgSeries\": [" + preWdcgSeries + nowWdcgSeries + "], \"prenowQtSeries\": [" + preQtSeries + nowQtSeries + "]}}";
|
}
|
return ResultJson;
|
}
|
|
//拼接资源(其他的)
|
private String MontageResourceOther(String nowQtSeries, int nowmon, List<GroupByPubDate> nowMonthList) {
|
int j;
|
List<GroupByPubDate> qt = nowMonthList.stream().filter((GroupByPubDate b) -> b.getResourceclass() != "KJ_JCDT" && b.getResourceclass() != "KJ_YWTC" && b.getResourceclass() != "KJ_ZTDT" && b.getResourceclass() != "SJWJ").collect(Collectors.toList());
|
// 降序是否正确
|
Collections.sort(qt, new Comparator() {
|
@Override
|
public int compare(Object o1, Object o2) {
|
if (o1 instanceof GroupByPubDate && o2 instanceof GroupByPubDate) {
|
GroupByPubDate e1 = (GroupByPubDate) o1;
|
GroupByPubDate e2 = (GroupByPubDate) o2;
|
return e2.getMonth() - e1.getMonth();
|
}
|
throw new ClassCastException("不能转换为GroupByPubDate类型");
|
}
|
});
|
j = 0;
|
for (int k = nowmon; k >= 1; k--) {
|
List<GroupByPubDate> monList = null;
|
switch (k) {
|
case 1:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 1).collect(Collectors.toList());
|
break;
|
case 2:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 2).collect(Collectors.toList());
|
break;
|
case 3:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 3).collect(Collectors.toList());
|
break;
|
case 4:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 4).collect(Collectors.toList());
|
break;
|
case 5:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 5).collect(Collectors.toList());
|
break;
|
case 6:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 6).collect(Collectors.toList());
|
break;
|
case 7:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 7).collect(Collectors.toList());
|
break;
|
case 8:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 8).collect(Collectors.toList());
|
break;
|
case 9:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 9).collect(Collectors.toList());
|
break;
|
case 10:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 10).collect(Collectors.toList());
|
break;
|
case 11:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 11).collect(Collectors.toList());
|
break;
|
case 12:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 12).collect(Collectors.toList());
|
break;
|
}
|
int total = 0;
|
if (monList.size() > 0) {
|
for (int z = 0; z < monList.size(); z++) {
|
total = total + monList.get(z).getCount();
|
}
|
}
|
|
nowQtSeries += (nowQtSeries == "" ? "" : ",") + total;
|
j++;
|
}
|
if (nowmon != 12) {
|
nowQtSeries = nowQtSeries + ",";
|
}
|
return nowQtSeries;
|
}
|
|
//拼接资源(特定类型的)
|
private String MontageResource(String nowJcdtSeries, int nowmon, List<GroupByPubDate> nowMonthList, String type) {
|
int j;// 筛选类型为基础底图的集合
|
List<GroupByPubDate> jcdt = nowMonthList.stream().filter((GroupByPubDate b) -> b.getResourceclass() == type).collect(Collectors.toList());
|
// 降序是否正确
|
Collections.sort(jcdt, new Comparator() {
|
@Override
|
public int compare(Object o1, Object o2) {
|
if (o1 instanceof GroupByPubDate && o2 instanceof GroupByPubDate) {
|
GroupByPubDate e1 = (GroupByPubDate) o1;
|
GroupByPubDate e2 = (GroupByPubDate) o2;
|
return e2.getMonth() - e1.getMonth();
|
}
|
throw new ClassCastException("不能转换为GroupByPubDate类型");
|
}
|
});
|
j = 0;
|
for (int k = nowmon; k >= 1; k--) {
|
if (k == nowmon) {
|
if (jcdt.size() > 0) {
|
for (int x = k; x < jcdt.get(j).getMonth(); j++) {
|
// 由于分组采用倒序排序，此处保证开始统计的月份是当前月份
|
}
|
}
|
}
|
if (j >= jcdt.size() || jcdt.get(j).getMonth() != k) {
|
nowJcdtSeries += (nowJcdtSeries == "" ? "" : ",") + 0;
|
|
} else {
|
nowJcdtSeries += (nowJcdtSeries == "" ? "" : ",") + jcdt.get(j).getCount();
|
j++;
|
}
|
}
|
if (nowmon != 12) {
|
nowJcdtSeries = nowJcdtSeries + ",";
|
}
|
return nowJcdtSeries;
|
}
|
|
// 筛选不同类型的集合(其他的)
|
private String ScreenOther(String preQtSeries, int lastmon, List<GroupByPubDate> preMonthList) {
|
List<GroupByPubDate> qt = preMonthList.stream().filter((GroupByPubDate b) -> b.getResourceclass() != "KJ_JCDT" && b.getResourceclass() != "KJ_YWTC" && b.getResourceclass() != "KJ_ZTDT" && b.getResourceclass() != "SJWJ").collect(Collectors.toList());
|
// 降序是否正确
|
Collections.sort(qt, new Comparator() {
|
@Override
|
public int compare(Object o1, Object o2) {
|
if (o1 instanceof GroupByPubDate && o2 instanceof GroupByPubDate) {
|
GroupByPubDate e1 = (GroupByPubDate) o1;
|
GroupByPubDate e2 = (GroupByPubDate) o2;
|
return e2.getMonth() - e1.getMonth();
|
}
|
throw new ClassCastException("不能转换为GroupByPubDate类型");
|
}
|
});
|
for (int k = 12; k >= lastmon; k--) {
|
List<GroupByPubDate> monList = null;
|
switch (k) {
|
case 1:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 1).collect(Collectors.toList());
|
break;
|
case 2:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 2).collect(Collectors.toList());
|
break;
|
case 3:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 3).collect(Collectors.toList());
|
break;
|
case 4:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 4).collect(Collectors.toList());
|
break;
|
case 5:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 5).collect(Collectors.toList());
|
break;
|
case 6:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 6).collect(Collectors.toList());
|
break;
|
case 7:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 7).collect(Collectors.toList());
|
break;
|
case 8:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 8).collect(Collectors.toList());
|
break;
|
case 9:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 9).collect(Collectors.toList());
|
break;
|
case 10:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 10).collect(Collectors.toList());
|
break;
|
case 11:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 11).collect(Collectors.toList());
|
break;
|
case 12:
|
monList = qt.stream().filter((GroupByPubDate b) -> b.getMonth() == 12).collect(Collectors.toList());
|
break;
|
}
|
|
int total = 0;
|
if (monList.size() > 0) {
|
for (int z = 0; z < monList.size(); z++) {
|
total = total + monList.get(z).getCount();
|
}
|
}
|
|
preQtSeries += (preQtSeries == "" ? "" : ",") + total;
|
}
|
return preQtSeries;
|
}
|
|
// 筛选不同类型的集合(特定类型的)
|
private String Screen(String preJcdtSeries, int lastmon, List<GroupByPubDate> preMonthList, String type) {
|
int j;
|
List<GroupByPubDate> jcdt = preMonthList.stream().filter((GroupByPubDate b) -> b.getResourceclass() == type).collect(Collectors.toList());
|
// 降序是否正确
|
Collections.sort(jcdt, new Comparator() {
|
@Override
|
public int compare(Object o1, Object o2) {
|
if (o1 instanceof GroupByPubDate && o2 instanceof GroupByPubDate) {
|
GroupByPubDate e1 = (GroupByPubDate) o1;
|
GroupByPubDate e2 = (GroupByPubDate) o2;
|
return e2.getMonth() - e1.getMonth();
|
}
|
throw new ClassCastException("不能转换为GroupByPubDate类型");
|
}
|
});
|
j = 0;
|
for (int k = 12; k >= lastmon; k--) {
|
if (j >= jcdt.size() || jcdt.get(j).getMonth() != k) {
|
preJcdtSeries += (preJcdtSeries == "" ? "" : ",") + 0;
|
} else {
|
preJcdtSeries += (preJcdtSeries == "" ? "" : ",") + jcdt.get(j).getCount();
|
j++; }
|
}
|
return preJcdtSeries;
|
}
|
|
/**
|
* 获取最新6笔资源推荐
|
*/
|
@ResponseBody
|
@RequestMapping("ZiYuan/getTopRecommend")
|
public Result getTopRecommend(boolean isDiTuFuwu) {
|
Long userid = getUserId();
|
Long unitId = orgUserService.getDefaultUnit(userid).getUnitid();
|
Res_ApplyRecommend resApplyRecommend = new Res_ApplyRecommend();
|
resApplyRecommend.setAppuserid(userid.toString());
|
resApplyRecommend.setAppunitid(unitId.toString());
|
Map<String, Object> paramMap = new HashMap<String, Object>();
|
paramMap.put("appuserid", userid);
|
paramMap.put("appunitid", unitId);
|
if (isDiTuFuwu == true) {
|
paramMap.put("isDiTuFuwu", getMapResourceClass());
|
} else {
|
paramMap.put("isDiTuFuwu", null);
|
}
|
List<Res_MainInfo> resMainInfoList = resApplyRecommendService.getTopRecommend(paramMap);
|
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
StringBuilder str = new StringBuilder();
|
str.append("[");
|
|
List<Map<String, Object>> maps = new LinkedList<>();
|
for (int i = 0; i < resMainInfoList.size(); i++) {
|
Map<String, Object> map = new HashMap<>();
|
String description = resMainInfoList.get(i).getDescription();
|
if (description != null && description.length() > 60) {
|
description = description.substring(0, 60) + "...";
|
try {
|
description = URLEncoder.encode(description, "utf-8").replace("+", "%20");
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
map.put("description", description);
|
// str.append("'description':'" + description + "',");
|
} else {
|
try {
|
if (description != null) {
|
description = URLEncoder.encode(description, "utf-8").replace("+", "%20");
|
} else description = "";
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
map.put("description", description);
|
// str.append("'description':'" + description + "',");
|
}
|
String fulldescription = resMainInfoList.get(i).getDescription();
|
try {
|
if (fulldescription != null)
|
fulldescription = URLEncoder.encode(fulldescription, "utf-8").replace("+", "%20");
|
else fulldescription = "";
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
String path = null;
|
if (resMainInfoList.get(i).getImgurl() != null && !resMainInfoList.get(i).getImgurl().isEmpty()) {
|
if (resMainInfoList.get(i).getImgurl().startsWith("Atkas")) {//图集
|
path = "/image/" + resMainInfoList.get(i).getImgurl();
|
File file = new File(System.getProperty("user.dir") + "\\src\\main\\resources\\static" + ("/image/" + resMainInfoList.get(i).getImgurl()).replace("/", "\\"));
|
if (!file.exists()) { //判断物理路径是否存在，不存在则默认
|
path = "/image/classimg/" + resMainInfoList.get(i).getResourceclass() + ".gif";
|
}
|
} else {
|
path = "/uploadPath/" + resMainInfoList.get(i).getImgurl();
|
String filepath = sysConfig.getUploadPath() + resMainInfoList.get(i).getImgurl();
|
File file = new File(filepath);
|
if (!file.exists()) { //判断物理路径是否存在，不存在则默认
|
path = "/image/classimg/" + resMainInfoList.get(i).getResourceclass() + ".gif";
|
}
|
}
|
} else {
|
path = "/image/classimg/" + resMainInfoList.get(i).getResourceclass() + ".gif";
|
}
|
map.put("title", resMainInfoList.get(i).getTitle());
|
map.put("fulldescription", fulldescription);
|
map.put("resourceclass", resMainInfoList.get(i).getResourceclass());
|
map.put("imgurl", path);
|
map.put("pubdate", sdf.format(resMainInfoList.get(i).getPubdate()));
|
map.put("resourceid", resMainInfoList.get(i).getResourceid());
|
|
//判断是否有权限
|
Map<String, Object> smap = new HashMap<>();
|
smap.put("resourceid", resMainInfoList.get(i).getResourceid());
|
smap.put("userid", getUserId());
|
smap.put("unitid", unitId);
|
int count = resMainInfoService.checkZiYuanQuanXian(smap);
|
//有权限查看（1有，0没有）
|
Integer isquanxian = 0;
|
if (count > 0) {
|
isquanxian = 1;
|
}
|
map.put("isquanxian", isquanxian);
|
map.put("firstMapUrl", getZTDTByPortalMapUrl(resMainInfoList.get(i).getResourceid(), resMainInfoList.get(i).getResourceclass()));
|
maps.add(map);
|
|
}
|
// str.append("]");
|
// String jsonEncoder = new sun.misc.BASE64Encoder().encode(str.toString().getBytes());
|
return Result.ok().put("result", maps);
|
}
|
|
/**
|
* 获取所有资源推荐
|
*
|
* @return
|
*/
|
@ResponseBody
|
@RequestMapping("ZiYuan/getAllRecommend")
|
public Result getAllRecommend(boolean isDiTuFuwu) {
|
Long userid = getUserId();
|
Long unitId = orgUserService.getDefaultUnit(userid).getUnitid();
|
|
Res_ApplyRecommend resApplyRecommend = new Res_ApplyRecommend();
|
resApplyRecommend.setAppuserid(userid.toString());
|
resApplyRecommend.setAppunitid(unitId.toString());
|
Map<String, Object> paramMap = new HashMap<String, Object>();
|
paramMap.put("appuserid", userid);
|
paramMap.put("appunitid", unitId);
|
if (isDiTuFuwu) {
|
paramMap.put("isDiTuFuwu", getMapResourceClass());
|
} else {
|
paramMap.put("isDiTuFuwu", null);
|
}
|
List<Res_MainInfo> resMainInfoList = resApplyRecommendService.getAllRecommend(paramMap);
|
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
StringBuilder str = new StringBuilder();
|
str.append("[");
|
|
List<Map<String, Object>> maps = new LinkedList<>();
|
for (int i = 0; i < resMainInfoList.size(); i++) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("title", resMainInfoList.get(i).getTitle());
|
map.put("resourceid", resMainInfoList.get(i).getResourceid());
|
|
if (resMainInfoList.get(i).getDescription().length() > 60) {
|
String description = resMainInfoList.get(i).getDescription().substring(0, 60) + "...";
|
// str.append("'description':'" + description + "',");
|
map.put("description", description);
|
} else {
|
map.put("description", resMainInfoList.get(i).getDescription());
|
// str.append("'description':'" + resMainInfoList.get(i).getDescription() + "',");
|
}
|
map.put("resourceclass", resMainInfoList.get(i).getResourceclass());
|
String path = null;
|
if (!resMainInfoList.get(i).getImgurl().isEmpty()) {
|
path = "/uploadPath/" + resMainInfoList.get(i).getImgurl();
|
String filepath = sysConfig.getUploadPath() + resMainInfoList.get(i).getImgurl();
|
File file = new File(filepath);
|
if (!file.exists()) { //判断物理路径是否存在，不存在则默认
|
path = "/image/classimg/" + resMainInfoList.get(i).getResourceclass() + ".gif";
|
}
|
} else {
|
path = "/image/classimg/" + resMainInfoList.get(i).getResourceclass() + ".gif";
|
}
|
map.put("imgurl", path);
|
map.put("pubdate", sdf.format(resMainInfoList.get(i).getPubdate()));
|
maps.add(map);
|
}
|
return Result.ok().put("result", maps);
|
}
|
|
// 获取地图服务的类型代码
|
private String getMapResourceClass() {
|
LinkedHashMap<String, String> resourceTypeList = FieldUtils.getFieldListByKey("ResourceType");
|
Iterator<Map.Entry<String, String>> iter = resourceTypeList.entrySet().iterator();
|
String dituTypes = "";
|
while (iter.hasNext()) {
|
Map.Entry entry = (Map.Entry) iter.next();
|
Object key = entry.getKey();
|
if (key.toString().startsWith("KJ_")) {
|
dituTypes += "'" + key.toString() + "',";
|
}
|
}
|
dituTypes = dituTypes.length() > 0 ? dituTypes.substring(0, dituTypes.length() - 1) : dituTypes;
|
return dituTypes;
|
}
|
|
/**
|
* 资源目录左侧面板目录结构
|
*
|
* @param id 节点ID
|
* @param treeType 目录树类型（0：资源目录 4：资源类型）
|
* @param XZQHID 区域ID
|
* @param NF 时间
|
* @param IsSC 是否收藏
|
* @return String
|
*/
|
@ResponseBody
|
@RequestMapping("GetMuLuTreeData")
|
public String getMuLuTreeData(Integer id, int treeType, String XZQHID, String NF, int IsSC, String catalogName, String ResourceClass,String spcStatus) {
|
String result = "";
|
if (id == null) id = 0;
|
Map<String, Object> map = new HashMap<>();
|
map.put("parentid", id);
|
map.put("xzqhid", XZQHID);
|
if (NF != null && !NF.isEmpty()) {
|
map.put("nf", NF);
|
}
|
map.put("shoucang", IsSC);
|
// added by qfx at 2021-09-15
|
if(StringUtils.isNotEmpty(ResourceClass)){
|
map.put("resourceclass",ResourceClass);
|
}else{
|
map.put("resourceclass","");
|
}
|
if (treeType == 0) {// 资源目录
|
if (catalogName != null && !catalogName.isEmpty()) {
|
catalogName = catalogName.replaceAll("%(?![0-9a-fA-F]{2})", "%25");//编码需要处理%号，判断%是否是十六进制编码后的%号
|
//dsh 2018/12/12
|
map.put("catalogName", URLDecoder.decode(catalogName));
|
}
|
map.put("spcStatus",spcStatus);
|
List<Res_Catalog> resCatalogList = resCatalogService.getMuLuTreeData(map);
|
for (Res_Catalog resCatalog : resCatalogList) {
|
int childCount = resCatalogService.selectResCatalogIsExistsSon(resCatalog.getCatlogid(),spcStatus);
|
result += (result.length() > 0 ? "," : "") + "{id:" + resCatalog.getCatlogid() + ", code: '" + resCatalog.getCatlogcode() + "', name:'" + resCatalog.getTitle() + "(" + GetZYCountByClassNew(0, resCatalog.getCatlogcode(), catalogName , ResourceClass,spcStatus) + ")', pId:" + resCatalog.getParentid() + ", rpId:" + resCatalog.getParentid() + (childCount > 0 ? ",isParent:true,iconOpen:'/image/classicons/folderOpen.png',iconClose:'/image/classicons/folder.png'" : ",icon:'/image/classicons/defaulticon.png'") + "}";
|
}
|
} else if (treeType == 4) {// 资源类型
|
LinkedHashMap<String, String> ResourceTypeList = FieldUtils.getFieldListByKey("ResourceType");// 获取资源类型列表
|
String kj = "";
|
if (ResourceTypeList.size() > 0) {
|
int count = 0;
|
for (Map.Entry<String, String> entry : ResourceTypeList.entrySet()) {
|
if (entry.getKey().length() > 3 && entry.getKey().substring(0, 3).equals("KJ_")) {
|
kj += (kj.length() > 0 ? "," : "") + "{id:'" + entry.getKey() + "', code: '" + entry.getKey() + "', name:'" + entry.getValue() + "(" + GetZYCountByClassNew(4, "", "", entry.getKey(),spcStatus) + ")'" + ",icon:'/image/classicons/" + entry.getKey() + ".png'" + " }";
|
}
|
}
|
for (Map.Entry<String, String> entry : ResourceTypeList.entrySet()) {
|
if (entry.getKey().equals("KJ_")) {
|
result += (result.length() > 0 ? "," : "") + "{id:'" + entry.getKey() + "', code: '" + entry.getKey() + "', name:'" + entry.getValue() + "(" + GetZYCountByClassNew(4, "", "", entry.getKey(),spcStatus) + ")',open:true,children:[" + kj + "],iconOpen:'/image/classicons/folderOpen.png',iconClose:'/image/classicons/folder.png'}";
|
} else if (entry.getKey().length() > 3 && entry.getKey().substring(0, 3).equals("KJ_")) {
|
continue;
|
} else {
|
result += (result.length() > 0 ? "," : "") + "{id:'" + entry.getKey() + "', code: '" + entry.getKey() + "', name:'" + entry.getValue() + "(" + GetZYCountByClassNew(4, "", "", entry.getKey(),spcStatus) + ")'" + ",icon:'/image/classicons/" + entry.getKey() + ".png'" + "}";
|
}
|
}
|
System.out.println(result);
|
}
|
}
|
if (id == 0 && treeType == 4) {
|
result = "{id:0,name:'" + (treeType == 4 ? "资源类型" : "资源目录") + "(" + GetZYCountByClassNew(0, "", "", ResourceClass,spcStatus) + ")',pId:-1,isParent:true,open:true,children:[" + result + "],iconOpen:'/image/classicons/folderOpen.png',iconClose:'/image/classicons/folder.png' }";
|
}
|
return "[" + result + "]";
|
}
|
|
/**
|
* 根据名称拼音 显示名字
|
*/
|
@ResponseBody
|
@RequestMapping("/user/findUserByWord")
|
public String findUserByWord(String keyWord, HttpServletRequest request) {
|
String callbackFunName = request.getParameter("callback");
|
if (callbackFunName == null || callbackFunName.isEmpty()) {
|
callbackFunName = "callback";
|
}
|
String url = sysConfig.getApiServer() + "/api/org/user/findUserByWord/" + URLEncoder.encode(keyWord);
|
String username = null;
|
try {
|
username = HttpOperateUtils.httpGet(url);
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
StringBuilder Json = new StringBuilder();
|
Json.append(username);
|
//System.out.print("test:==============" + Json.toString());
|
//return Json.toString();
|
return callbackFunName + "(" + Json.toString() + ")";
|
}
|
|
/**
|
* 资源查看页面新版
|
*/
|
@RequestMapping("ZiYuan/ZiYuanBaseInfo")
|
public String ziYuanBaseInfo(Integer resourceid, Model model, HttpServletRequest request) {
|
Long userId = getUserId(); //获取用户ID
|
OrgUnit orgUnit = getUnit();//获取用户单位信息
|
model.addAttribute("backstageWebRoot", sysConfig.getApiServer() + "/"); // 后台服务路径
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot()); // 公共资源库路径
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("gisPortal", sysConfig.getGisPortal());
|
model.addAttribute("userId", String.valueOf(userId));
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
String integratetype = "";
|
String integrateurl = "";
|
// 修改
|
res_mainInfo = resMainInfoService.selectByPrimaryKey(resourceid);
|
if (res_mainInfo == null) {
|
model.addAttribute("pubzyWebRoot", sysConfig.getPubzyWebRoot());
|
model.addAttribute("systemName", sysConfig.getAppFullName());
|
model.addAttribute("message", "资源已被删除，无法查看！");
|
return "ResManage/ResRegister/ZiYuanErrorPage";
|
}
|
if (res_mainInfo != null) {
|
//判断显示是否未提交、未审核、审核未通过
|
if (res_mainInfo.getAuditstatus() == 0) {
|
String html = "";
|
html += "<span style='font-size: 14px;'>【<font style='color:white;' '>未提交</font>】</span>";
|
model.addAttribute("shenhe", html);
|
} else if (res_mainInfo.getAuditstatus() == 1) {
|
String html = "";
|
html += "<span style='font-size: 14px;'>【<font style='color:white;' '>未审核</font>】</span>";
|
model.addAttribute("shenhe", html);
|
} else if (res_mainInfo.getAuditstatus() == 3) {
|
String html = "";
|
html += "<span style='font-size: 14px;'>【<font style='color:white;' '>审核未通过</font>】</span>";
|
model.addAttribute("shenhe", html);
|
}
|
|
// 收藏，用来判断登录的用户是否有收藏这个资源
|
Res_ActionRecord resActionRecord = new Res_ActionRecord();
|
resActionRecord.setUserid(userId);
|
resActionRecord.setResourceid(resourceid);
|
resActionRecord.setActiontype("收藏");
|
Res_ActionRecord res_actionRecord = resActionRecordService.getUserActionRecord(resActionRecord);
|
if (res_actionRecord != null) {
|
model.addAttribute("actionid", res_actionRecord.getActionid());//已收藏
|
} else {
|
model.addAttribute("actionid", 0);//未收藏
|
}
|
|
// 统计该资源的收藏次数
|
Res_ActionRecord resActionRecord1 = new Res_ActionRecord();
|
resActionRecord1.setActiontype("收藏");
|
resActionRecord1.setResourceid(resourceid);
|
int countResult = resActionRecordService.selectResourceCount(resActionRecord1);
|
model.addAttribute("shoucangcount", countResult);
|
|
// 统计该资源的浏览次数
|
Res_ActionRecord resActionRecord2 = new Res_ActionRecord();
|
resActionRecord2.setActiontype("浏览");
|
resActionRecord2.setResourceid(resourceid);
|
int countResult1 = resActionRecordService.selectResourceCount(resActionRecord2);
|
model.addAttribute("liulancount", countResult1);
|
|
// 统计该资源的调用次数
|
Res_ActionRecord resActionRecord3 = new Res_ActionRecord();
|
resActionRecord3.setActiontype("调用");
|
resActionRecord3.setResourceid(resourceid);
|
int countResult2 = resActionRecordService.selectResourceCount(resActionRecord3);
|
model.addAttribute("diaoyongcount", countResult2);
|
|
// 统计该资源的申请次数
|
Res_ApplyRecommend resApplyRecommend = new Res_ApplyRecommend();
|
resApplyRecommend.setResourceid(resourceid);
|
//alter: Xxx 资源申请数量统计完善 20181227
|
int shenqingcount = resApplyRecommendService.getApplyCount(resourceid);
|
model.addAttribute("shenqingcount", shenqingcount);
|
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat sdfmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
String Pubdate = sdf.format(res_mainInfo.getPubdate());
|
// 判断所属目录
|
strMuLu = "";
|
res_mainInfo.setCatlogcode(GetBianMu(res_mainInfo.getCatlogid()));
|
// 判断发布单位
|
String unitname = orgUnitService.getUnitById((long) res_mainInfo.getPubunitid()).getUnitname();
|
model.addAttribute("unitname", unitname);
|
// res_mainInfo.setPubunitid(unitid);
|
// 判断数据覆盖范围
|
// modified by qufangxu 信创环境下，若 res_mainInfo.getAdministrativeid() = ' ',会返回单点登录页面，具体原因未知。 解决办法：提前去除空格、制表符
|
String administrativeid = (String) res_mainInfo.getAdministrativeid();
|
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 = "";
|
try {
|
jsonStr = HttpOperateUtils.httpGet(getRegionInfourl.trim());
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
if (jsonStr != null && !jsonStr.isEmpty()) {
|
JSONObject item = JSONObject.parseObject(jsonStr);
|
String regionname = item.getString("regionname");
|
res_mainInfo.setAdministrativeid(regionname);
|
}
|
}
|
|
//申请按钮控制
|
Integer isApply = -1;//-1 发布人、完全公开、已有记录且审核过且未超过有效截止时间，不显示申请按钮 1 已申请未批复
|
//如果当前用户是管理员则不显示申请按钮
|
if (!SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
if (!res_mainInfo.getCreateuserid().equals(userId) && !res_mainInfo.getSharprotocol().equals("完全公开") && !(res_mainInfo.getSharprotocol().equals("单位内公开") && res_mainInfo.getPubunitid() == orgUnit.getUnitid().intValue())) {
|
// 获取是否有在申请表有申请RES_APPLYRECOMMEND
|
Map<String, Object> map = new HashMap<>();
|
map.put("resourceid", resourceid);
|
map.put("userid", userId);
|
map.put("unitid", orgUnit.getUnitid());
|
Res_ApplyRecommend recommend = resApplyRecommendService.checkZiYuanShenQing(map);
|
if (recommend != null) {
|
if (recommend.getAuditresult().equals(0)) {//已申请未批复
|
isApply = 1;
|
}else if(recommend.getAuditresult().equals(2)){//已批复未通过
|
isApply = 0;
|
}
|
else {//申请批复后时间没有过
|
Long timenum = new Date().getTime();
|
if (recommend.getEffendtime() != null && timenum < recommend.getEffendtime().getTime()) {
|
isApply = -1;
|
} else if (recommend.getEffendtime() == null) {//批复时间为空，代表永久
|
isApply = -1;
|
} else {
|
isApply = 0;
|
}
|
}
|
} else {
|
isApply = 0;
|
}
|
}
|
}
|
|
//订阅按钮控制
|
Integer isDingYue = -1;
|
if (res_mainInfo.getResourceclass().equals("SJKB")) {
|
isDingYue = 0; //2018.08.01 自己也可以订阅自己发布的资源，亦可多次订阅同一个资源
|
// Res_Subscriptions sub = new Res_Subscriptions();
|
// sub.setAppuserid(getUserId().toString());
|
// sub.setResourceid(resourceid);
|
// Res_Subscriptions subscriptions = resSubscriptionsService.selectSubscriptionsByUser(sub);
|
// if(subscriptions != null){
|
// isDingYue = 1;
|
// }
|
}
|
model.addAttribute("dingyue", isDingYue);
|
|
// 判断资源类型
|
String leixin = res_mainInfo.getResourceclass();
|
if (leixin == null) leixin = "";
|
// 判断该类型对应那张表，然后查询对应的表的字段
|
switch (leixin) {
|
case "SJWJ":// 数据文件(有用误删)
|
Res_ExtFileSource resExtFileSource = resExtFileSourceService.selectByPrimaryKey(resourceid);
|
if (resExtFileSource != null) {
|
LinkedHashMap<String, String> filetypelist = FieldUtils.getFieldListByKey("FileType");
|
resExtFileSource.setFiletype(filetypelist.get(resExtFileSource.getFiletype()));
|
//判断是否有权限
|
Map<String, Object> map = new HashMap<>();
|
map.put("resourceid", resourceid);
|
map.put("userid", userId);
|
OrgUser user = getUser();
|
map.put("unitid", orgUserService.getDefaultUnit(user.getUserid()).getUnitid());
|
int count = resMainInfoService.checkZiYuanQuanXian(map);
|
//有权限查看
|
if (count > 0) {
|
SelectFileUrl(resourceid, model, request, resExtFileSource);
|
model.addAttribute("XianShiWenJian", 1);//1代表可以显示
|
} else {
|
model.addAttribute("XianShiWenJian", 0);//0代表不可以显示
|
}
|
|
model.addAttribute("resExtFileSource", resExtFileSource);
|
} else {
|
Res_ExtFileSource resExtFileSource1 = new Res_ExtFileSource();
|
model.addAttribute("resExtFileSource", resExtFileSource1);
|
}
|
break;
|
case "SJKB":// 数据库表(有用误删)
|
|
//查询该笔资源的订阅次数,订阅的相关信息
|
Map<String, Object> smap = new HashMap<String, Object>();
|
smap.put("resourceid", resourceid);
|
if (!SecurityUtils.getSubject().isPermitted("org_user_admin") && userId != res_mainInfo.getCreateuserid()) {
|
smap.put("appuserid", getUserId());
|
}
|
List<Res_Subscriptions> subscriptionsList = resSubscriptionsService.selectByResourceIdList(smap);
|
model.addAttribute("dingyuecount", subscriptionsList.size());
|
boolean isDingYueList = false;
|
if (subscriptionsList.size() > 0) {
|
List<DingYue> dingYues = new ArrayList<DingYue>();
|
for (int i = 0; i < subscriptionsList.size(); i++) {
|
DingYue dingYue = new DingYue();
|
OrgUser user = orgUserService.queryObject(Long.parseLong(subscriptionsList.get(i).getAppuserid()));
|
OrgUnit unit = orgUserService.getDefaultUnit(Long.parseLong(subscriptionsList.get(i).getAppuserid()));
|
dingYue.setUsername(user.getChinesename());
|
dingYue.setUnit(unit.getUnitname());
|
Res_ExtDataSource dataSource = resExtDataSourceService.selectByPrimaryKey(subscriptionsList.get(i).getDatasourceid());
|
if (dataSource != null) {
|
dingYue.setDatabasetype(dataSource.getDatabasetype());
|
}
|
dingYue.setSyncmessage(subscriptionsList.get(i).getSyncmessage());
|
dingYue.setHangup(subscriptionsList.get(i).getHangup());
|
dingYue.setTablename(subscriptionsList.get(i).getTablename());
|
dingYue.setLastupdate(sdfmt.format(subscriptionsList.get(i).getLastupdate()));
|
dingYue.setAppdate(sdfmt.format(subscriptionsList.get(i).getAppdate()));
|
dingYue.setId(subscriptionsList.get(i).getAppid());
|
dingYue.setSyncresult(subscriptionsList.get(i).getSyncresult());
|
dingYue.setAuditresult(subscriptionsList.get(i).getAuditresult());
|
if (userId == res_mainInfo.getCreateuserid() && !SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
dingYue.setFlag("1");
|
} else {
|
dingYue.setFlag("0");
|
}
|
dingYues.add(dingYue);
|
}
|
isDingYueList = true;
|
model.addAttribute("dingYues", dingYues);
|
}
|
model.addAttribute("isDingYueList", isDingYueList);
|
|
Res_ExtDataBase res_extDataBase = resExtDataBaseService.selectByMainInfoId(resourceid);
|
if (res_extDataBase != null) {
|
Res_ExtDataSource resExtDataSource = resExtDataSourceService.selectByPrimaryKey(res_extDataBase.getDatasourceid());
|
//开始拼接sql,然后判断是哪个数据库
|
String leirong = null;
|
JSONArray leirongjson = null;
|
JSONArray leirongjsonTwo = null;
|
if (resExtDataSource != null) { //缺少null值处理 alert 2018/12/27
|
if (resExtDataSource.getDatabasetype().equalsIgnoreCase("SQLServer")) {
|
String sql = "SELECT convert(varchar(100),col.name) AS name , " + "convert(varchar(100),ISNULL(ep.[value], '') ) AS ColumnDescription ," + "t.name AS DataType,col.length AS ColLength, " + "convert(varchar(100),ISNULL(COLUMNPROPERTY(col.id, col.name, 'Scale'), 0) ) AS XiaoShuNum," + "CASE WHEN col.isnullable = 1 THEN '否' ELSE '是' END AS Required " + "FROM dbo.syscolumns col LEFT JOIN dbo.systypes t " + "ON col.xtype = t.xusertype inner JOIN dbo.sysobjects obj " + "ON col.id = obj.id AND obj.xtype = 'U' AND obj.status >= 0 LEFT JOIN dbo.syscomments comm " + "ON col.cdefault = comm.id LEFT JOIN sys.extended_properties ep " + "ON col.id = ep.major_id " + "AND col.colid = ep.minor_id " + "AND ep.name = 'MS_Description' LEFT JOIN sys.extended_properties epTwo " + "ON obj.id = epTwo.major_id AND epTwo.minor_id = 0 AND epTwo.name = 'MS_Description' " + "WHERE obj.name = '" + res_extDataBase.getTablename() + "' ORDER BY col.name";
|
leirong = JDBCUtils.SqlServerConnUtils(resExtDataSource.getServeraddress(), resExtDataSource.getDatabasename(), resExtDataSource.getUsername(), resExtDataSource.getPassword(), sql);
|
leirongjson = JSONArray.parseArray(leirong);
|
//获取我设置的别名
|
DataBaseLeftDataSource database = resExtDataBaseService.selectBaseLeftSource(resourceid);
|
JSONObject sqlObj = JSON.parseObject(database.getFieldconfig());
|
//sqlObj 为 null 报错，缺少空值处理。ccr add
|
if (sqlObj != null) {
|
if (leirongjson.getJSONObject(0).get("success").toString().equals("true")) {
|
JSONArray jsarr = JSONArray.parseArray(sqlObj.getString("sql"));
|
leirongjsonTwo = new JSONArray();
|
JSONArray obj = JSONArray.parseArray(leirongjson.getJSONObject(0).get("data").toString());
|
int k = 0;
|
// for (int j = 0; j < obj.size(); j++) {
|
// BiaoJieGou biaoJieGou = JSONUtil.toBean(obj.get(j).toString(), BiaoJieGou.class);
|
// biaoJieGou.setColumnDescription("");
|
// for (int i = 0; i < jsarr.size(); i++) {
|
// ZiDuanPeiZi ziDuanPeiZi = JSONUtil.toBean(jsarr.get(i).toString(), ZiDuanPeiZi.class);
|
// if (ziDuanPeiZi.getZiDuanName().equals(biaoJieGou.getName())) {
|
// biaoJieGou.setColumnDescription(ziDuanPeiZi.getZiDuanBieMing());
|
// }
|
// }
|
// JSONObject Json = (JSONObject) JSONObject.toJSON(biaoJieGou);
|
// if (!biaoJieGou.getColumnDescription().equals("")) {
|
// leirongjsonTwo.set(k, Json);
|
// k++;
|
// }
|
// }
|
//update dsh 2018/12/28
|
for (int i = 0; i < jsarr.size(); i++) {
|
for (int j = 0; j < obj.size(); j++) {
|
BiaoJieGou biaoJieGou = JSONUtil.toBean(obj.get(j).toString(), BiaoJieGou.class);
|
ZiDuanPeiZi ziDuanPeiZi = JSONUtil.toBean(jsarr.get(i).toString(), ZiDuanPeiZi.class);
|
if (ziDuanPeiZi.getZiDuanName().equals(biaoJieGou.getName())) {
|
biaoJieGou.setColumnDescription(ziDuanPeiZi.getZiDuanBieMing());
|
JSONObject Json = (JSONObject) JSONObject.toJSON(biaoJieGou);
|
leirongjsonTwo.set(k, Json);
|
k++;
|
}
|
}
|
}
|
}
|
}
|
}
|
if (resExtDataSource.getDatabasetype().equalsIgnoreCase("Oracle")) {
|
String sql = "select" + " A.column_name as \"name\"," + " B.comments \"ColumnDescription\"," + " A.data_type \"DataType\"," + " A.data_length \"ColLength\"," + " nvl(A.Data_Scale,0) \"XiaoShuNum\"," + " CASE WHEN A.nullable = 'Y' THEN '否' ELSE '是' END AS \"Required\" " + " from" + " user_tab_columns A,user_col_comments B" + " where" + " A.Table_Name = B.Table_Name" + " and A.Column_Name = B.Column_Name" + " and A.Table_Name = '" + res_extDataBase.getTablename() + "'";
|
leirong = JDBCUtils.OracleConnUtils(resExtDataSource.getServeraddress(), resExtDataSource.getDatabasename(), resExtDataSource.getUsername(), resExtDataSource.getPassword(), resExtDataSource.getPort(), sql);
|
leirongjson = JSONArray.parseArray(leirong);
|
//获取我设置的别名
|
DataBaseLeftDataSource database = resExtDataBaseService.selectBaseLeftSource(resourceid);
|
JSONObject sqlObj = JSON.parseObject(database.getFieldconfig());
|
//sqlObj 为 null 报错，缺少空值处理。ccr add
|
if (sqlObj != null) {
|
if (leirongjson.getJSONObject(0).get("success").toString().equals("true")) {
|
JSONArray jsarr = JSONArray.parseArray(sqlObj.getString("sql"));
|
leirongjsonTwo = new JSONArray();
|
JSONArray obj = JSONArray.parseArray(leirongjson.getJSONObject(0).get("data").toString());
|
int k = 0;
|
// for (int j = 0; j < obj.size(); j++) {
|
// BiaoJieGou biaoJieGou = JSONUtil.toBean(obj.get(j).toString(), BiaoJieGou.class);
|
// biaoJieGou.setColumnDescription("");
|
// for (int i = 0; i < jsarr.size(); i++) {
|
// ZiDuanPeiZi ziDuanPeiZi = JSONUtil.toBean(jsarr.get(i).toString(), ZiDuanPeiZi.class);
|
// if (ziDuanPeiZi.getZiDuanName().equals(biaoJieGou.getName())) {
|
// biaoJieGou.setColumnDescription(ziDuanPeiZi.getZiDuanBieMing());
|
// }
|
// }
|
// JSONObject Json = (JSONObject) JSONObject.toJSON(biaoJieGou);
|
// if (!biaoJieGou.getColumnDescription().equals("")) {
|
// leirongjsonTwo.set(k, Json);
|
// k++;
|
// }
|
// }
|
//update dsh 2018/12/28
|
for (int i = 0; i < jsarr.size(); i++) {
|
for (int j = 0; j < obj.size(); j++) {
|
BiaoJieGou biaoJieGou = JSONUtil.toBean(obj.get(j).toString(), BiaoJieGou.class);
|
ZiDuanPeiZi ziDuanPeiZi = JSONUtil.toBean(jsarr.get(i).toString(), ZiDuanPeiZi.class);
|
if (ziDuanPeiZi.getZiDuanName().equals(biaoJieGou.getName())) {
|
biaoJieGou.setColumnDescription(ziDuanPeiZi.getZiDuanBieMing());
|
JSONObject Json = (JSONObject) JSONObject.toJSON(biaoJieGou);
|
leirongjsonTwo.set(k, Json);
|
k++;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
model.addAttribute("leirongjson", leirongjsonTwo);
|
model.addAttribute("resExtDataBase", res_extDataBase);
|
model.addAttribute("resExtDataSource", resExtDataSource);
|
} else {
|
res_extDataBase = new Res_ExtDataBase();
|
JSONArray leirongjsonTwo = null;
|
Res_ExtDataSource res_extDataSource = new Res_ExtDataSource();
|
model.addAttribute("leirongjson", leirongjsonTwo);
|
model.addAttribute("resExtDataBase", res_extDataBase);
|
model.addAttribute("resExtDataSource", res_extDataSource);
|
}
|
break;
|
case "JKFW":// 接口服务(有用误删)
|
Res_ExtInterFaceService res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(resourceid);
|
model.addAttribute("show", 0);
|
//接口说明是否显示 1为显示
|
model.addAttribute("ShuoMing", 0);
|
if (res_extInterFaceService != null) {
|
if (res_extInterFaceService.getServertype().equals("WebService")) {
|
//判断是否有权限
|
Map<String, Object> map = new HashMap<>();
|
map.put("resourceid", resourceid);
|
map.put("userid", userId);
|
OrgUser user = getUser();
|
map.put("unitid", orgUserService.getDefaultUnit(user.getUserid()).getUnitid());
|
int count = resMainInfoService.checkZiYuanQuanXian(map);
|
//>0就是有权限
|
if (count > 0) {
|
res_extInterFaceService.setHelpurl(StringEscapeUtils.unescapeHtml(res_extInterFaceService.getHelpurl()));
|
model.addAttribute("helpurl", res_extInterFaceService.getHelpurl());
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
model.addAttribute("show", 1);
|
model.addAttribute("ShuoMing", 0);
|
|
//查询相关的附件
|
List<Res_Files> res_filesList = resFileService.selectDataListForResourceid(resourceid);
|
model.addAttribute("resFileList", res_filesList);
|
} else {
|
res_extInterFaceService.setHelpurl(StringEscapeUtils.unescapeHtml(res_extInterFaceService.getHelpurl()));
|
model.addAttribute("helpurl", res_extInterFaceService.getHelpurl());
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
model.addAttribute("show", 0);
|
model.addAttribute("ShuoMing", 0);
|
}
|
} else {
|
res_extInterFaceService.setHelpurl(StringEscapeUtils.unescapeHtml(res_extInterFaceService.getHelpurl()));
|
model.addAttribute("helpurl", res_extInterFaceService.getHelpurl());
|
model.addAttribute("show", 0);
|
model.addAttribute("ShuoMing", 1);
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
}
|
} else {
|
res_extInterFaceService = new Res_ExtInterFaceService();
|
model.addAttribute("show", 0);
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
}
|
break;
|
case "YWJC":
|
Res_ExtIntegrate resExtIntegrate = resExtIntegrateService.selectByPrimaryKey(resourceid);
|
integratetype = resExtIntegrate.getIntegratetype() != null ? resExtIntegrate.getIntegratetype() : "";
|
//判断是否有权限
|
Map<String, Object> map = new HashMap<>();
|
map.put("resourceid", resourceid);
|
map.put("userid", getUserId());
|
map.put("unitid", orgUnit.getUnitid());
|
if (resMainInfoService.checkZiYuanQuanXian(map) > 0) {
|
integrateurl = resExtIntegrate.getServerurl() != null ? resExtIntegrate.getServerurl() : "";
|
}
|
break;
|
case "KJ_KJFX": //空间分析
|
Res_ExtSpaceServer res_extSpaceServer = resExtSpaceServerService.selectByPrimaryKey(resourceid);
|
//判断是否有权限
|
if (res_extSpaceServer != null) {
|
if (checkZiYuanQuanXian(resourceid) > 0) {
|
model.addAttribute("helpurl", res_extSpaceServer.getHelpurl());
|
model.addAttribute("show", 1);
|
|
//查询相关的附件
|
List<Res_Files> res_filesList = resFileService.selectDataListForResourceid(resourceid);
|
model.addAttribute("resFileList", res_filesList);
|
} else {
|
model.addAttribute("helpurl", res_extSpaceServer.getHelpurl());
|
model.addAttribute("show", 1);
|
}
|
}
|
break;
|
}
|
model.addAttribute("Pubdate", Pubdate);
|
model.addAttribute("resourceType", leixin);
|
model.addAttribute("apply", isApply);
|
ProblemFeedback(resourceid, model);
|
GetProblemStatus(res_mainInfo, model);
|
}
|
//换地址
|
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("mainInfo", res_mainInfo);
|
model.addAttribute("resMainInfoId", resourceid);
|
model.addAttribute("isMyZy", res_mainInfo.getCreateuserid() != getUserId() ? false : true);//判断是否是自己申请的资源（申请按钮）
|
//编辑按钮
|
boolean isEdit = false;
|
if (res_mainInfo.getCreateuserid() == getUserId() || SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
isEdit = true;
|
}
|
model.addAttribute("isEdit", isEdit);
|
model.addAttribute("integratetype", integratetype);
|
model.addAttribute("integrateurl", integrateurl);
|
model.addAttribute("firstMapUrl", getZTDTByPortalMapUrl(res_mainInfo.getResourceid(), res_mainInfo.getResourceclass()));
|
String imgurl = "";
|
String defClassImg = "/image/classimg/" + res_mainInfo.getResourceclass() + ".gif";
|
if (res_mainInfo.getImgurl() != null && !res_mainInfo.getImgurl().isEmpty()) {
|
if (res_mainInfo.getImgurl().startsWith("Atkas")) {//图集
|
imgurl = "/image/" + res_mainInfo.getImgurl();
|
File file = new File(System.getProperty("user.dir") + "\\src\\main\\resources\\static" + ("/image/" + res_mainInfo.getImgurl()).replace("/", "\\"));
|
if (!file.exists()) { //判断物理路径是否存在，不存在则默认
|
imgurl = defClassImg;
|
}
|
} else {
|
imgurl = "/uploadPath/" + res_mainInfo.getImgurl();
|
File file = new File(sysConfig.getUploadPath() + res_mainInfo.getImgurl());
|
if (!file.exists()) { //判断物理路径是否存在，不存在则默认
|
imgurl = defClassImg;
|
}
|
}
|
} else {
|
imgurl = defClassImg;
|
}
|
model.addAttribute("imgurl", imgurl);
|
|
if (checkZiYuanQuanXian(resourceid) > 0 || SecurityUtils.getSubject().isPermitted("org_user_admin")) {
|
model.addAttribute("resourceChaKan", 1);
|
} else {
|
model.addAttribute("resourceChaKan", 0);
|
}
|
|
boolean del = false;
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
//自定义风格列表
|
List<Res_DiyLayerInfo> res_diyLayerInfos = resDiyLayerInfoService.selectByResourceid(resourceid);
|
for (int i = 0; i < res_diyLayerInfos.size(); i++) {
|
res_diyLayerInfos.get(i).setDiydate(sdf.format(res_diyLayerInfos.get(i).getDiytime()));
|
if (res_diyLayerInfos.get(i).getDiyuserid() == 0) { //定义风格用户ID为0时，管理员和发布该资源的用户可以删除该风格
|
if (SecurityUtils.getSubject().isPermitted("org_user_admin") || getUserId() == res_mainInfo.getCreateuserid()) {
|
del = true;
|
}
|
}
|
if (getUserId() == res_diyLayerInfos.get(i).getDiyuserid().longValue()) { //当前登录用户是定义人则可以删除自己定义的风格
|
del = true;
|
}
|
res_diyLayerInfos.get(i).setDel(del);
|
}
|
model.addAttribute("diyLayerInfos", res_diyLayerInfos);
|
return "ResManage/ResRegister/ZiYuanBaseInfo";
|
}
|
|
/**
|
* 删除自定义风格
|
*/
|
@RequestMapping("diylayer/deleteDiyLayerInfo")
|
@ResponseBody
|
public String deleteDiyLayerInfo(Integer diyid) {
|
resDiyLayerInfoService.deleteDiyLayerInfo(diyid);
|
return "1";
|
}
|
|
private void SelectFileUrl(Integer resourceid, Model model, HttpServletRequest request, Res_ExtFileSource resExtFileSource) {
|
if (resExtFileSource.getSourcetype() != null && resExtFileSource.getSourcetype().equals("文件夹")) {
|
if (resExtFileSource.getServerurl() != null && resExtFileSource.getStoragemode().equals("本地")) {
|
File file = new File(sysConfig.getUploadPath() + resExtFileSource.getServerurl());
|
String ip = "/uploadPath/";
|
String webUrl = ip + resExtFileSource.getServerurl();
|
String httpurl = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + webUrl;
|
List<Res_FileSource_Way> res_fileSource_way = null;
|
if (file.isDirectory()) {
|
System.out.println(resExtFileSource.getServerurl());
|
String[] fileLists = file.list();
|
File[] files = file.listFiles();
|
List<FileSourceList> fileSourceLists = new ArrayList<>();
|
List list = new ArrayList();
|
for (int i = 0; i < fileLists.length; i++) {
|
File file1 = new File(fileLists[i]);
|
File file2 = new File(files[i].getAbsolutePath());
|
String size = FileUtils.byteCountToDisplaySize(file2.length());
|
String path2 = wenjianjiaPath() + file1.getName(); // 文件映射路径
|
FileSourceList sourceList = new FileSourceList();
|
sourceList.setName(file1.getName());
|
sourceList.setPath(webUrl + "/" + file1.getName());
|
sourceList.setSize(size);
|
//查看 展现方式
|
res_fileSource_way = resFileSourceWayService.selectById(resourceid);
|
List<Res_FileSource_Way> ways = new ArrayList<Res_FileSource_Way>();
|
for (int j = 0; j < res_fileSource_way.size(); j++) {
|
Res_FileSource_Way way = res_fileSource_way.get(j);
|
if (!(StringUtils.isEmpty(way.getUrl()) || StringUtils.equals(way.getUrl(), "--"))) {
|
ways.add(0, way);
|
}
|
}
|
sourceList.setList(ways);
|
fileSourceLists.add(sourceList);
|
}
|
if (res_fileSource_way != null) {
|
for (int j = 0; j < res_fileSource_way.size(); j++) {
|
if (!res_fileSource_way.get(j).getUrl().equals("") && !res_fileSource_way.get(j).getRemark().equals("")) {
|
Res_FileSource_Way way = res_fileSource_way.get(j);
|
String PathUrl = way.getRemark();
|
if (!StringUtils.isEmpty(PathUrl)) {
|
PathUrl += URLEncoder.encode(httpurl);
|
way.setRemark(PathUrl);
|
}
|
|
list.add(way);
|
}
|
}
|
}
|
model.addAttribute("res_fileSource_way", list);
|
System.out.println(fileSourceLists);
|
System.out.println(request.getServerName());
|
//model.addAttribute("webUrl",request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+webUrl);
|
model.addAttribute("webUrl", httpurl);
|
model.addAttribute("filelist", fileSourceLists);
|
//model.addAttribute("zhanxian",zhanxian);
|
}
|
}
|
}
|
if (resExtFileSource.getSourcetype() != null && resExtFileSource.getSourcetype().equals("文件")) {
|
if (resExtFileSource.getServerurl() != null && resExtFileSource.getStoragemode().equals("本地")) {
|
File file = new File(sysConfig.getUploadPath() + resExtFileSource.getServerurl());
|
String ip = "/uploadPath/";
|
String webUrl = ip + resExtFileSource.getServerurl();
|
FileSourceList sourceList = new FileSourceList();
|
List<FileSourceList> fileSourceLists = new ArrayList<>();
|
sourceList.setName(file.getName());
|
sourceList.setPath(webUrl);
|
sourceList.setSize(FileUtils.byteCountToDisplaySize(file.length()));
|
List<Res_FileSource_Way> res_fileSource_way = resFileSourceWayService.selectById(resourceid);
|
sourceList.setList(res_fileSource_way);
|
fileSourceLists.add(sourceList);
|
model.addAttribute("webUrlWenJian", request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + webUrl);
|
model.addAttribute("filelist", fileSourceLists);
|
}
|
}
|
}
|
|
private LinkedHashMap<String, String> queryUserOrUnitList(String gettype) {
|
String url = sysConfig.getApiServer() + (gettype == "unit" ? "/api/org/unit/queryAllList" : "/api/org/user/queryAllList");
|
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
|
try {
|
String jsonStr = HttpOperateUtils.httpGet(url.trim());
|
if (jsonStr.length() != 0) {
|
JSONArray list = JSON.parseArray(jsonStr);
|
for (int i = 0; i < list.size(); i++) {
|
Map maps = (Map) JSON.parse(list.get(i).toString());
|
map.put(maps.get("id").toString(), maps.get("name").toString());
|
}
|
}
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return map;
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtBaseMap")//基础底图
|
public String BaseInfoExtBaseMap(Integer resourceid, Model model, HttpServletRequest request) {
|
GetMainInfo(resourceid, model, request);
|
return "ResManage/ResRegister/BaseInfoExtBaseMap";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtBusinessLayer")
|
public String BaseInfoExtBusinessLayer(Integer resourceid, Model model, HttpServletRequest request) {
|
GetMainInfo(resourceid, model, request);
|
return "ResManage/ResRegister/BaseInfoExtBusinessLayer";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtSpaceServer")
|
public String BaseInfoExtSpaceServer(Integer resourceid, Model model, HttpServletRequest request) {
|
if (checkZiYuanQuanXian(resourceid) > 0) {
|
model.addAttribute("isReadUrl", 1);
|
} else {
|
model.addAttribute("isReadUrl", 0);
|
}
|
Res_ExtSpaceServer res_extSpaceServer = resExtSpaceServerService.selectByPrimaryKey(resourceid);
|
if (res_extSpaceServer != null) {
|
model.addAttribute("ResExtSpaceServer", res_extSpaceServer);
|
String UrlAndToken = getUrlAndToken(resourceid, res_extSpaceServer.getServerurl(), request);
|
model.addAttribute("urlAndToken", UrlAndToken);
|
} else {
|
res_extSpaceServer = new Res_ExtSpaceServer();
|
model.addAttribute("ResExtSpaceServer", res_extSpaceServer);
|
}
|
GetMainInfo(resourceid, model, request);
|
return "ResManage/ResRegister/BaseInfoExtSpaceServer";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtThemeMap")
|
public String BaseInfoExtThemeMap(Integer resourceid, Model model, HttpServletRequest request) {
|
GetMainInfo(resourceid, model, request);
|
return "ResManage/ResRegister/BaseInfoExtThemeMap";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtIntegrate")
|
public String BaseInfoExtIntegrate(Integer resourceid, Model model, HttpServletRequest request) {
|
if (checkZiYuanQuanXian(resourceid) > 0) {
|
model.addAttribute("isReadUrl", 1);
|
} else {
|
model.addAttribute("isReadUrl", 0);
|
}
|
Res_ExtIntegrate res_extIntegrate = resExtIntegrateService.selectByPrimaryKey(resourceid);
|
if (res_extIntegrate != null) {
|
model.addAttribute("res_extIntegrate", res_extIntegrate);
|
String UrlAndToken = getUrlAndToken(resourceid, res_extIntegrate.getServerurl(), request);
|
model.addAttribute("urlAndToken", UrlAndToken);
|
} else {
|
res_extIntegrate = new Res_ExtIntegrate();
|
model.addAttribute("res_extIntegrate", res_extIntegrate);
|
}
|
GetMainInfo(resourceid, model, request);
|
|
return "ResManage/ResRegister/BaseInfoExtIntegrate";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtFileSource")
|
public String BaseInfoExtFileSource(Integer resourceid, Model model, HttpServletRequest request) {
|
Res_ExtFileSource res_extFileSource = resExtFileSourceService.selectByPrimaryKey(resourceid);
|
if (res_extFileSource != null) {
|
|
model.addAttribute("resExtFileSource", res_extFileSource);
|
} else {
|
res_extFileSource = new Res_ExtFileSource();
|
model.addAttribute("resExtFileSource", res_extFileSource);
|
}
|
GetMainInfo(resourceid, model, request);
|
return "ResManage/ResRegister/BaseInfoExtFileSource";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExtDataBase")
|
public String BaseInfoExtDataBase(Integer resourceid, Model model, HttpServletRequest request) {
|
GetMainInfo(resourceid, model, request);
|
DataBaseLeftDataSource database = resExtDataBaseService.selectBaseLeftSource(resourceid);
|
String databasetype = "";
|
if (database != null) {
|
databasetype = database.getDatabasetype();
|
}
|
model.addAttribute("databasetype", databasetype);
|
return "ResManage/ResRegister/BaseInfoExtDataBase";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoEextInterFace")
|
public String BaseInfoEextInterFace(Integer resourceid, Model model, HttpServletRequest request) {
|
GetMainInfo(resourceid, model, request);
|
if (checkZiYuanQuanXian(resourceid) > 0) {
|
model.addAttribute("isReadUrl", 1);
|
} else {
|
model.addAttribute("isReadUrl", 0);
|
}
|
Res_ExtInterFaceService res_extInterFaceService = resExtInterFaceService.selectByPrimaryKey(resourceid);
|
if (res_extInterFaceService != null) {
|
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
String UrlAndToken = getUrlAndToken(resourceid, res_extInterFaceService.getServerurl(), request);
|
model.addAttribute("urlAndToken", UrlAndToken);
|
} else {
|
res_extInterFaceService = new Res_ExtInterFaceService();
|
model.addAttribute("resExtInterFaceService", res_extInterFaceService);
|
}
|
return "ResManage/ResRegister/BaseInfoEextInterFace";
|
}
|
|
@RequestMapping("ZiYuan/BaseInfoExt3D")
|
public String BaseInfoExt3D(Integer resourceid, Model model, HttpServletRequest request) {
|
if (checkZiYuanQuanXian(resourceid) > 0) {
|
model.addAttribute("isReadUrl", 1);
|
} else {
|
model.addAttribute("isReadUrl", 0);
|
}
|
Res_Ext3D res_ext3D = resExt3DService.selectByPrimaryKey(resourceid);
|
if (res_ext3D != null) {
|
model.addAttribute("resExt3D", res_ext3D);
|
String UrlAndToken = getUrlAndToken(resourceid, res_ext3D.getServerurl(), request);
|
model.addAttribute("urlAndToken", UrlAndToken);
|
} else {
|
res_ext3D = new Res_Ext3D();
|
model.addAttribute("resExt3D", res_ext3D);
|
}
|
GetMainInfo(resourceid, model, request);
|
return "ResManage/ResRegister/BaseInfoExt3D";
|
}
|
|
private Model GetMainInfo(Integer resourceid, Model model, HttpServletRequest request) {
|
String UrlAndToken = "";//复制地址
|
Res_MainInfo res_mainInfo = new Res_MainInfo();
|
OrgUnit orgUnit = getUnit();//获取用户单位信息
|
// 修改
|
res_mainInfo = resMainInfoService.selectByPrimaryKey(resourceid);
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
|
String Pubdate = sdf.format(res_mainInfo.getPubdate());
|
String Productiontime = res_mainInfo.getProductiontime() != null ? sdf.format(res_mainInfo.getProductiontime()) : "";
|
// 判断所属目录
|
strMuLu = "";
|
res_mainInfo.setCatlogcode(GetBianMu(res_mainInfo.getCatlogid()));
|
// 判断发布单位
|
String unitname = orgUnitService.getUnitById((long) res_mainInfo.getPubunitid()).getUnitname();
|
model.addAttribute("unitname", unitname);
|
// 判断数据覆盖范围
|
// modified by qufangxu 信创环境下，若 res_mainInfo.getAdministrativeid() = ' ',会返回单点登录页面，具体原因未知。 解决办法：提前去除空格、制表符
|
String administrativeid = (String) res_mainInfo.getAdministrativeid();
|
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 = "";
|
try {
|
jsonStr = HttpOperateUtils.httpGet(getRegionInfourl.trim());
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
if (jsonStr != null && !jsonStr.isEmpty()) {
|
JSONObject item = JSONObject.parseObject(jsonStr);
|
String regionname = item.getString("regionname");
|
res_mainInfo.setAdministrativeid(regionname);
|
}
|
}
|
List list = new ArrayList();
|
if (res_mainInfo.getKeywords() != "") {
|
String keywords = res_mainInfo.getKeywords();
|
if (keywords != null && !keywords.equals("")) {
|
String key[] = keywords.split(",");
|
for (int i = 0; i < key.length; i++) {
|
String s = key[i];
|
list.add(s);
|
}
|
}
|
}
|
model.addAttribute("Pubdate", Pubdate);
|
model.addAttribute("Productiontime", Productiontime);
|
//换地址
|
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("list", list);
|
model.addAttribute("createusername", res_mainInfo.getCreateuserid() != null ? orgUserService.getChinesename(res_mainInfo.getCreateuserid()) : "");//发布人
|
//资源类型
|
switch (res_mainInfo.getResourceclass()) {
|
case "KJ_JCDT"://基础底图
|
Res_ExtBaseMap resExtBaseMap = resExtBaseMapService.selectByPrimaryKey(resourceid);
|
if (resExtBaseMap == null) {
|
resExtBaseMap = new Res_ExtBaseMap();
|
}
|
model.addAttribute("resExtBaseMap", resExtBaseMap);
|
break;
|
case "KJ_ZTDT":// 专题地图
|
Res_ExtThemeMap resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resourceid);
|
if (resExtThemeMap == null) {
|
resExtThemeMap = new Res_ExtThemeMap();
|
}
|
model.addAttribute("resExtThemeMap", resExtThemeMap);
|
break;
|
case "KJ_YWTC":// 业务图层
|
Res_ExtBusinessLayer resExtBusinessLayer = resExtBusinessLayerService.selectByPrimaryKey(resourceid);
|
if (resExtBusinessLayer == null) {
|
resExtBusinessLayer = new Res_ExtBusinessLayer();
|
}
|
model.addAttribute("resExtBusinessLayer", resExtBusinessLayer);
|
break;
|
}
|
//服务地址链接
|
List<Res_ExtMapUrl> resExtMapUrls = resExtMapUrlService.selectByCondition(resourceid);
|
String serviceUrl = "";//服务地址
|
String layername = "";
|
List<String> urltokens = new ArrayList<>();
|
Integer isReadUrl = 0;//是否有权限查看服务地址
|
if (resExtMapUrls.size() > 0) {
|
//判断是否有权限
|
Map<String, Object> map = new HashMap<>();
|
Long userId = getUserId(); //获取用户ID
|
map.put("resourceid", resourceid);
|
map.put("userid", userId);
|
OrgUser user = getUser();
|
map.put("unitid", orgUserService.getDefaultUnit(user.getUserid()).getUnitid());
|
int count = resMainInfoService.checkZiYuanQuanXian(map);
|
if (count > 0) {
|
isReadUrl = 1;
|
serviceUrl = (resExtMapUrls != null && resExtMapUrls.size() > 0) ? resExtMapUrls.get(0).getServerurl() : "";//暂时先取第一个地址
|
layername = (resExtMapUrls != null && resExtMapUrls.size() > 0) ? resExtMapUrls.get(0).getLayername() : "";
|
}
|
UrlAndToken = getUrlAndToken(resourceid, serviceUrl, request);
|
// resExtMapUrls.remove(0);
|
//TODO 获取服务代理地址
|
for (Res_ExtMapUrl res : resExtMapUrls) {
|
String urltoken = getUrlAndToken(resourceid, res.getServerurl(), request);
|
res.setUrlandtoken(urltoken);
|
}
|
model.addAttribute("urlAndToken", UrlAndToken);
|
model.addAttribute("isReadUrl", isReadUrl);
|
}
|
|
model.addAttribute("serviceUrl", serviceUrl);
|
model.addAttribute("firstlayername", layername);
|
// resExtMapUrls.remove(0);
|
model.addAttribute("serviceUrls", resExtMapUrls);
|
|
model.addAttribute("mainInfo", res_mainInfo);
|
GetProblemStatus(res_mainInfo, model);
|
|
ProblemFeedback(resourceid, model);
|
logger.error(model.toString());
|
return model;
|
}
|
|
private int checkZiYuanQuanXian(Integer resourceid) {
|
Map<String, Object> map = new HashMap<>();
|
Long userId = getUserId(); //获取用户ID
|
map.put("resourceid", resourceid);
|
map.put("userid", userId);
|
OrgUser user = getUser();
|
map.put("unitid", orgUserService.getDefaultUnit(user.getUserid()).getUnitid());
|
return resMainInfoService.checkZiYuanQuanXian(map);
|
}
|
|
/**
|
* 复制
|
*/
|
@ResponseBody
|
@RequestMapping("/ZiYuan/copyMainInfoAndKZ")
|
public int copyMainInfoAndKZ(int resourceid, String copyname, String copyurl, String type) {
|
int resultId = 0;
|
Timestamp nowtime = new Timestamp(new Date().getTime());// 获取当前时间
|
Res_MainInfo mainInfo = resMainInfoService.selectByPrimaryKey(resourceid);
|
if (mainInfo != null) {
|
mainInfo.setResourceid(null);
|
mainInfo.setAuditstatus(0);
|
mainInfo.setCreatedate(nowtime);
|
mainInfo.setLasteditdate(nowtime);
|
mainInfo.setTitle(copyname);
|
resultId = resMainInfoService.insertSelective(mainInfo);
|
if (resultId == 1) {
|
resultId = resMainInfoService.queryResMainInfoIdentCurrent();
|
int isExitsUrl = 0;
|
switch (type) {
|
case "ExtBaseMap"://基础底图
|
Res_ExtBaseMap baseMapInfo = resExtBaseMapService.selectByPrimaryKey(resourceid);
|
if (baseMapInfo != null) {
|
baseMapInfo.setResourceid(resultId);
|
resExtBaseMapService.insertSelective(baseMapInfo);
|
isExitsUrl = 1;
|
}
|
break;
|
case "ExtSpaceServer"://空间分析不用复制扩展信息
|
break;
|
case "ExtBusinessLayer"://业务图层
|
Res_ExtBusinessLayer businessInfo = resExtBusinessLayerService.selectByPrimaryKey(resourceid);
|
if (businessInfo != null) {
|
businessInfo.setResourceid(resultId);
|
resExtBusinessLayerService.insertSelective(businessInfo);
|
isExitsUrl = 1;
|
}
|
break;
|
case "ExtThemeMap"://专题地图
|
Res_ExtThemeMap themeInfo = resExtThemeMapService.selectByPrimaryKey(resourceid);
|
if (themeInfo != null) {
|
themeInfo.setResourceid(resultId);
|
resExtThemeMapService.insertSelective(themeInfo);
|
isExitsUrl = 1;
|
}
|
break;
|
case "ExtFileSource"://数据文件不用复制扩展信息
|
break;
|
case "ExtIntegrate"://业务集成
|
Res_ExtIntegrate integerInfo = resExtIntegrateService.selectByPrimaryKey(resourceid);
|
if (integerInfo != null) {
|
integerInfo.setResourceid(resultId);
|
integerInfo.setServerurl(copyurl);
|
resExtIntegrateService.insertSelective(integerInfo);
|
}
|
break;
|
case "ExtInterFaceService"://接口服务
|
Res_ExtInterFaceService faceInfo = resExtInterFaceService.selectByPrimaryKey(resourceid);
|
if (faceInfo != null) {
|
faceInfo.setResourceid(resultId);
|
faceInfo.setServerurl(copyurl);
|
resExtInterFaceService.insertSelective(faceInfo);
|
}
|
break;
|
case "Ext3D"://3D模型
|
Res_Ext3D threeDInfo = resExt3DService.selectByPrimaryKey(resourceid);
|
if (threeDInfo != null) {
|
threeDInfo.setResourceid(resultId);
|
threeDInfo.setServerurl(copyurl);
|
resExt3DService.insertSelective(threeDInfo);
|
}
|
break;
|
case "ExtDataBase"://数据库表不用复制扩展信息
|
break;
|
}
|
//复制服务地址
|
if (isExitsUrl == 1) {
|
List<Res_ExtMapUrl> extMapUrlList = resExtMapUrlService.selectByCondition(resourceid);
|
if (extMapUrlList != null && extMapUrlList.size() > 0) {
|
for (int i = 0; i < extMapUrlList.size(); i++) {
|
Res_ExtMapUrl urlmodel = extMapUrlList.get(i);
|
urlmodel.setUrlid(null);
|
urlmodel.setResourceid(resultId);
|
if (i == 0) {//填写的服务地址替换第一个
|
urlmodel.setServerurl(copyurl);
|
}
|
resExtMapUrlService.insertSelective(urlmodel);
|
}
|
}
|
}
|
}
|
}
|
return resultId;
|
}
|
|
//类型为专题地图portal专题类型获取首笔协议服务路径
|
private String getZTDTByPortalMapUrl(Integer resourceid, String resourceclass) {
|
String firstMapUrl = "";
|
if (resourceid != null && resourceclass != null) {
|
if (resourceclass.equals("KJ_ZTDT")) {
|
Res_ExtThemeMap resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resourceid);
|
if (resExtThemeMap != null && resExtThemeMap.getType() != null && resExtThemeMap.getType().equals("Portal专题")) {
|
List<Res_ExtMapUrl> urlList = resExtMapUrlService.selectByCondition(resourceid);
|
if (urlList != null && urlList.size() > 0 && urlList.get(0).getServerurl() != null)
|
firstMapUrl = urlList.get(0).getServerurl();
|
}
|
}
|
}
|
return firstMapUrl;
|
}
|
|
/**
|
* 自动补全输入首字母查询
|
*
|
* @param keyWord
|
* @return
|
*/
|
@ResponseBody
|
@GetMapping("/findPinyinByKeyWord")
|
public String[] findpinyinByKeyWord(@RequestParam(name = "keyWord") String keyWord) {
|
List<String> titles = resMainInfoService.pingyin(URLDecoder.decode(keyWord.toLowerCase()));
|
|
if (org.springframework.util.StringUtils.isEmpty(titles)) {
|
return null;
|
}
|
|
int size = titles.size();
|
|
String[] arr = titles.toArray(new String[size]);
|
|
return arr;
|
}
|
|
/** 文件上传 */
|
/**
|
* @Description:
|
* @author dsh
|
* 文件资源类型
|
* @date 2018/6/28
|
*/
|
@ResponseBody
|
@RequestMapping("/ZiYuan/uploadfile")
|
public String uploadfile(@RequestParam("myFile") MultipartFile[] file, String resourceid) {
|
String res = "";
|
for (int i = 0; i < file.length; i++) {
|
if (file[i].isEmpty()) {
|
return "No File";
|
}
|
// 判断文件夹是否存在（resource/diydes/resourceid/文件）
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
|
String timePath = sdf.format(new Date().getTime());
|
timePath = timePath.replace("-", "");
|
String thisPath = sysConfig.getUploadPath() + "diydes\\" + timePath + "\\" + resourceid;
|
String paths[] = {""};
|
try {
|
String tempPath = new File(thisPath).getCanonicalPath();
|
// paths = tempPath.split("\\\\");
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
//创建文件夹
|
String dir = paths[0];
|
for (int j = 0; j < paths.length - 1; j++) {
|
try {
|
dir = dir + "/" + paths[j + 1];
|
File dirFile = new File(dir);
|
if (!dirFile.exists()) {
|
dirFile.mkdirs();
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
//判断文件是否存在
|
String filename = file[0].getOriginalFilename().indexOf("\\") != -1
|
? file[0].getOriginalFilename().substring(file[0].getOriginalFilename().lastIndexOf("\\") + 1, file[0].getOriginalFilename().length())
|
: file[0].getOriginalFilename();
|
File thisfile = new File(thisPath + "\\" + filename);
|
File thisdir = new File(thisPath);
|
String webpath = "";
|
if (!thisfile.exists()) {
|
try {
|
//删除已有的文件
|
File[] childrens = thisdir.listFiles();
|
if (childrens != null) {
|
for (int j = 0; j < childrens.length; j++) {
|
File temp = childrens[i];
|
temp.delete();
|
}
|
}
|
//文件网络地址
|
webpath = "diydes/" + timePath + "/" + resourceid + "/" + filename; // 类型为文件指向文件
|
FileUtils.copyInputStreamToFile(file[i].getInputStream(), thisfile);
|
res = "{'result':'1','name':'" + file[i].getOriginalFilename() + "','Path':'" + sysConfig.getUploadRootPath() + webpath + "'}";
|
} catch (Exception e) {
|
e.printStackTrace();
|
res = "{'result':'0'}";
|
}
|
} else {
|
res = "{'result':'3'}";
|
}
|
}
|
return res;
|
}
|
|
/**
|
* 获取复制地址
|
*
|
* @param resourceid
|
* @param url
|
* @param request
|
* @return
|
*/
|
@ResponseBody
|
@RequestMapping("mainInfo/getUrlAndToken")
|
public String getUrlAndToken(Integer resourceid, String url, HttpServletRequest request) {
|
Res_MainInfo resMainInfo = resMainInfoService.selectByPrimaryKey(resourceid);
|
if (resMainInfo.getEspproxy() == 1) {
|
Res_ExtThemeMap resExtThemeMap = resExtThemeMapService.selectByPrimaryKey(resourceid);
|
String subzyids = "";
|
if (resExtThemeMap != null) {
|
subzyids = resExtThemeMap.getSublayerset();
|
}
|
boolean isPubzy = false;
|
if (resMainInfo != null && resMainInfo.getSharprotocol().equals("完全公开")) {
|
isPubzy = true;
|
}
|
String serviceUrl = url;
|
//获取token拼接url
|
//String path= TerraToken.getToken(serviceUrl, getUserId().intValue(), request.getRemoteAddr(), resourceid, resMainInfo.getEspproxy(), sysConfig, subzyids, isPubzy, resMainInfo.getToken(), false);
|
String remoteAddr = request.getRemoteAddr();
|
String path = EsbToken.getEsbUrl(serviceUrl, 163, request.getRemoteAddr(), resourceid, resMainInfo.getEspproxy(), sysConfig, subzyids, isPubzy, resMainInfo.getToken(), false);
|
return path;
|
} else {
|
if (resMainInfo.getToken() != null && !resMainInfo.getToken().isEmpty()) {
|
if (url.indexOf("?") > -1) {
|
return url + "&token=" + resMainInfo.getToken();
|
} else {
|
return url + "?token=" + resMainInfo.getToken();
|
}
|
} else {
|
return url;
|
}
|
}
|
}
|
|
//检查服务地址是否异常，异常则插入记录
|
@ResponseBody
|
@RequestMapping("ZiYuan/CheckServerurl")
|
public String CheckServerurl(Integer resourceid, String urlStr) {
|
Integer status = -1;//不成功
|
if (urlStr == null || urlStr.trim().equals("")) {
|
return "";
|
}
|
Res_MainInfo res_mainInfo = resMainInfoService.selectByPrimaryKey(resourceid);
|
//检查：pingIP或域名是否成功
|
//1.先查最新一笔记录是否为异常，异常则不检查
|
//2.最新一笔记录为网络异常，再次检查，如果正常则插入正常消息
|
//3.没有异常消息，检查
|
List<Res_ProblemFeedback> problemFeedbacks = resProblemFeedbackService.selectByResourceid(resourceid);
|
Integer lastServerStatus = (problemFeedbacks != null && problemFeedbacks.size() > 0 && problemFeedbacks.get(0).getServerstatus() != null) ? problemFeedbacks.get(0).getServerstatus() : -1;
|
String lastStatus = (problemFeedbacks != null && problemFeedbacks.size() > 0 && problemFeedbacks.get(0).getFeedbackstatus() != null) ? problemFeedbacks.get(0).getFeedbackstatus() : "";
|
String lastType = (problemFeedbacks != null && problemFeedbacks.size() > 0 && problemFeedbacks.get(0).getFeedbacktype() != null) ? problemFeedbacks.get(0).getFeedbacktype() : "";
|
boolean res = false;
|
if (problemFeedbacks == null || problemFeedbacks.size() == 0 || lastServerStatus.equals(1) || (lastStatus.equals("网络问题") && lastServerStatus.equals(0) && lastType.equals("系统"))) {
|
try {
|
Runtime runtime = Runtime.getRuntime();
|
Process process = null;
|
String line = null;
|
InputStream is = null;
|
InputStreamReader isr = null;
|
BufferedReader br = null;
|
URL url = new URL(urlStr);
|
String ip = url.getHost();
|
res = false;
|
process = runtime.exec("ping " + ip);
|
is = process.getInputStream();
|
isr = new InputStreamReader(is);
|
br = new BufferedReader(isr);
|
while ((line = br.readLine()) != null) {
|
if (line.contains("TTL")) {
|
res = true;
|
break;
|
}
|
}
|
is.close();
|
isr.close();
|
br.close();
|
br.close();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
/** add ykm 2019-04-17 判断服务地址
|
* 如果IP不通，则判断服务地址是否通
|
* 如果服务地址正常，则认为网络也正常
|
* */
|
if (!res) {
|
boolean isTrue = isConnect(urlStr);
|
if (isTrue) {
|
res = true;
|
}
|
}
|
//插入正常信息
|
if (res && (lastStatus.equals("网络问题") && lastServerStatus.equals(0) && lastType.equals("系统"))) {
|
InsertProblem(resourceid, 1, 0);
|
if (res_mainInfo != null) res_mainInfo.setResourcestatus(0);
|
status = 0;
|
}
|
//插入异常
|
if (!res && (lastServerStatus.equals(1) || lastServerStatus.equals(-1))) {
|
InsertProblem(resourceid, 0, 1);
|
if (res_mainInfo != null) res_mainInfo.setResourcestatus(1);
|
status = 1;
|
}
|
}
|
return "{result:" + status + "}";
|
}
|
|
//插入问题消息
|
private void InsertProblem(Integer resourceid, Integer status, Integer resourcestatus) {
|
Res_ProblemFeedback model = new Res_ProblemFeedback();
|
java.sql.Timestamp time = new java.sql.Timestamp(new Date().getTime());
|
model.setResourceid(resourceid);
|
model.setCreateuserid(getUserId().intValue());
|
model.setAddtime(time);
|
model.setFeedbacktype("系统");
|
model.setServerstatus(status);
|
model.setFeedbackstatus("网络问题");
|
model.setRemark("无法连接服务器");
|
resProblemFeedbackService.insertSelective(model);
|
Res_MainInfo mainInfo = new Res_MainInfo();
|
mainInfo.setResourceid(resourceid);
|
mainInfo.setResourcestatus(resourcestatus);
|
resMainInfoService.updateByPrimaryKeySelective(mainInfo);
|
}
|
|
//获取问题类型
|
private Model GetProblemStatus(Res_MainInfo mainInfo, Model model) {
|
String status = "";
|
if (mainInfo != null) {
|
List<Res_ProblemFeedback> problemFeedbacks = resProblemFeedbackService.selectByResourceid(mainInfo.getResourceid());
|
if (problemFeedbacks != null && problemFeedbacks.size() > 0 && problemFeedbacks.get(0).getServerstatus().equals(0)) {
|
status = problemFeedbacks.get(0).getFeedbackstatus();
|
}
|
}
|
model.addAttribute("problemStatus", status.equals("") ? "" : status.substring(0, 2));
|
return model;
|
}
|
|
//根据类型获取资源条数
|
private int GetZYCountByClass(Integer treeType, String search, String catalogname) {
|
catalogname = URLDecoder.decode(catalogname);
|
UserDef_ZYML_ChaXunQu userDefZymlChaXunQu = new UserDef_ZYML_ChaXunQu();
|
if (!search.equals("") && treeType == 4) userDefZymlChaXunQu.setResourceclass(search);
|
if (!search.equals("") && treeType == 0) {
|
userDefZymlChaXunQu.setCatlogcode(search);
|
userDefZymlChaXunQu.setCatalogName(catalogname);
|
}
|
int count = ziYuanMuLuService.selectZiYuanMuLuList(userDefZymlChaXunQu).size();
|
return count;
|
}
|
|
private int GetZYCountByClassNew(Integer treeType, String catalogcode, String catalogname, String resourceclass,String spcStatus) {
|
UserDef_ZYML_ChaXunQu userDefZymlChaXunQu = new UserDef_ZYML_ChaXunQu();
|
|
catalogname = URLDecoder.decode(catalogname);
|
// 按资源目录划分
|
if(treeType == 0){
|
userDefZymlChaXunQu.setCatlogcode(catalogcode);
|
userDefZymlChaXunQu.setCatalogName(catalogname);
|
userDefZymlChaXunQu.setResourceclass(resourceclass);
|
}
|
if(treeType == 4){
|
userDefZymlChaXunQu.setResourceclass(resourceclass);
|
}
|
userDefZymlChaXunQu.setSpcStatus(spcStatus);
|
int count = ziYuanMuLuService.selectZiYuanMuLuList(userDefZymlChaXunQu).size();
|
return count;
|
}
|
|
private Model ProblemFeedback(Integer resourceid, Model model) {
|
//获取资源最后一笔问题反馈的状态
|
Res_ProblemFeedback problemFeedback = resProblemFeedbackService.selectTopByResourceid(resourceid);
|
String result = "";
|
if (problemFeedback != null) {
|
if (problemFeedback.getServerstatus() == 1) {
|
result = "正常";
|
} else {
|
result = "异常";
|
}
|
}
|
model.addAttribute("ProblemFeedback", result);
|
return model;
|
}
|
|
//根据输入的用户名获取用户ID
|
private String getUserIds(String name) {
|
String url = sysConfig.getApiServer() + "/api/org/user/findUserByWord/" + URLEncoder.encode(URLEncoder.encode(name));
|
|
String username = null;
|
try {
|
username = HttpOperateUtils.httpGet(url);
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
JSONArray object = JSONArray.parseArray(username);
|
StringBuilder t = new StringBuilder();
|
if (!name.equals("%")) {
|
for (int i = 0; i < object.size(); i++) {
|
if (i != 0) t.append(",");
|
t.append(object.getJSONObject(i).getString("id"));
|
}
|
}
|
if (t.toString().equals("") && !name.equals("%")) {
|
t.append("-1");
|
}
|
return t.toString();
|
}
|
|
public boolean isConnect(String urlStr) {
|
boolean status = false;
|
int counts = 0;
|
if (urlStr == null || urlStr.length() <= 0) {
|
return false;
|
}
|
while (counts < 2) {
|
try {
|
URL url = new URL(urlStr);
|
HttpURLConnection con = (HttpURLConnection) url.openConnection();
|
int state = con.getResponseCode();
|
if (state == 200) {
|
status = true;
|
}
|
break;
|
} catch (Exception ex) {
|
status = false;
|
counts++;
|
System.out.println("URL不可用，连接第 " + counts + " 次");
|
continue;
|
}
|
}
|
return status;
|
}
|
|
|
/**
|
* 资源目录左侧面板目录结构(由资源类型分类)
|
* @return String
|
*/
|
@ResponseBody
|
@RequestMapping("getMuLuTreeDataByResourceType")
|
public String getMuLuTreeDataByResourceType() {
|
// 获取资源类型列表
|
LinkedHashMap<String, String> resourceTypes = FieldUtils.getFieldListByKey("ResourceType");
|
Map<String, Object> map = new HashMap<>();
|
map.put("parentid", 0);
|
//获取资源目录节点数据
|
List<Res_Catalog> resCatalogList = resCatalogService.getMuLuTreeDataByResourceType(map);
|
ArrayList<TreeDataByResourceType> arrayList = new ArrayList<>();
|
//获取资源目录父节点id集合
|
List<Integer> countList=resCatalogService.selectResCatalogExistsSon();
|
int id=1;
|
for (Map.Entry<String, String> entry : resourceTypes.entrySet()) {
|
String key = entry.getKey();
|
//查询对应resourceClass对应的资源总数
|
int count = resMainInfoService.getCountByResourceClass(key);
|
if(count==0) continue;
|
TreeDataByResourceType resourceType = new TreeDataByResourceType();
|
resourceType.setName(entry.getValue()+"("+count+")");
|
resourceType.setPid(String.valueOf(0));
|
resourceType.setId(String.valueOf(id));
|
for (Res_Catalog resCatalog : resCatalogList) {
|
if (!resCatalog.getResourceClass().equals(key)) continue;
|
map.put("catlogcode",resCatalog.getCatlogcode());
|
map.put("key",key);
|
Integer countId = resMainInfoService.getCountByresCatalogId(map);
|
if(null==countId) continue;
|
resCatalog.setParent(false);
|
if (countList.contains(resCatalog.getCatlogid())) resCatalog.setParent(true);
|
resCatalog.setIconOpen("/image/classicons/folderOpen.png");
|
resCatalog.setIconClose("/image/classicons/folder.png");
|
resCatalog.setIcon("/image/classicons/defaulticon.png");
|
resCatalog.setName(resCatalog.getTitle()+"("+countId+")");
|
resCatalog.setPid(Integer.valueOf(resourceType.getId()));
|
resourceType.getChildren().add(resCatalog);
|
|
}
|
arrayList.add(resourceType);
|
id++;
|
}
|
return JSONObject.toJSONString(arrayList);
|
}
|
|
|
/**
|
* 资源目录左侧面板目录结构(与专题数据混合)
|
* @return String
|
*/
|
@ResponseBody
|
@RequestMapping("getMuLuTreeDataForSpcData")
|
public String getMuLuTreeDataForSpcData(Integer id, String XZQHID, String NF, String catalogName, String ResourceClass,String spcStatus) {
|
catalogName=null==catalogName?"":catalogName;
|
ResourceClass=null==ResourceClass?"":ResourceClass;
|
spcStatus=null==spcStatus?"1":spcStatus;
|
return getMuLuTreeData( id, 0, XZQHID, NF, 0, catalogName, ResourceClass, spcStatus);
|
}
|
|
|
|
|
@ResponseBody
|
@GetMapping(path = "/genTokenForApply")
|
public String genTokenForApply(String resourceid) throws Exception {
|
Long userid = getUser().getUserid(); // TODO:管理员判断
|
Map<String,Object> param= new HashMap<>();
|
String proxyUrl = sysConfig.getProxyUrl();
|
JSONObject json = new JSONObject();
|
param.put("resourceid",resourceid);
|
param.put("userid",userid);
|
param.put("applyuserid",userid);
|
param.put("appId",0);
|
param.put("isPubzy",1);
|
param.put("identyinfo",orgUserService.getChinesename(userid));
|
Map<String,String> resultMap=resMainInfoService.queryForApply(param);
|
//资源公开则直接返回
|
String sharprotocol = resultMap.get("SHARPROTOCOL");
|
String url = resultMap.get("SERVERURL");
|
if(StringUtils.equals(sharprotocol,"完全公开")){
|
param.put("isNever","1"); //系统申请永久
|
if(url!=null&&url.contains(":8066")){
|
json.put("code", 200);
|
json.put("data", url);
|
json.put("message", "获取成功");
|
return json.toJSONString();
|
}
|
return HttpUtils.get(proxyUrl +"/genTokenForApply", param);
|
}else {
|
Res_ApplyRecommend applyRecommend = resApplyRecommendService.getApplyDate(param);
|
if (null != applyRecommend) {
|
//获取申请有效期的天数 -针对申请的资源
|
Integer sysid = applyRecommend.getSysid();
|
param.put("appId",sysid ==null?0:sysid);
|
String appDays = applyRecommend.getAppDays();
|
Integer apptype = applyRecommend.getApptype();
|
if (appDays == null) {
|
switch (apptype) {
|
case 0:
|
appDays = "30"; // 个人申请30天
|
break;
|
case 1:
|
appDays = "360"; //单位申请360
|
break;
|
case 3:
|
param.put("isNever", "1"); //系统申请永久
|
appDays = "0";
|
break;
|
}
|
}
|
param.put("expiration", Integer.parseInt(appDays) * 24 * 3600);
|
return HttpUtils.get(proxyUrl + "/genTokenForApply", param);
|
}else {
|
param.put("isNever", "1"); // 其它情况也是永久
|
return HttpUtils.get(proxyUrl + "/genTokenForApply", param);
|
}
|
}
|
|
}
|
|
public static void main(String[] args) throws Exception {
|
String test= " ";
|
String sda = test.trim();
|
String url="http://71.3.110.202:6080/arcgis/rest/services/HYHD/HYQS/MapServer/0";
|
String[] split = url.split("/MapServer");
|
System.out.println("split = " + split);
|
}
|
}
|
