发布tif图层

1、controller
geoserver.jar
package com.jeeplus.common.utils;

import java.io.File;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jeeplus.common.config.Global;

import ev.springboot.gsserver.RasterPublish;

/**

  • @author zb

  • 图层发布
    */
    public class RasterPublishUtils {

    private static Logger log = LoggerFactory.getLogger(RasterPublishUtils.class);

    /**

    • 获取geoserver连接
    • @return
      */
      public static RasterPublish createGeoserverConnect(){
      log.info(“获取geoserver连接开始!”);
      RasterPublish rasterPublish = null;
      try {
      String url = Global.getConfig(“geoserver.url”);
      String username = Global.getConfig(“geoserver.username”);
      String password = Global.getConfig(“geoserver.password”);
      String ws = Global.getConfig(“geoserver.ws”);
      rasterPublish = new RasterPublish(url,username,password,ws);
      rasterPublish.GeneralWorkspace();
      } catch (Exception e) {
      rasterPublish = null;
      log.error(“获取geoserver连接失败!errorMsg:” + e.getMessage());
      }
      log.info(“获取geoserver连接结束”);
      return rasterPublish;
      }

    /**

    • 发布tif 图层
    • @param filePath
    • @param storeName
    • @param styleName
    • @return
      */
      public static boolean rasterPublish(RasterPublish rasterPublish,String filePath,String storeName,String styleName){
      log.info(“发布图层开始”);
      boolean bl = true;
      try {
      //rasterPublish.GeneralRestStyles(styleName, asld);
      //String filePath=“C:\Users\Admin\Desktop\水保监测\yingshan_taohe2015_erosion073077_xz1.tif”;
      //String filePath=“C:\Users\Admin\Desktop\水保监测\yingshan_taohe2015_erosion073077_xz2new.tif”;
      //String styleName = “aFactorStyle”;//raster aFactorStyle
      String path = Global.getConfig(“afator.tif.rootpath”) + filePath;
      log.info(“path:”+path);
      File file = new File(path);
      if(file.exists()) {
      rasterPublish.Publish(path, storeName, storeName, styleName);
      }
      else {
      log.info(“path:” + path + “文件不存在!”);
      bl = false;
      }
      /rasterPublish.DeleteCoverage(storeName);/
      } catch (Exception e) {
      bl = false;
      log.error(“发布tif图层失败!errorMsg:” + e.getMessage());
      }
      log.info(“发布tif图层结束”);
      return bl;
      }

}

/**
*
*/
package com.jeeplus.common.utils;

/**

  • @Description

  • A因子计算因子类型常量
    */
    public enum AFactorTypeEnum{

    水土流失模数(“土壤侵蚀模数”,1,“a.tif”,“aFactorStyle”), //土壤侵蚀模数
    降雨侵蚀因子(“降雨侵蚀因子”,2,“r.tif”,“rFactorStyle”),
    植被覆盖与生物措施因子(“植被覆盖与生物措施因子”,3,“b.tif”,“bFactorStyle”),
    工程措施因子(“工程措施因子”,4,“e.tif”,“eFactorStyle”),
    土壤可蚀性因子(“土壤可蚀性因子”,5,“k.tif”,“kFactorStyle”),
    坡长因子(“坡长因子”,6,“l.tif”,“lFactorStyle”),
    坡度因子(“坡度因子”,7,“s.tif”,“sFactorStyle”),
    耕作措施因子(“耕作措施因子”,8,“t.tif”,“tFactorStyle”);

    /**

    • 根据 因子类型获取因子
    • @param factorType
    • @return
      /
      public static String getTifNameByType(Integer factorType){
      String tifName = null;
      for(AFactorTypeEnum platformFree:AFactorTypeEnum.values()){
      if(factorType.equals(platformFree.getFactorType())){
      tifName = platformFree.getTifName();
      break;
      }
      }
      return tifName;
      }
      /
      *
    • 根据 因子类型获取因子样式名
    • @param factorType
    • @return
      */
      public static String getStyleNameByType(Integer factorType){
      String styleName = null;
      for(AFactorTypeEnum platformFree:AFactorTypeEnum.values()){
      if(factorType.equals(platformFree.getFactorType())){
      styleName = platformFree.getStyleName();
      break;
      }
      }
      return styleName;
      }

    /**

    • 因子描述
      /
      private String factorDescribe;
      /
      *
    • 类型值
      */
      private Integer factorType;

    /**

    • tiff文件名
      /
      private String tifName;
      /
      *
    • 样式名
      */
      private String styleName;

    AFactorTypeEnum(String factorDescribe, Integer factorType, String tifName, String styleName) {
    this.factorDescribe = factorDescribe;
    this.factorType = factorType;
    this.tifName = tifName;
    this.setStyleName(styleName);
    }

    public String getFactorDescribe() {
    return factorDescribe;
    }

    public void setFactorDescribe(String factorDescribe) {
    this.factorDescribe = factorDescribe;
    }

    public Integer getFactorType() {
    return factorType;
    }

    public void setFactorType(Integer factorType) {
    this.factorType = factorType;
    }

    public String getTifName() {
    return tifName;
    }

    public void setTifName(String tifName) {
    this.tifName = tifName;
    }
    public String getStyleName() {
    return styleName;
    }
    public void setStyleName(String styleName) {
    this.styleName = styleName;
    }

}

package com.jeeplus.modules.analysis.web;

import com.jeeplus.common.json.AjaxJson;
import com.jeeplus.common.utils.AfactorPlanTypeEnum;
import com.jeeplus.common.utils.CommonContants;
import com.jeeplus.common.utils.StringUtils;
import com.jeeplus.core.persistence.Page;
import com.jeeplus.core.web.BaseController;
import com.jeeplus.modules.analysis.dto.GeoPublishEntity;
import com.jeeplus.modules.analysis.entity.AFactorPlan;
import com.jeeplus.modules.analysis.entity.AFactorPlanGeo;
import com.jeeplus.modules.analysis.entity.Basininfo;
import com.jeeplus.modules.analysis.service.AFactorPlanGeoService;
import com.jeeplus.modules.analysis.service.AFactorPlanService;
import com.jeeplus.modules.analysis.service.BasininfoService;
import com.jeeplus.modules.sys.entity.Area;
import com.jeeplus.modules.sys.service.AreaService;
import com.jeeplus.modules.sys.utils.UserUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;

/**

  • A因子计算 侵蚀模数

  • @author zb

  • @date 创建时间:2019年10月14日 下午3:06:26
    */
    @Controller
    @RequestMapping(value = “${adminPath}/analysis/aFactorMap”)
    public class AFactorMapController extends BaseController {

    @Autowired
    private AreaService areaService;
    @Autowired
    private AFactorPlanService aFactorPlanService;
    @Autowired
    private AFactorPlanGeoService aFactorPlanGeoService;
    @Autowired
    private BasininfoService basininfoService;

    @RequestMapping(value = { “index”, “” })
    public String index(HttpServletRequest request) {
    request.setAttribute(“userLevel”, UserUtils.getUserLevel());
    request.setAttribute(“userAreaCode”, UserUtils.getUserAreaCode());
    request.setAttribute(“userAreaName”, UserUtils.getUserAreaName());
    return “modules/analysis/aFactorMap”;
    }

    @ResponseBody
    @RequestMapping(“getData”)
    public Map getData(AFactorPlan aFactorPlan, HttpServletRequest request, HttpServletResponse response, Model model) {
    Integer userLevel = UserUtils.getUserLevel();
    String userAreaCode = UserUtils.getUserAreaCode();
    aFactorPlan.setUserLevel(userLevel);
    aFactorPlan.setUserAreaCode(userAreaCode);
    //省级不做过滤
    // if(!userLevel.equals(1)) {
    // List areaCodes = areaService.getChildAndCodesByCode(userAreaCode);
    // List basincodes = basininfoService.getBasincodesByAreaCode(areaCodes);
    // if(areaCodes != null && areaCodes.size()>0) {
    // aFactorPlan.setSearchAreaCodes(String.join(",",areaCodes));
    // }
    // if(basincodes != null && basincodes.size()>0) {
    // aFactorPlan.setSearchBasincodes(String.join(",",basincodes));
    // }
    // }
    Page page = aFactorPlanService.findPage(new Page(request, response), aFactorPlan);
    List list = page.getList();
    this.setZonalName(list);
    return getBootstrapData(page);
    }

    /**

    • 设置区域名称
    • @param list
      */
      public void setZonalName(List list){
      for (AFactorPlan aFactorPlan2 : list) {
      String scope = aFactorPlan2.getScope();
      //取小流域名称
      if(CommonContants.SCOPE_XIAOLIUYU.equals(scope)) {
      Basininfo basininfo = new Basininfo();
      basininfo.setBasincodes(aFactorPlan2.getZonalCode().split(","));
      List basininfoList = basininfoService.findList(basininfo);
      aFactorPlan2.setBasincode(aFactorPlan2.getZonalCode());
      if(basininfoList != null && basininfoList.size()>0) {
      String basinname = “”;
      String zonalName = “”;
      for (Basininfo basininfo2 : basininfoList) {
      basinname +=("".equals(basinname)?basininfo2.getBasinname():","+basininfo2.getBasinname());
      zonalName +=("".equals(zonalName)?basininfo2.getCounty()+ “/” +basininfo2.getBasinname():","+basininfo2.getCounty()+ “/” +basininfo2.getBasinname());
      }
      aFactorPlan2.setBasinname(basinname);
      aFactorPlan2.setZonalName(zonalName);
      }
      else {
      aFactorPlan2.setBasincode(aFactorPlan2.getZonalCode());
      aFactorPlan2.setZonalName(aFactorPlan2.getZonalCode());
      }
      }
      //取区域名称
      else {
      if(aFactorPlan2.getZonalCode() != null && “42”.equals(aFactorPlan2.getZonalCode())) {
      aFactorPlan2.setZonalName(“湖北省”);
      }
      else {
      List areas = areaService.getAreaByCodes(aFactorPlan2.getZonalCode().split(","));
      String zonalName = “”;
      if(areas != null && areas.size()>0) {
      for (Area area:areas) {
      zonalName +=("".equals(zonalName)?area.getName():","+area.getName());
      }
      }
      aFactorPlan2.setZonalName("".equals(zonalName)?aFactorPlan2.getZonalCode():zonalName);
      }
      }
      }
      }

    @ResponseBody
    @RequestMapping(value = “save”)
    public AjaxJson save(AFactorPlan aFactorPlan, HttpServletRequest request) throws Exception {
    AjaxJson j = new AjaxJson();
    String errMsg = beanValidator(aFactorPlan);
    if (StringUtils.isNotBlank(errMsg)) {
    j.setSuccess(false);
    j.setMsg(errMsg);
    return j;
    }
    if(AfactorPlanTypeEnum.A实时.getAFactorPlanType().equals(aFactorPlan.getPlanType())) {
    // 设置 A计算 区域编码 zonalCode
    aFactorPlanService.setAFactorZonalCode(aFactorPlan);
    // 验证数据的重复性
    List aFactorPlanList = aFactorPlanService.getAFactorByTimeAndPlanType(aFactorPlan);
    if(aFactorPlanList != null && aFactorPlanList.size()>0) {
    j.setSuccess(false);
    this.setZonalName(aFactorPlanList);
    j.put(“aFactorPlanList”,aFactorPlanList);
    j.setMsg(“保存计算任务失败!已经存在相同的计算任务”+aFactorPlanList.size()+“条!”);
    return j;
    }
    aFactorPlanService.saveAfactor(aFactorPlan);// 保存 A 计算
    }
    else {
    // 设置 R计算 区域编码 zonalCode
    aFactorPlanService.setRFactorZonalCode(aFactorPlan);
    // 验证数据的重复性
    List aFactorPlanList = aFactorPlanService.getAFactorByTimeAndPlanType(aFactorPlan);
    if(aFactorPlanList != null && aFactorPlanList.size()>0) {
    j.setSuccess(false);
    this.setZonalName(aFactorPlanList);
    j.put(“aFactorPlanList”,aFactorPlanList);
    j.setMsg(“保存计算任务失败!已经存在相同的计算任务”+aFactorPlanList.size()+“条!”);
    return j;
    }
    aFactorPlanService.saveRfactor(aFactorPlan);// 保存 R 计算
    }
    j.setSuccess(true);
    j.setMsg(“保存计算任务成功”);
    return j;
    }

    /**

    • 查看a因子计算相关信息
    • 发布因子相关的tif文件到geoserver
    • @param aFactorPlan
    • @param request
    • @return
    • @throws Exception
      */
      @ResponseBody
      @RequestMapping(value = “rePublish”)
      public AjaxJson rePublish(AFactorPlan aFactorPlan, HttpServletRequest request) throws Exception {
      AjaxJson j = new AjaxJson();
      // 因子类型
      Integer factorType = aFactorPlan.getFactorType();
      // 任务类型
      String planType = aFactorPlan.getPlanType();
      if(factorType == null) {
      j.setSuccess(false);
      j.setMsg(“查看因子类型不能为空!”);
      return j;
      }
      if(planType == null || “”.equals(planType)) {
      j.setSuccess(false);
      j.setMsg(“任务类型不能为空!”);
      return j;
      }
      //用户级别
      Integer userLevel = UserUtils.getUserLevel();
      //获取任务ID
      String aFactorPlanId = aFactorPlan.getId();
      // A计算任务ID为空取定时任务产生的tif图层
      if(aFactorPlanId == null || “”.equals(aFactorPlanId)) {
      AFactorPlan aFactorPlanParam = new AFactorPlan();
      //定时计算 由开始时间和任务类型就可以确定一个任务,先查询任务,根据任务查询或者发布tif图层进行展示
      aFactorPlanParam.setStartTime(getStartTimeByPlanType(planType));
      //aFactorPlanParam.setEndTime(getEndTime());
      aFactorPlanParam.setPlanType(planType);
      aFactorPlanParam.setScope(CommonContants.SCOPE_SHENG);
      List aFactorPlanList = aFactorPlanService.getAFactorByTimeAndPlanType(aFactorPlanParam);
      if(aFactorPlanList != null && aFactorPlanList.size()>0) {
      boolean haveSuccess = false;
      String errorMessage = “定时计算失败!”;
      for (AFactorPlan aFactorPlanRes:aFactorPlanList) {
      if(CommonContants.AFACTOR_PLAN_STATE_SUCCESS.equals(aFactorPlanRes.getState())) {
      haveSuccess = true;
      aFactorPlanId = aFactorPlanRes.getId();
      break;
      }
      else if(CommonContants.AFACTOR_PLAN_STATE_ERROR.equals(aFactorPlanRes.getState())) {
      errorMessage = aFactorPlanRes.getErrorMessage();
      }
      }
      if(!haveSuccess) {
      j.setSuccess(false);
      j.setMsg(errorMessage);
      return j;
      }
      }
      else {
      j.setSuccess(false);
      j.setMsg(“没有查询到该因子图层!”);
      return j;
      }
      }
      // 查询图层是否存在
      AFactorPlanGeo aFactorPlanGeoParam = new AFactorPlanGeo();
      aFactorPlanGeoParam.setAFactorPlanId(aFactorPlanId);
      aFactorPlanGeoParam.setFactorType(factorType);
      //不是省级用户,取省级任务下的定时任务生成的tif图层
      List areaCodes = null;
      if(StringUtils.isBlank(aFactorPlan.getId()) && userLevel != null && (!userLevel.equals(1))) {
      areaCodes = areaService.getChildAndCodesByCode(UserUtils.getUserAreaCode());
      aFactorPlanGeoParam.setAreaCodes(areaCodes);
      }
      //获取任务 图层是否存在,存在直接展示,不存在先发布图层再展示
      List aFactorPlanGeoList = aFactorPlanGeoService.getAFactorPlanGeoByFactorIdAndType(aFactorPlanGeoParam);
      if(aFactorPlanGeoList != null && aFactorPlanGeoList.size()>0) {
      // 定时任务为省级,市级、县级用户需要过滤
      if(areaCodes != null) {
      j.put(“aFactorPlanGeoList”, filterAFactorPlanGeoListByAreaCodes(aFactorPlanGeoList, areaCodes));
      }
      else {
      j.put(“aFactorPlanGeoList”, aFactorPlanGeoList);
      }
      j.setSuccess(true);
      j.setMsg(“图层已发布成功,可直接展示!”);
      return j;
      }
      //获取要发布的图层
      List geoPublishList = aFactorPlanService.getGeoPublishList(aFactorPlanId,factorType);
      if(geoPublishList == null || geoPublishList.size() == 0) {
      j.setSuccess(false);
      j.setMsg(“没有获取到可以发布的图层!”);
      return j;
      }
      //发布图层
      aFactorPlanGeoList = aFactorPlanService.rePublicGeo(geoPublishList);
      if(aFactorPlanGeoList != null && aFactorPlanGeoList.size()>0) {
      // 定时任务为省级,市级、县级用户需要过滤
      if(areaCodes != null) {
      j.put(“aFactorPlanGeoList”, filterAFactorPlanGeoListByAreaCodes(aFactorPlanGeoList, areaCodes));
      }
      else {
      j.put(“aFactorPlanGeoList”, aFactorPlanGeoList);
      }
      j.setSuccess(true);
      j.setMsg(“发布图层成功!”);
      }
      else {
      j.setSuccess(false);
      j.setMsg(“发布图层失败!”);
      }
      return j;
      }

    /**

    • 根据区划集合过滤数据
    • @param aFactorPlanGeoList
    • @param areaCodes
    • @return
      */
      public List filterAFactorPlanGeoListByAreaCodes(List aFactorPlanGeoList, List areaCodes){
      List aFactorPlanGeoListFilter = new ArrayList();
      for (AFactorPlanGeo aFactorPlanGeo:aFactorPlanGeoList
      ) {
      boolean bl= areaCodes.stream().anyMatch(areaCode -> Objects.equals(areaCode, aFactorPlanGeo.getZonalCode()));
      if(bl) {
      aFactorPlanGeoListFilter.add(aFactorPlanGeo);
      }
      }
      return aFactorPlanGeoListFilter;
      }

    /**

    • 获取定时的开始时间
    • @return
      */
      public Date getStartTimeByPlanType(String planType){
      Date result = new Date();
      //当前年 月 日
      Calendar currCal = Calendar.getInstance();
      int currentYear = currCal.get(Calendar.YEAR);
      int currentMonth = currCal.get(Calendar.MONTH) + 1;
      int currentDay = currCal.get(Calendar.DAY_OF_MONTH);
      Calendar cale = Calendar.getInstance();
      // 注释:cale.set(Calendar.MONTH, currentMonth - 1);代表设置月份为本月
      //1、任务类型为A定时年、R定时年
      if(AfactorPlanTypeEnum.A定时年.getAFactorPlanType().equals(planType) || AfactorPlanTypeEnum.R定时年.getAFactorPlanType().equals(planType)) {
      cale.clear();
      // 2019 年 查看的数据的开始时间是 2017年12月31号20点
      cale.set(Calendar.YEAR,currentYear-2);
      cale.roll(Calendar.DAY_OF_YEAR, -1);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      result = cale.getTime();
      }
      //2、任务类型为A定时月、R定时月
      else if(AfactorPlanTypeEnum.A定时月.getAFactorPlanType().equals(planType) || AfactorPlanTypeEnum.R定时月.getAFactorPlanType().equals(planType)) {
      cale.clear();
      //上半月,取上个月下半月的数据
      if(currentMonth == 1) {
      // 1 月 取上一年 11月 最后一天开始的
      cale.set(Calendar.YEAR,currentYear-1);
      cale.set(Calendar.MONTH,10);
      // 获取某月最大天数
      int lastDay = cale.getActualMaximum(Calendar.DATE);
      cale.set(Calendar.DAY_OF_MONTH, lastDay);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      }
      else {
      // 取上个月 15号20点开始的
      cale.set(Calendar.YEAR,currentYear);
      //设置月份为上上个月
      cale.set(Calendar.MONTH, currentMonth - 3);
      // 获取某月最大天数
      int lastDay = cale.getActualMaximum(Calendar.DATE);
      cale.set(Calendar.DAY_OF_MONTH, lastDay);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      }
      result = cale.getTime();
      }
      //3、任务类型为A定时半月、R定时半月
      else if(AfactorPlanTypeEnum.A定时半月.getAFactorPlanType().equals(planType) || AfactorPlanTypeEnum.R定时半月.getAFactorPlanType().equals(planType)) {
      cale.clear();
      if(currentDay < 16) {
      //上半月,取上个月下半月的数据
      if(currentMonth == 1) {
      // 1 月 取上一年 12月15号开始的
      cale.set(Calendar.YEAR,currentYear-1);
      cale.set(Calendar.MONTH,11);
      cale.set(Calendar.DAY_OF_YEAR, 15);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      }
      else {
      // 取上个月 15号20点开始的
      cale.set(Calendar.YEAR,currentYear);
      cale.set(Calendar.MONTH, currentMonth - 2);
      cale.set(Calendar.DAY_OF_MONTH, 15);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      }
      }
      else {
      //下半月, 取本月上半月
      if(currentMonth == 1) {
      // 1 月 取上一年 12月最后一天20点开始的
      cale.set(Calendar.YEAR,currentYear-1);
      cale.roll(Calendar.DAY_OF_YEAR, -1);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      }
      else {
      // 取上月 最后一天 20点开始的
      cale.set(Calendar.YEAR,currentYear);
      cale.set(Calendar.DAY_OF_MONTH,currentMonth - 2);
      // 获取某月最大天数
      int lastDay = cale.getActualMaximum(Calendar.DATE);
      cale.set(Calendar.DAY_OF_MONTH, lastDay);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      }
      }
      result = cale.getTime();
      }
      //5、任务类型为A定时日、R定时日
      else if(AfactorPlanTypeEnum.A定时日.getAFactorPlanType().equals(planType) || AfactorPlanTypeEnum.R定时日.getAFactorPlanType().equals(planType)) {
      cale.add(Calendar.DAY_OF_MONTH, -2);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      result = cale.getTime();
      }
      return result;
      }

    /**

    • 获取定时的结束时间
    • @return
      */
      public Date getEndTime(){
      Calendar cale = Calendar.getInstance();
      cale.add(Calendar.DAY_OF_MONTH, -1);
      cale.set(Calendar.HOUR_OF_DAY, 20);
      cale.set(Calendar.MINUTE, 0);
      cale.set(Calendar.SECOND, 0);
      cale.set(Calendar.MILLISECOND, 0);// 毫秒
      return cale.getTime();
      }

}
2、service
/**

  • Copyright © 2015-2020 JeePlus All rights reserved.
    */
    package com.jeeplus.modules.analysis.service;

import com.jeeplus.common.config.Global;
import com.jeeplus.common.utils.*;
import com.jeeplus.common.utils.time.DateFormatUtil;
import com.jeeplus.core.persistence.Page;
import com.jeeplus.core.service.CrudService;
import com.jeeplus.modules.analysis.dto.GeoPublishEntity;
import com.jeeplus.modules.analysis.entity.AFactorPlan;
import com.jeeplus.modules.analysis.entity.AFactorPlanGeo;
import com.jeeplus.modules.analysis.mapper.AFactorPlanGeoMapper;
import com.jeeplus.modules.analysis.mapper.AFactorPlanMapper;
import com.jeeplus.modules.analysis.mapper.BasininfoMapper;
import com.jeeplus.modules.sys.entity.AddvSbSj;
import com.jeeplus.modules.sys.entity.Area;
import com.jeeplus.modules.sys.mapper.AreaMapper;
import com.jeeplus.modules.sys.mapper.SbSjMapper;
import ev.springboot.gsserver.RasterPublish;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**

  • A因子计算Service

  • @author zb

  • @version 2019-10-24
    */
    @Service
    @Transactional(readOnly = true)
    public class AFactorPlanService extends CrudService {

    @Autowired
    private AFactorPlanGeoMapper aFactorPlanGeoMapper;
    @Autowired
    private AreaMapper areaMapper;
    @Autowired
    private BasininfoMapper basininfoMapper;
    @Autowired
    private SbSjMapper sbSjMapper;

    public AFactorPlan get(String id) {
    return super.get(id);
    }

    public List findList(AFactorPlan aFactorPlan) {
    return super.findList(aFactorPlan);
    }
    public List getAFactorByTimeAndPlanType(AFactorPlan aFactorPlan) {
    return mapper.getAFactorByTimeAndPlanType(aFactorPlan);
    }

    /**

    • 发布图层,可发布多个
    • @param geoPublishList
    • @return
      */
      @Transactional(readOnly = false,rollbackFor = Exception.class)
      public List rePublicGeo(List geoPublishList){
      List aFactorPlanGeoList = new ArrayList();
      //获取geoserver连接
      RasterPublish rasterPublish = RasterPublishUtils.createGeoserverConnect();
      if(rasterPublish == null) {
      return aFactorPlanGeoList;
      }
      for (GeoPublishEntity geoPublishEntity: geoPublishList) {
      boolean bl = RasterPublishUtils.rasterPublish(rasterPublish,geoPublishEntity.getFilePath(),geoPublishEntity.getStoreName(),geoPublishEntity.getStyleName());
      AFactorPlanGeo aFactorPlanGeoResp = new AFactorPlanGeo();
      if(!bl) {
      aFactorPlanGeoResp.setAFactorPlanId(geoPublishEntity.getaFactorPlanId());
      aFactorPlanGeoResp.setFactorType(geoPublishEntity.getFactorType());
      aFactorPlanGeoResp.setGeoWs(Global.getConfig(“geoserver.ws”));
      aFactorPlanGeoResp.setGeoName(geoPublishEntity.getStoreName());
      aFactorPlanGeoResp.setPlanName(geoPublishEntity.getaFactorPlan().getPlanName());
      aFactorPlanGeoResp.setPlanType(geoPublishEntity.getaFactorPlan().getPlanType());
      aFactorPlanGeoResp.setScope(geoPublishEntity.getaFactorPlan().getScope());
      aFactorPlanGeoResp.setZonalCode(geoPublishEntity.getZonalCode());
      aFactorPlanGeoResp.setSuccess(false);
      aFactorPlanGeoResp.setMsg(“区域编码为:”+geoPublishEntity.getZonalCode()+“的图层发布失败!”);
      }
      else {
      //保存影像信息
      aFactorPlanGeoResp = saveAfactorGeo(geoPublishEntity);
      aFactorPlanGeoResp.setSuccess(true);
      }
      aFactorPlanGeoList.add(aFactorPlanGeoResp);
      }
      return aFactorPlanGeoList;
      }

    /**

    • 获取要发布的图层集合
    • @param aFactorPlanId
    • @param factorType
    • @return
      /
      public List getGeoPublishList(String aFactorPlanId,Integer factorType){
      List geoPublishList = new ArrayList();
      AFactorPlan aFactorPlanResponse = mapper.get(aFactorPlanId);
      aFactorPlanResponse.setFactorType(factorType);
      // 区域编码或小流域编码
      String zonalCode = aFactorPlanResponse.getZonalCode();
      zonalCode = zonalCode.length() == 2?(zonalCode+“0000”):zonalCode;
      // 计算范围、省、市、县、小流域
      String scope = aFactorPlanResponse.getScope();
      // 任务类型(“A实时”、“R实时”、“A定时”、“R定时”。。)
      String planType = aFactorPlanResponse.getPlanType();
      // 任务名称
      String planName = aFactorPlanResponse.getPlanName();
      // 任务计算周期开始时间
      //Date startTime = aFactorPlanResponse.getStartTime();
      //Date endTime = aFactorPlanResponse.getEndTime();
      Date date = aFactorPlanResponse.getStartTime();
      Date endTime = aFactorPlanResponse.getEndTime();
      // 因子图相对路径
      String planTypePath = CommonContants.AFACTOR_REALTIME;
      if(factorType>2) {
      //6因子
      planTypePath = CommonContants.AFACTOR_BG;
      // B 因子
      // 实时计算所选时间段跨半月
      //B因子:42/4201/420101/RealTime/20191023110000/b.tif。
      //实时计算所选时间段没跨半月,判断查询时间段所属半月号,如2019-11-01 —— 2019-11-10,则属于21半月,其B因子在
      //B因子:42/4201/420101/ bg00/slr/slr21.tif实时计算所选时间段跨半月
      //B因子:42/4201/420101/RealTime/20191023110000/b.tif。
      //实时计算所选时间段没跨半月,判断查询时间段所属半月号,如2019-11-01 —— 2019-11-10,则属于21半月,其B因子在
      //B因子:42/4201/420101/ bg00/slr/slr21.tif
      if(AFactorTypeEnum.植被覆盖与生物措施因子.getFactorType().equals(factorType)) {
      if(AfactorPlanTypeEnum.A实时.getAFactorPlanType().equals(planType)){
      //没有跨半月, 不进行计算 直接取42/4201/420101/ bg00/slr/slr21.tif
      if(isNotKuaBanYue(date,endTime)) {
      planTypePath = CommonContants.AFACTOR_BG + “/slr”;
      }
      else {
      planTypePath = CommonContants.AFACTOR_REALTIME + “/” + planName;
      }
      }
      else {
      // 定时的都是跨半月的
      planTypePath = CommonContants.AFACTOR_REALTIME + “/” + planName;
      }
      }
      }
      else {
      // A因子 R因子
      planTypePath = this.getPlanFilePathByDateAndPlanType(date, planType, planName);
      }
      // tif 文件名
      String fileName = AFactorTypeEnum.getTifNameByType(factorType);
      /

      if(AfactorPlanTypeEnum.R定时年.getAFactorPlanType().equals(planType)
      || AfactorPlanTypeEnum.R定时月.getAFactorPlanType().equals(planType)
      || AfactorPlanTypeEnum.R定时半月.getAFactorPlanType().equals(planType)
      || AfactorPlanTypeEnum.R定时日.getAFactorPlanType().equals(planType)
      ) {
      fileName = CommonContants.R_RUNTIME_FILE_NAME;
      }/
      // A实时计算 :没有跨半月, 不进行计算 直接取42/4201/420101/ bg00/slr/slr21.tif
      if(AFactorTypeEnum.植被覆盖与生物措施因子.getFactorType().equals(factorType)) {
      if (AfactorPlanTypeEnum.A实时.getAFactorPlanType().equals(planType)) {
      //没有跨半月, 不进行计算 直接取42/4201/420101/ bg00/slr/slr21.tif
      //若:实时计算所选时间段跨半月会生成b.tif,存放路径为:
      //B因子:42/4201/420101/RealTime/20191023110000/b.tif。
      //若:实时计算所选时间段没跨半月,判断查询时间段所属半月,判断规则为:当日<=15时,所属半月为 2
      月-1,当日>15时,所属半月为2月。
      //如2019-11-01 —— 2019-11-10。则属于2
      11-1=21半月,其B因子调用对应半月slr参与计算。
      //B因子:42/4201/420101/ bg00/slr/slr21.tif
      if (isNotKuaBanYue(date, endTime)) {
      Calendar startCalender = Calendar.getInstance();
      startCalender.setTime(date);
      int startMonth = startCalender.get(Calendar.MONTH) + 1;
      int startDayOfMonth = startCalender.get(Calendar.DAY_OF_MONTH);
      Integer byInt = (startDayOfMonth<=15?(2startMonth - 1):(2startMonth));
      fileName = “slr” + (byInt<10?“0”+byInt:byInt) + “.tif”;
      }
      }
      }
      // 样式名
      String styleName = AFactorTypeEnum.getStyleNameByType(factorType);
      // tif 文件路径
      String filePath = “”;
      //小流域
      if(CommonContants.SCOPE_XIAOLIUYU.equals(scope)){
      //获取所有小流域信息
      String basincodes[] = zonalCode.split(",");
      for (String basincode : basincodes) {
      //小流域 D:\BJ-RUC\42\0000\420111\FA030000021420111
      filePath = “0000/” + basincode.substring(basincode.length() - 6, basincode.length())
      + “/” + basincode
      + “/” + planTypePath
      + “/” + fileName;
      String storeName = “sbjc_”+ UUID.randomUUID().toString().replace("-", “”);
      geoPublishList.add(this.setGeoPublicEntity(filePath,storeName,styleName,aFactorPlanResponse,basincode));
      }
      }
      //省 市
      else if(CommonContants.SCOPE_SHENG.equals(scope) || CommonContants.SCOPE_SHI.equals(scope)){
      if(AfactorPlanTypeEnum.R定时年.getAFactorPlanType().equals(planType)
      || AfactorPlanTypeEnum.R定时月.getAFactorPlanType().equals(planType)
      || AfactorPlanTypeEnum.R定时半月.getAFactorPlanType().equals(planType)
      || AfactorPlanTypeEnum.R定时日.getAFactorPlanType().equals(planType)
      ) {
      // 这几个计算的都是全省的图 42/2019/10/23/rr.tif
      // 42/2019/13/rr.tif
      filePath = planTypePath
      + “/” + fileName;
      String storeName = “sbjc_”+ UUID.randomUUID().toString().replace("-", “”);
      geoPublishList.add(this.setGeoPublicEntity(filePath,storeName,styleName,aFactorPlanResponse,aFactorPlanResponse.getZonalCode()));
      }
      else if(AfactorPlanTypeEnum.R实时.getAFactorPlanType().equals(planType)){
      //R实时 市级
      if(CommonContants.SCOPE_SHI.equals(scope)){
      String zonalCodes[] = zonalCode.split(",");
      for (String cityCode : zonalCodes) {
      // D:\42\4201\RealTime\20191122114921697
      filePath = cityCode.substring(0,4)
      + “/” + planTypePath
      + “/” + fileName;
      String storeName = “sbjc_” + UUID.randomUUID().toString().replace("-", “”);
      geoPublishList.add(this.setGeoPublicEntity(filePath,storeName,styleName,aFactorPlanResponse,cityCode));
      }
      }
      //R实时 省级
      else if(CommonContants.SCOPE_SHENG.equals(scope)){
      //D:\42\RealTime\20191122120823014
      filePath = planTypePath
      + “/” + fileName;
      String storeName = “sbjc_”+ UUID.randomUUID().toString().replace("-", “”);
      geoPublishList.add(this.setGeoPublicEntity(filePath,storeName,styleName,aFactorPlanResponse,zonalCode));
      }
      }
      else {
      // A实时、 A定时年、A定时月、A定时半月、 A定时日、
      //获取所有县信息
      List areaList = areaMapper.getCountyByCodes(zonalCode.split(","));
      for (Area area : areaList) {
      // 县 D:\BJ-RUC\42\4201\420103\RealTime\20191025125410034
      filePath = area.getParent().getCode().substring(0, 4)
      + “/” + area.getCode()
      + “/” + planTypePath
      + “/” + fileName;
      String storeName = “sbjc_”+ UUID.randomUUID().toString().replace("-", “”);
      geoPublishList.add(this.setGeoPublicEntity(filePath,storeName,styleName,aFactorPlanResponse,area.getCode()));
      }
      }
      }
      //县
      else {
      // 县 D:\BJ-RUC\42\4201\420103\RealTime\20191025125410034
      //获取所有县信息
      List areaList = areaMapper.getCountyByCodes(zonalCode.split(","));
      for (Area area : areaList) {
      // 县 D:\BJ-RUC\42\4201\420103\RealTime\20191025125410034
      filePath = area.getParent().getCode().substring(0, 4)
      + “/” + area.getCode()
      + “/” + planTypePath
      + “/” + fileName;
      String storeName = “sbjc_”+ UUID.randomUUID().toString().replace("-", “”);
      geoPublishList.add(this.setGeoPublicEntity(filePath,storeName,styleName,aFactorPlanResponse,area.getCode()));
      }
      }
      return geoPublishList;
      }

    /**

    • 判断 开始时间和结束时间是没有跨半月,跨
    • @param startTime
    • @param endTime
    • @return
      */
      public boolean isNotKuaBanYue(Date startTime, Date endTime){
      boolean bl = false;
      // 开始时间
      Calendar start = Calendar.getInstance();
      start.setTime(startTime);
      // 结束时间
      Calendar end = Calendar.getInstance();
      end.setTime(endTime);
      int startMonth = start.get(Calendar.MONTH);
      int startMonthOfDay = start.get(Calendar.DAY_OF_MONTH);
      int endMonth = end.get(Calendar.MONTH);
      int endMonthOfDay = end.get(Calendar.DAY_OF_MONTH);
      if(startMonth == endMonth) {
      if((startMonthOfDay<=15 && endMonthOfDay <=15)
      || (startMonthOfDay>15 && endMonthOfDay >15)) {
      bl = true;
      }
      }
      return bl;
      }

    /**

    • 设置 图层对象
    • @param filePath
    • @param storeName
    • @param styleName
    • @param aFactorPlan
    • @param zonalCode
    • @return
      */
      public GeoPublishEntity setGeoPublicEntity(String filePath, String storeName, String styleName,AFactorPlan aFactorPlan, String zonalCode){
      GeoPublishEntity geoPublishEntity = new GeoPublishEntity();
      geoPublishEntity.setFilePath(filePath);
      geoPublishEntity.setStoreName(storeName);
      geoPublishEntity.setStyleName(styleName);
      geoPublishEntity.setaFactorPlanId(aFactorPlan.getId());
      geoPublishEntity.setFactorType(aFactorPlan.getFactorType());
      geoPublishEntity.setaFactorPlan(aFactorPlan);
      geoPublishEntity.setZonalCode(zonalCode);
      return geoPublishEntity;
      }

    /**

    • 获取tif文件的相对路劲
    • @param date
    • @param planType
    • @param planName
    • @return
      /
      public String getPlanFilePathByDateAndPlanType(Date date, String planType, String planName){
      String planTypePath = “”;
      SimpleDateFormat yearSdf = new SimpleDateFormat(“yyyy”);
      SimpleDateFormat monthSdf = new SimpleDateFormat(“yyyy/MM”);
      SimpleDateFormat daySdf = new SimpleDateFormat(“yyyy/MM/dd”);
      Calendar calendar = Calendar.getInstance();
      calendar.setTime(date);
      int year = calendar.get(Calendar.YEAR);
      int month = calendar.get(Calendar.MONTH) + 1;
      int monthOfDay = calendar.get(Calendar.DAY_OF_MONTH);
      switch (planType) {
      case “A实时” :
      planTypePath = CommonContants.AFACTOR_REALTIME + “/” + planName;
      break;
      case “R实时” :
      planTypePath = CommonContants.AFACTOR_REALTIME + “/” + planName;
      break;
      case “A定时年” :
      planTypePath = String.valueOf(year + 1);
      break;
      case “R定时年” :
      planTypePath = String.valueOf(year + 1);
      break;
      case “A定时月” :
      if(month == 12) {
      planTypePath = String.valueOf(year + 1) +"/01";
      }
      else {
      planTypePath = String.valueOf(year) + “/” + String.valueOf(month + 1);
      }
      // planTypePath = monthSdf.format(date);
      break;
      case “R定时月” :
      if(month == 12) {
      planTypePath = String.valueOf(year + 1) +"/01";
      }
      else {
      planTypePath = String.valueOf(year) + “/” + String.valueOf(month + 1);
      }
      // planTypePath = monthSdf.format(date);
      break;
      case “A定时半月” :
      //下半月
      if(monthOfDay == 15) {
      int byMonthA = (2
      month);
      planTypePath = String.valueOf(year) + “/by” + (byMonthA<10?(“0”+byMonthA) : byMonthA);
      }
      //上半月
      else {
      int byMonthA = (2month - 1);
      planTypePath = String.valueOf(year) + “/by” + (byMonthA<10?(“0”+byMonthA) : byMonthA);
      }
      //int byMonthA = (2
      month - 1);
      //planTypePath = yearSdf.format(date) + “/by” + (byMonthA<10?(“0”+byMonthA) : byMonthA);
      // if(month<16) {
      // //上半月 2n - 1
      // planTypePath = yearSdf.format(date) + “/by” + (2month + 11);
      // }{
      // //下班月 2n + 12
      // planTypePath = yearSdf.format(date) + “/by” + (2
      month + 12);
      // }
      break;
      case “R定时半月” :
      //下半月
      if(monthOfDay == 15) {
      int byMonthA = (2month);
      planTypePath = String.valueOf(year) + “/by” + (byMonthA<10?(“0”+byMonthA) : byMonthA);
      }
      //上半月
      else {
      int byMonthA = (2
      month - 1);
      planTypePath = String.valueOf(year) + “/by” + (byMonthA<10?(“0”+byMonthA) : byMonthA);
      }
      //int byMonthR = (2month - 1);
      //planTypePath = yearSdf.format(date) + “/by” + (byMonthR<10?(“0”+byMonthR) : byMonthR);
      // if(month<16) {
      // //上半月 2n + 11
      // planTypePath = yearSdf.format(date) + “/” + (2
      month + 11);
      // }{
      // //下班月 2n + 12
      // planTypePath = yearSdf.format(date) + “/” + (2*month + 12);
      // }
      break;
      case “A定时日” :
      planTypePath = daySdf.format(date);
      break;
      case “R定时日” :
      planTypePath = daySdf.format(date);
      break;
      default :
      break;
      }
      return planTypePath;
      }

    /**

    • 保存发布的影像信息
    • @param geoPublishEntity
    • @return
      */
      @Transactional(readOnly = false,rollbackFor = Exception.class)
      public AFactorPlanGeo saveAfactorGeo(GeoPublishEntity geoPublishEntity){
      // 存放发布的影像信息
      AFactorPlanGeo aFactorPlanGeo = new AFactorPlanGeo();
      aFactorPlanGeo.setAFactorPlanId(geoPublishEntity.getaFactorPlanId());
      aFactorPlanGeo.setFilePath(geoPublishEntity.getFilePath());
      aFactorPlanGeo.setStyleName(geoPublishEntity.getStyleName());
      aFactorPlanGeo.setFactorType(geoPublishEntity.getFactorType());
      aFactorPlanGeo.setGeoWs(Global.getConfig(“geoserver.ws”));
      aFactorPlanGeo.setGeoName(geoPublishEntity.getStoreName());
      aFactorPlanGeo.setZonalCode(geoPublishEntity.getZonalCode());
      aFactorPlanGeo.setPlanName(geoPublishEntity.getaFactorPlan().getPlanName());
      aFactorPlanGeo.setPlanType(geoPublishEntity.getaFactorPlan().getPlanType());
      aFactorPlanGeo.setScope(geoPublishEntity.getaFactorPlan().getScope());
      aFactorPlanGeo.setId(IdGen.uuid());
      aFactorPlanGeo.setCreateDate(new Date());
      aFactorPlanGeoMapper.insert(aFactorPlanGeo);
      return aFactorPlanGeo;
      }

    public Page findPage(Page page, AFactorPlan aFactorPlan) {
    return super.findPage(page, aFactorPlan);
    }

    public Page findPageGroupByPlanName(Page page, AFactorPlan aFactorPlan) {
    aFactorPlan.setPage(page);
    page.setList(mapper.findPageGroupByPlanName(aFactorPlan));
    return page;
    }

    /**

    • A 计算实时计算保存
    • @param aFactorPlan
      */
      @Transactional(readOnly = false)
      public void saveAfactor(AFactorPlan aFactorPlan) {
      aFactorPlan.setIdType(“AUTO”);
      aFactorPlan.setPlanStartTime(new Date());
      aFactorPlan.setState(“待处理”);
      aFactorPlan.setPlanName(DateFormatUtil.formatDate(“yyyyMMddHHmmssSSS”,new Date()));
      super.save(aFactorPlan);
      }

    /**

    • R实时计算保存
    • @param aFactorPlan
      */
      @Transactional(readOnly = false,rollbackFor = Exception.class)
      public void saveRfactor(AFactorPlan aFactorPlan) {
      aFactorPlan.setIdType(“AUTO”);
      aFactorPlan.setPlanStartTime(new Date());
      aFactorPlan.setState(“待处理”);
      aFactorPlan.setPlanName(DateFormatUtil.formatDate(“yyyyMMddHHmmssSSS”,new Date()));
      super.save(aFactorPlan);
      }

    /**

    • 设置 A 计算保存的区域编码
    • @param aFactorPlan
      */
      public void setAFactorZonalCode(AFactorPlan aFactorPlan){
      Integer chooseType = aFactorPlan.getChooseType();
      if(chooseType != null) {
      //选择的区域
      if(chooseType == 1) {
      // String zonalCodesParam[] = aFactorPlan.getZonalCode().split(",");
      // List areaList = areaMapper.getCountyByCodes(zonalCodesParam);
      // List countyList = areaList.stream().map(Area::getCode).collect(Collectors.toList());
      // String zonalCodes[] = new String[countyList.size()];
      // zonalCodes = countyList.toArray(zonalCodes);
      // aFactorPlan.setZonalCodes(zonalCodes);
      // aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      String zonalCodesParam[] = aFactorPlan.getZonalCode().split(",");
      boolean haveProvince = false;
      boolean haveCity = false;
      List cityList = new ArrayList();
      for (String code:zonalCodesParam) {
      if(CommonContants.DEFAULT_SHENG_CODE.equals(code)) {
      haveProvince = true;
      }
      if(“00”.equals(code.substring(code.length()-2,code.length()))) {
      haveCity = true;
      cityList.add(code);
      }
      }
      // 有省级的,直接计算省级的
      if(haveProvince) {
      String zonalCodes[] = new String[]{CommonContants.DEFAULT_SHENG_CODE};
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setScope(CommonContants.SCOPE_SHENG);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      else {
      if(haveCity) {
      String zonalCodes[] = new String[cityList.size()];
      zonalCodes = cityList.toArray(zonalCodes);
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setScope(CommonContants.SCOPE_SHI);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      else {
      List areaList = areaMapper.getCountyByCodes(zonalCodesParam);
      List countyList = areaList.stream().map(Area::getCode).collect(Collectors.toList());
      String zonalCodes[] = new String[countyList.size()];
      zonalCodes = countyList.toArray(zonalCodes);
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setScope(CommonContants.SCOPE_XIAN);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      }
      }
      //选择的八大块
      else if(chooseType == 2) {
      String sbsjCodes[] = aFactorPlan.getSbsjCode().split(",");
      AddvSbSj addvSbSj = new AddvSbSj();
      addvSbSj.setSbsjCodes(sbsjCodes);
      List addvSbsjList = sbSjMapper.findAllAddvBySbSjs(addvSbSj);
      List countyList = addvSbsjList.stream().map(AddvSbSj::getCountyCode).collect(Collectors.toList());
      String zonalCodes[] = new String[countyList.size()];
      zonalCodes = countyList.toArray(zonalCodes);
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      //选择小流域
      else if(chooseType == 3) {
      String zonalCodes[] = aFactorPlan.getBasincode().split(",");
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      }
      else {
      // 区域集合
      String zonalCodes[] = aFactorPlan.getZonalCode().split(",");
      aFactorPlan.setZonalCodes(zonalCodes);
      }
      }

    /**

    • 设置 R 计算保存的区域编码
    • @param aFactorPlan
      */
      public void setRFactorZonalCode(AFactorPlan aFactorPlan){
      Integer chooseType = aFactorPlan.getChooseType();
      if(chooseType != null) {
      //选择的区域
      if(chooseType == 1) {
      String zonalCodesParam[] = aFactorPlan.getZonalCode().split(",");
      boolean haveProvince = false;
      boolean haveCity = false;
      List cityList = new ArrayList();
      for (String code:zonalCodesParam) {
      if(CommonContants.DEFAULT_SHENG_CODE.equals(code)) {
      haveProvince = true;
      }
      if(“00”.equals(code.substring(code.length()-2,code.length()))) {
      haveCity = true;
      cityList.add(code);
      }
      }
      // 有省级的,直接计算省级的
      if(haveProvince) {
      String zonalCodes[] = new String[]{CommonContants.DEFAULT_SHENG_CODE};
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setScope(CommonContants.SCOPE_SHENG);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      else {
      if(haveCity) {
      String zonalCodes[] = new String[cityList.size()];
      zonalCodes = cityList.toArray(zonalCodes);
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setScope(CommonContants.SCOPE_SHI);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      else {
      List areaList = areaMapper.getCountyByCodes(zonalCodesParam);
      List countyList = areaList.stream().map(Area::getCode).collect(Collectors.toList());
      String zonalCodes[] = new String[countyList.size()];
      zonalCodes = countyList.toArray(zonalCodes);
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setScope(CommonContants.SCOPE_XIAN);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      }
      }
      //选择的八大块
      else if(chooseType == 2) {
      String sbsjCodes[] = aFactorPlan.getSbsjCode().split(",");
      AddvSbSj addvSbSj = new AddvSbSj();
      addvSbSj.setSbsjCodes(sbsjCodes);
      List addvSbsjList = sbSjMapper.findAllAddvBySbSjs(addvSbSj);
      List countyList = addvSbsjList.stream().map(AddvSbSj::getCountyCode).collect(Collectors.toList());
      String zonalCodes[] = new String[countyList.size()];
      zonalCodes = countyList.toArray(zonalCodes);
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      //选择小流域
      else if(chooseType == 3) {
      String zonalCodes[] = aFactorPlan.getBasincode().split(",");
      aFactorPlan.setZonalCodes(zonalCodes);
      aFactorPlan.setZonalCode(String.join(",",zonalCodes));
      }
      }
      else {
      // 区域集合
      String zonalCodes[] = aFactorPlan.getZonalCode().split(",");
      aFactorPlan.setZonalCodes(zonalCodes);
      }
      }

    @Transactional(readOnly = false)
    public void delete(AFactorPlan aFactorPlan) {
    super.delete(aFactorPlan);
    }

}
3、entity
package com.jeeplus.modules.analysis.entity;

import java.util.Date;

import javax.validation.constraints.NotNull;

import org.hibernate.validator.constraints.NotBlank;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.jeeplus.core.persistence.DataEntity;

/**

  • @author zb

  • A因子计算任务
    */
    public class AFactorPlan extends DataEntity{

    /**

    */
    private static final long serialVersionUID = 1L;

    /**

    • 页面选择的类型 区域、八大块、小流域
      */
      private Integer chooseType;

    /**

    • 因子类型
      */
      private Integer factorType;

    /**

    • 开始时间
      /
      private Date planStartTime;
      /
      *
    • 截止时间
      /
      private Date planEndTime;
      /
      *
    • 开始时间
      /
      @NotNull(message = “开始时间不能为空”)
      private Date startTime;
      /
      *
      结束时间
      /
      @NotNull(message = “截止时间不能为空”)
      private Date endTime;
      /
    • 计算级别(“省”、“市”、“县”、“小流域”)
      /
      @NotBlank(message = “计算级别不能为空”)
      private String scope;
      /
      *
    • 任务类型(“即时”、“周期”)
      /
      @NotBlank(message = “任务类型不能为空”)
      private String planType;
      /
      *
    • 任务名称(采用任务发布时间字符串)
      /
      private String planName;
      /
      *
    • 分辨率
      /
      @NotNull(message = “分辨率不能为空”)
      private Double cellSize;
      /
    • 区域编号
      */
      @NotBlank(message = “区域编号不能为空”)
      private String zonalCode;

    /**

    • 区域、小流域编码集合
      /
      private String zonalCodes[];
      /
      *
    • 区域名称
      /
      private String zonalName;
      /
      *
    • 小流域编码
      /
      private String basincode;
      /
      *
    • 小流域名称
      /
      private String basinname;
      /
      *
    • 三大分区编码
      /
      private String sbsjCode;
      /
      *
    • 三大分区名称
      */
      private String sbsjName;

    /**

    • 处理状态
      */
      private String state;

    /**

    • 错误消息
      */
      private String errorMessage;

    /**

    • 用户区域编码
    • @return
      */
      private String userAreaCode;

    /**

    • 用户级别
      */
      private Integer userLevel;

    private String searchAreaCodes;//逗号分隔的用户区划下的区域编码集合
    private String searchBasincodes;//逗号分隔的用户区划下的小流域编码集合

    public String getSearchAreaCodes() {
    return searchAreaCodes;
    }

    public void setSearchAreaCodes(String searchAreaCodes) {
    this.searchAreaCodes = searchAreaCodes;
    }

    public String getSearchBasincodes() {
    return searchBasincodes;
    }

    public void setSearchBasincodes(String searchBasincodes) {
    this.searchBasincodes = searchBasincodes;
    }

    public String getUserAreaCode() {
    return userAreaCode;
    }

    public void setUserAreaCode(String userAreaCode) {
    this.userAreaCode = userAreaCode;
    }

    public Integer getUserLevel() {
    return userLevel;
    }

    public void setUserLevel(Integer userLevel) {
    this.userLevel = userLevel;
    }

    public String[] getZonalCodes() {
    return zonalCodes;
    }

    public void setZonalCodes(String[] zonalCodes) {
    this.zonalCodes = zonalCodes;
    }

    public String getSbsjCode() {
    return sbsjCode;
    }

    public void setSbsjCode(String sbsjCode) {
    this.sbsjCode = sbsjCode;
    }

    public String getSbsjName() {
    return sbsjName;
    }

    public void setSbsjName(String sbsjName) {
    this.sbsjName = sbsjName;
    }

    public Integer getChooseType() {
    return chooseType;
    }

    public void setChooseType(Integer chooseType) {
    this.chooseType = chooseType;
    }

    @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”)
    public Date getPlanStartTime() {
    return planStartTime;
    }

    public void setPlanStartTime(Date planStartTime) {
    this.planStartTime = planStartTime;
    }

    @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”)
    public Date getPlanEndTime() {
    return planEndTime;
    }

    public void setPlanEndTime(Date planEndTime) {
    this.planEndTime = planEndTime;
    }

    public String getScope() {
    return scope;
    }

    public void setScope(String scope) {
    this.scope = scope;
    }

    public String getPlanType() {
    return planType;
    }

    public void setPlanType(String planType) {
    this.planType = planType;
    }

    public String getPlanName() {
    return planName;
    }

    public void setPlanName(String planName) {
    this.planName = planName;
    }

    public Double getCellSize() {
    return cellSize;
    }

    public void setCellSize(Double cellSize) {
    this.cellSize = cellSize;
    }

    public String getZonalCode() {
    return zonalCode;
    }

    public void setZonalCode(String zonalCode) {
    this.zonalCode = zonalCode;
    }

    public String getState() {
    return state;
    }

    public void setState(String state) {
    this.state = state;
    }

    public String getErrorMessage() {
    return errorMessage;
    }

    public void setErrorMessage(String errorMessage) {
    this.errorMessage = errorMessage;
    }

    @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”)
    public Date getStartTime() {
    return startTime;
    }

    public void setStartTime(Date startTime) {
    this.startTime = startTime;
    }

    @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”)
    public Date getEndTime() {
    return endTime;
    }

    public void setEndTime(Date endTime) {
    this.endTime = endTime;
    }

    public Integer getFactorType() {
    return factorType;
    }

    public void setFactorType(Integer factorType) {
    this.factorType = factorType;
    }

    public String getZonalName() {
    return zonalName;
    }

    public void setZonalName(String zonalName) {
    this.zonalName = zonalName;
    }

    public String getBasincode() {
    return basincode;
    }

    public void setBasincode(String basincode) {
    this.basincode = basincode;
    }

    public String getBasinname() {
    return basinname;
    }

    public void setBasinname(String basinname) {
    this.basinname = basinname;
    }

}

package com.jeeplus.modules.analysis.entity;

import com.jeeplus.core.persistence.DataEntity;

import java.util.List;

/**

  • @author zb

  • A因子计算任务发布的影像表
    */
    public class AFactorPlanGeo extends DataEntity{

    /**

    */
    private static final long serialVersionUID = 1L;

    /**

    • A因子任务表
      /
      private String aFactorPlanId;
      /
      *
    • 范围
      /
      private String scope;
      /
      *
    • 编码
      /
      private String zonalCode;
      /
      *
    • 任务类型(“即时”、“周期”)
      /
      private String planType;
      /
      *
    • 任务名称(采用任务发布时间字符串)
      */
      private String planName;

    /**

    • 因子类型
      /
      private Integer factorType;
      /
      *
    • geoserver 工作区
      */
      private String geoWs;

    /**

    • geoserver 图层名
      */
      private String geoName;

    /**

    • tif文件路径
      */
      private String filePath;

    /**

    • tif图层样式文件名
      */
      private String styleName;

    /**

    • 用户包含的区域集合
      */
      private List areaCodes;

    private boolean success = true;// 是否成功
    private String msg = “操作成功”;// 提示信息

    public boolean isSuccess() {
    return success;
    }

    public void setSuccess(boolean success) {
    this.success = success;
    }

    public String getMsg() {
    return msg;
    }

    public void setMsg(String msg) {
    this.msg = msg;
    }

    public List getAreaCodes() {
    return areaCodes;
    }

    public void setAreaCodes(List areaCodes) {
    this.areaCodes = areaCodes;
    }

    public String getFilePath() {
    return filePath;
    }

    public void setFilePath(String filePath) {
    this.filePath = filePath;
    }

    public String getStyleName() {
    return styleName;
    }

    public void setStyleName(String styleName) {
    this.styleName = styleName;
    }

    public String getAFactorPlanId() {
    return aFactorPlanId;
    }

    public void setAFactorPlanId(String aFactorPlanId) {
    this.aFactorPlanId = aFactorPlanId;
    }

    public Integer getFactorType() {
    return factorType;
    }

    public void setFactorType(Integer factorType) {
    this.factorType = factorType;
    }

    public String getGeoWs() {
    return geoWs;
    }

    public void setGeoWs(String geoWs) {
    this.geoWs = geoWs;
    }

    public String getGeoName() {
    return geoName;
    }

    public void setGeoName(String geoName) {
    this.geoName = geoName;
    }

    public String getPlanType() {
    return planType;
    }

    public void setPlanType(String planType) {
    this.planType = planType;
    }

    public String getPlanName() {
    return planName;
    }

    public void setPlanName(String planName) {
    this.planName = planName;
    }

    public String getScope() {
    return scope;
    }

    public void setScope(String scope) {
    this.scope = scope;
    }

    public String getZonalCode() {
    return zonalCode;
    }

    public void setZonalCode(String zonalCode) {
    this.zonalCode = zonalCode;
    }
    }
    package com.jeeplus.modules.analysis.dto;

import com.jeeplus.modules.analysis.entity.AFactorPlan;

import java.io.Serializable;

public class GeoPublishEntity implements Serializable {

private static final long serialVersionUID = 1L;
/**
 * 任务ID
 */
private String aFactorPlanId;
/**
 * 因子类型
 */
private Integer factorType;
/**
 * 文件路径
 */
private String filePath;

/**
 * 图层名称
 */
private String storeName;

/**
 * 样式名称
 */
private String styleName;

/**
 * A计算任务
 */
private AFactorPlan aFactorPlan;
/**
 * 区域编码
 */
private String zonalCode;
private String zonalName;

public String getZonalName() {
    return zonalName;
}

public void setZonalName(String zonalName) {
    this.zonalName = zonalName;
}

public String getZonalCode() {
    return zonalCode;
}

public void setZonalCode(String zonalCode) {
    this.zonalCode = zonalCode;
}

public AFactorPlan getaFactorPlan() {
    return aFactorPlan;
}

public void setaFactorPlan(AFactorPlan aFactorPlan) {
    this.aFactorPlan = aFactorPlan;
}

public String getaFactorPlanId() {
    return aFactorPlanId;
}

public void setaFactorPlanId(String aFactorPlanId) {
    this.aFactorPlanId = aFactorPlanId;
}

public Integer getFactorType() {
    return factorType;
}

public void setFactorType(Integer factorType) {
    this.factorType = factorType;
}

public String getFilePath() {
    return filePath;
}

public void setFilePath(String filePath) {
    this.filePath = filePath;
}

public String getStoreName() {
    return storeName;
}

public void setStoreName(String storeName) {
    this.storeName = storeName;
}

public String getStyleName() {
    return styleName;
}

public void setStyleName(String styleName) {
    this.styleName = styleName;
}

}

4、js代码

<%@ page contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8” %>

<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>
<%@ include file="/webpage/include/taglib.jsp"%>

A因子计算地图 <%@ include file="/webpage/include/bootstraptable.jsp"%>
图例
A-土壤侵蚀模数
<2.0
2<=A<25.0
25.0<=A<50.0
50.0<=A<80.0
80.0<=A<150.0
>150
<%----%>
<%@include file="js/aFactorMap.js" %>

@charset “UTF-8”;
#map {
height: 100%;
width: 100%;
}
#position{
float: right;
position: absolute;
bottom: 70px;
height: 20px;
z-index: 2000;
color: #fff;
right: 80px;
display: block;
}
#scaleLine{
float: left;
position: absolute;
bottom: 40px;
height: 20px;
z-index: 2000;
color: #fff;
right: 200px;
display: block;
}

.navigate-container{
position:fixed;
z-index: 99;
margin-left: 50px;
margin-top: 20px;
}

#right_contont{
width: 340px;
height: auto;
max-height: 100%;
position: fixed;
z-index: 999;
/* background: #fff; */
right: 0;
}

.map-top{
position: absolute;
top: 0;
width: 100%;
left: 0;
text-align: center;
margin: 0;
background: #fff;
z-index: 3000;
}

#bottom_content{
width: 100%;
height: 310px;
position: fixed;
z-index: 2001;
bottom: -285px;
background: #fff;
padding: 0px 3px 3px 3px;
/* overflow-y: scroll; */
}
.bottom_title {
position: relative;
margin: 0 auto;
display: block;
height: 30px;
width: 100%;
}
#bottomBotton{
width: 150px;
display: block;
margin: 0 auto;
}
.bottom_table {
height: 280px;
overflow-y: scroll;
position:relative;
}
.bottom_table_refresh{
position:absolute;
z-index: 2;
top: 1px;
right: 5px;
}
#aFactorTaskTable .dropdown-menu {
position:relative;
}
#aFactorTaskTable .dropdown-menu > li {
list-style: none;
position: absolute;
top: -34px;
left: -78px;
background: #fff;
width: 150px;
text-align: left;
padding: 2px;
border: #d6d6d6 1px solid;
height: 32px;
line-height: 32px;
}
.fixed-table-body {
overflow: visible;
}
#aFactorTaskTable .dropdown-menu > li > a {
padding: 3px 5px;
}

    html {
        font-size:14px;
    }
    #body-container {
        margin-left: 0px !important;
        margin-top: 0px !important;
        padding: 0px;
        overflow-x: hidden !important;
        transition: all 0.2s ease-in-out !important;
        height: 100% !important;
    }
    .map {
        height: 100%;
        width: 100%;
        margin: 0;
        padding: 0;
    }
    
    .layui-layer {
        right:5px;
        left: initial;
    }
    
    .layui-layim-close .layui-layer-content span {
        width: auto;
        max-width: 120px;
    }
    
    .layim-chat-list li span, .layui-layim-min .layui-layer-content span {
        width: 100px;
        padding-left: 10px;
        font-size: 16px;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
    }
    
    body .layui-layim-min {
        border: 1px solid #D9D9D9;
    }
    
    .layui-layim-min .layui-layer-content {
        margin: 0 5px;
        padding: 5px 10px;
        white-space: nowrap;
    }
    
    .layim-chat-list li, .layui-layim-min .layui-layer-content {
        position: relative;
        margin: 5px;
        padding: 5px 30px 5px 5px;
        line-height: 40px;
        cursor: pointer;
        border-radius: 3px;
    }
    
    .layui-nav-child {
        top: auto;
        bottom: 40px;
    }
    
    .layui-bg-tl {
        background: #F5F5F5 !important;
    }
    
    .layui-nav .layui-nav-item a {
        color: #000;
    }
    
    .layui-nav .layui-nav-item a:hover {
        color: #000;
    }
    
    .layui-nav-child dd {
        line-height: 36px;
    }
    
    .layui-nav .layui-nav-item {
        line-height: 45px;
    }
    
    .layui-input-inline {
        height: 38px;
    }
    
    .layui-form-item .layui-input-inline {
        width: 100%;
    }
    
    .well {
        padding: 5px;
    }
    
    .form-horizontal {
        margin: 0;
    }
    
    .ol-popup {
        position: absolute;
        background-color: white;
        -webkit-filter: drop-shadow(0 1px 4px rgba(0,0,0,0.2));
        filter: drop-shadow(0 1px 4px rgba(0,0,0,0.2));
        padding: 5px;
        border-radius: 10px;
        border: 1px solid #cccccc;
        bottom: 12px;
        left: -50px;
        width: auto;
        min-width: 500px;
    }
    .ol-popup:after, .ol-popup:before {
        top: 100%;
        border: solid transparent;
        content: " ";
        height: 0;
        width: 0;
        position: absolute;
        pointer-events: none;
    }
    .ol-popup:after {
        border-top-color: white;
        border-width: 10px;
        left: 48px;
        margin-left: -10px;
    }
    .ol-popup:before {
        border-top-color: #cccccc;
        border-width: 11px;
        left: 48px;
        margin-left: -11px;
    }
    .ol-popup-closer {
        text-decoration: none;
        position: absolute;
        top: 2px;
        right: 8px;
    }
    .ol-popup-closer:after {
        content: "✖";
    }
    .popup-content > div{
        /* border: 1px solid #d6d6d6; */
    }
    
    .popup-content > div > div{
        border-bottom : 1px solid #d6d6d6;
        line-height: 1.5rem;
    }
    .popup-content > div > div:last-child{
        border-bottom : none;
    }
    
    .popup-content > fieldset{
        border: 1px solid #d6d6d6;
        padding: .25em;
        margin: .25rem;
        border: 1px solid silver;
    }
    legend {
        display: block;
        width: 100%;
        padding: 0;
        margin-bottom: 0;
        line-height: inherit;
        padding: .5em;
        padding-bottom: 0;
        border: 0;
        width: auto;
        font-size: 16px;
        webkit-box-sizing: border-box;
        box-sizing: border-box;
        color: inherit;
        display: table;
        max-width: 100%;
        white-space: normal;
     }
    
    .popup-content > fieldset > div{
        border-bottom : 1px solid #d6d6d6;
        line-height: 1.5rem;
        width: 250px;
        max-height: 125px;
        text-overflow: ellipsis;
        display: -webkit-box;
        -webkit-box-orient: vertical;
        -webkit-line-clamp: 5;
        overflow: hidden;
    }
    .popup-content > fieldset > div:last-child{
        border-bottom : none;
    }
    .layui-colla-content {
        padding: 0;
    }
    
    .spc{width: 100%;background-color: red;}
    .sp{
        display: inline-block;
    }
    .main-container {
        height: 100% !important;
        overflow-y: scroll;
    }
    .page-content form table tr td > a.btn {
        padding:0 .25rem;
    }
    .table > thead > tr {
        background: #e3f2ff !important;
    }
    .animation {
        position: absolute;
        top: 0;
        right: 0;
        width: 20rem;
        background: #fff;
    }
    .animation .container{
      display: flex;width:100%;
    }
    .animation .container > label{
        display: inline-block;
        margin: 0;
        width: 5rem;
        padding-top: .25rem;
    }
    .animation .container > button{
        background: #69aab8;
        border: 1px #fff solid;
        border-radius: .3rem;
        height: 30px;
        width: 13rem;
    }
    
    .layui-table td, .layui-table th {
	    position: relative;
       /* padding: 2px !important;*/
	    min-height: 20px;
	    line-height: 20px;
	    font-size: 14px;
	   /* border:unset;*/
	}

    .layui-table-search td, .layui-table-search th{
        padding: 2px !important;
        border:unset;
    }
    .input-group .input-group-btn .btn {
        width: 35px;
        height: 32px;
    }
	
	.layui-tab-content{
		padding: 5px 5px !important;
		background-color: #ffffff;
	}
	.layui-tab-title .layui-this{
	   color:#1890ff !important;
	}
	.search-botton{
	    position: absolute;
	    top: 1px;
	    right: 5px;
	}
	.shenSuo-botton{
	    position: absolute;
	    left: 0;
	    top: 0;
	    color: #666666;
	}
	.shenSuo-botton:hover {
	   color: #1890ff;
	}

.container{
position:relative;
display:block;
height:100%;
width:100%;
}
.ant-layout-footer, .ant-layout-header {
flex: 0 0 auto;
}
.ant-layout-header {
height: 64px;
padding: 0 50px;
line-height: 64px;
background: #001529;
}
.header___1fxJP {
height: 24px;
line-height: 24px;
font-size: 18px;
margin: 10px 20px 0 10px;
background-color: transparent;
padding: 0;
}

.tl-container{
z-index: 5;
position: absolute;
bottom: 20px;
left: 0;
width: 400px;
height: 250px;
color: #fff;
background-color: rgba(0,0,0,.55);
overflow: hidden;
}
.row___2TQGG {
line-height: 28px;
margin: 0 20px;
}
.ant-row {
position: relative;
height: auto;
zoom: 1;
display: block;
box-sizing: border-box;
}
.ant-col-12{
display:block;
width:50%;
box-sizing: border-box;
flex: 0 0 auto;
float: left;
margin: 0;
color: #fff;
font-size: 14px;
}
.anticon[tabindex] {
cursor: pointer;
}
.container___2rQsv {
z-index: 5;
position: absolute;
bottom: 40px;
left: 20px;
display: none;
}
.ant-btn {
line-height: 1.499;
position: relative;
display: inline-block;
font-weight: 400;
white-space: nowrap;
text-align: center;
background-image: none;
box-shadow: 0 2px 0 rgba(0,0,0,.015);
cursor: pointer;
transition: all .3s cubic-bezier(.645,.045,.355,1);
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
touch-action: manipulation;
height: 32px;
padding: 0 15px;
font-size: 14px;
border-radius: 4px;
color: rgba(0,0,0,.65);
background-color: #fff;
border: 1px solid #d9d9d9;
}
.anticon {
display: inline-block;
color: inherit;
font-style: normal;
line-height: 0;
text-align: center;
text-transform: none;
vertical-align: -.125em;
text-rendering: optimizeLegibility;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
.ant-btn-primary {
color: #fff;
background-color: #1890ff;
border-color: #1890ff;
text-shadow: 0 -1px 0 rgba(0,0,0,.12);
box-shadow: 0 2px 0 rgba(0,0,0,.045);
}
.ant-btn, .ant-btn:active, .ant-btn:focus {
outline: 0;
}

.ant-btn-circle, .ant-btn-circle-outline {
width: 32px;
height: 32px;
padding: 0;
font-size: 16px;
border-radius: 50%;
}

你可能感兴趣的:(java,geoserver)