dzhh-backend/.svn/pristine/b2/b28e2e31cbe81b19ea2b50cfac3091d16edf8561.svn-base

package org.jeecg.modules.demo.hzz.shjsgc.xmrk.controller;

import org.jeecg.common.aspect.annotation.PermissionData;
import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;

import org.jeecg.modules.demo.hzz.shjsgc.xmrk.entity.*;
import org.jeecg.modules.demo.untils.pdjwd;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;

import java.util.*;

import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmAxxmxxService;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmAxzyxmbService;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmAxhdzyzbService;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmAxshbfgcxxbService;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmAxshgczyzbbService;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmAxfxjszycgbService;
import org.jeecg.modules.demo.hzz.shjsgc.xmrk.service.IRmYxqkService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import java.io.IOException;
import java.util.stream.Collectors;

/**
 * @Description: 项目信息
 * @Author: jeecg-boot
 * @Date: 2022-03-31
 * @Version: V1.0
 */
@Api(tags = "项目信息")
@RestController
@RequestMapping("/hzz.shjsgc.xmrk/rmAxxmxx")
@Slf4j
public class RmAxxmxxController extends JeecgController<RmAxxmxx, IRmAxxmxxService> {
    @Autowired
    private org.jeecg.modules.demo.untils.zbzh zbzh;
    @Autowired
    private IRmAxxmxxService rmAxxmxxService;

    @Autowired
    private IRmAxzyxmbService rmAxzyxmbService;

    @Autowired
    private IRmAxhdzyzbService rmAxhdzyzbService;

    @Autowired
    private IRmAxshbfgcxxbService rmAxshbfgcxxbService;

    @Autowired
    private IRmAxshgczyzbbService rmAxshgczyzbbService;

    @Autowired
    private IRmAxfxjszycgbService rmAxfxjszycgbService;

    @Autowired
    private IRmYxqkService rmYxqkService;
    @Autowired
    private org.jeecg.modules.demo.untils.geoinfo geoinfo;



    /*---------------------------------主表处理-begin-------------------------------------*/

    /**
     * 分页列表查询
     *
     * @param rmAxxmxx
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    @AutoLog(value = "项目信息-分页列表查询")
    @ApiOperation(value = "项目信息-分页列表查询", notes = "项目信息-分页列表查询")
    @GetMapping(value = "/list")
    @PermissionData(pageComponent = "hzz/shjsgc/xmrk/RmAxxmxxList")
    public Result<?> queryPageList(RmAxxmxx rmAxxmxx,
                                   @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                   @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<RmAxxmxx> queryWrapper = QueryGenerator.initQueryWrapper(rmAxxmxx, req.getParameterMap());
        Page<RmAxxmxx> page = new Page<RmAxxmxx>(pageNo, pageSize);

        IPage<RmAxxmxx> pageList = rmAxxmxxService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmAxxmxx
     * @return
     */
    @AutoLog(value = "项目信息-添加")
    @ApiOperation(value = "项目信息-添加", notes = "项目信息-添加")
    @PostMapping(value = "/add")
    public Result<?> add(@RequestBody RmAxxmxx rmAxxmxx) {
        rmAxxmxxService.save(rmAxxmxx);
        if (rmAxxmxx.getZzb() != null && rmAxxmxx.getHzb() != null) {
            generateGeom2(rmAxxmxx);
            String geojson = rmAxxmxxService.getGeojson(rmAxxmxx.getId());
            System.out.println(geojson);
            rmAxxmxx.setGeoinfo(geojson);
			/*Double zzb = rmAxxmxx.getZzb();
			Double hzb = rmAxxmxx.getHzb();
			String geoinfo = this.geoinfo.geoinfo(String.valueOf(hzb), String.valueOf(zzb));
			rmAxxmxx.setGeoinfo(geoinfo);*/
        }
        rmAxxmxxService.saveOrUpdate(rmAxxmxx);
        rmAxxmxxService.insertShxmxx(rmAxxmxx.getId(), rmAxxmxx.getXmmc(), rmAxxmxx.getJszt());
        rmAxxmxxService.insetXmxx(rmAxxmxx);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmAxxmxx
     * @return
     */
    @AutoLog(value = "项目信息-编辑")
    @ApiOperation(value = "项目信息-编辑", notes = "项目信息-编辑")
    @PostMapping(value = "/edit")
    public Result<?> edit(@RequestBody RmAxxmxx rmAxxmxx) {
		/*Double zzb = rmAxxmxx.getZzb();
		Double hzb = rmAxxmxx.getHzb();
		updateGeom2(rmAxxmxx);
		String geoinfo = this.geoinfo.geoinfo(String.valueOf(hzb), String.valueOf(zzb));
		rmAxxmxx.setGeoinfo(geoinfo);*/
        rmAxxmxxService.updateById(rmAxxmxx);
        int number = rmAxxmxxService.selectXmxxByid(rmAxxmxx.getId());
        if (number == 0) {
            if (rmAxxmxx.getZzb() != null && rmAxxmxx.getHzb() != null) {
                generateGeom2(rmAxxmxx);
                String geojson = rmAxxmxxService.getGeojson(rmAxxmxx.getId());
                rmAxxmxx.setGeoinfo(geojson);
            }
        } else {
            if (rmAxxmxx.getZzb() != null && rmAxxmxx.getHzb() != null) {
                updateGeom2(rmAxxmxx);
                String geojson = rmAxxmxxService.getGeojson(rmAxxmxx.getId());
                rmAxxmxx.setGeoinfo(geojson);
            }
        }
        rmAxxmxxService.saveOrUpdate(rmAxxmxx);
        rmAxxmxxService.updateShxmxx(rmAxxmxx.getXmmc(), rmAxxmxx.getJszt(), rmAxxmxx.getId());

        rmAxxmxxService.updateXmxx(rmAxxmxx);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "项目信息-通过id删除")
    @ApiOperation(value = "项目信息-通过id删除", notes = "项目信息-通过id删除")
    @PostMapping(value = "/delete")
    public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
        rmAxxmxxService.delMain(id);
        rmAxxmxxService.deletexmxx(id);
        rmAxxmxxService.deleteshxmxx(id);
        rmAxxmxxService.delxmxx(id);
        return Result.OK("删除成功!");
    }

    /**
     * 通过id查询项目信息
     *
     * @param id
     * @return
     */
    @AutoLog(value = "项目信息-通过id查询项目信息")
    @ApiOperation(value = "项目信息-通过id查询项目信息", notes = "项目信息-通过id查询项目信息")
    @GetMapping(value = "/selectByid")
    public Result<?> selectByid(@RequestParam(name = "id", required = true) String id) {
        RmAxxmxx rmAxxmxx = rmAxxmxxService.getById(id);
        return Result.OK("查询成功!", rmAxxmxx);
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "项目信息-批量删除")
    @ApiOperation(value = "项目信息-批量删除", notes = "项目信息-批量删除")
    @PostMapping(value = "/deleteBatch")
    public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        this.rmAxxmxxService.delBatchMain(Arrays.asList(ids.split(",")));
       /* List<String> strings = Arrays.asList(ids.split(","));
        for (String id : strings) {
            rmAxxmxxService.deletexmxx(id);
            rmAxxmxxService.deleteshxmxx(id);
            rmAxxmxxService.delxmxx(id);
        }*/
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, RmAxxmxx rmAxxmxx) {
        return super.exportXls(request, rmAxxmxx, RmAxxmxx.class, "项目信息");
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmAxxmxx> list = ExcelImportUtil.importExcel(file.getInputStream(), RmAxxmxx.class, params);
                //update-begin-author:taoyan date:20190528 for:批量插入数据
                long start = System.currentTimeMillis();
                for (RmAxxmxx rmAxxmxx : list) {
                    rmAxxmxx.setId(UUID.randomUUID().toString().replace("-", ""));
                    rmAxxmxxService.insetXmxx(rmAxxmxx);
                    if (rmAxxmxx.getZzb() != null && rmAxxmxx.getHzb() != null) {
                        generateGeom2(rmAxxmxx);
                        String geojson = rmAxxmxxService.getGeojson(rmAxxmxx.getId());
                        rmAxxmxx.setGeoinfo(geojson);
                    }
                }
                rmAxxmxxService.saveBatch(list);
                //400条 saveBatch消耗时间1592毫秒  循环插入消耗时间1947毫秒
                //1200条  saveBatch消耗时间3687毫秒 循环插入消耗时间5212毫秒
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                //update-end-author:taoyan date:20190528 for:批量插入数据
                return Result.ok("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }
    /*---------------------------------主表处理-end-------------------------------------*/


    /*--------------------------------子表处理-单位信息-begin----------------------------------------------*/

    /**
     * 通过主表ID查询
     *
     * @return
     */
    @AutoLog(value = "单位信息-通过主表ID查询")
    @ApiOperation(value = "单位信息-通过主表ID查询", notes = "单位信息-通过主表ID查询")
    @GetMapping(value = "/listRmAxzyxmbByMainId")
    public Result<?> listRmAxzyxmbByMainId(RmAxzyxmb rmAxzyxmb,
                                           @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                           @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                           HttpServletRequest req) {
        QueryWrapper<RmAxzyxmb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxzyxmb, req.getParameterMap());
        Page<RmAxzyxmb> page = new Page<RmAxzyxmb>(pageNo, pageSize);
        IPage<RmAxzyxmb> pageList = rmAxzyxmbService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmAxzyxmb
     * @return
     */
    @AutoLog(value = "单位信息-添加")
    @ApiOperation(value = "单位信息-添加", notes = "单位信息-添加")
    @PostMapping(value = "/addRmAxzyxmb")
    public Result<?> addRmAxzyxmb(@RequestBody RmAxzyxmb rmAxzyxmb) {
        rmAxzyxmbService.save(rmAxzyxmb);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmAxzyxmb
     * @return
     */
    @AutoLog(value = "单位信息-编辑")
    @ApiOperation(value = "单位信息-编辑", notes = "单位信息-编辑")
    @PostMapping(value = "/editRmAxzyxmb")
    public Result<?> editRmAxzyxmb(@RequestBody RmAxzyxmb rmAxzyxmb) {
        rmAxzyxmbService.updateById(rmAxzyxmb);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "单位信息-通过id删除")
    @ApiOperation(value = "单位信息-通过id删除", notes = "单位信息-通过id删除")
    @PostMapping(value = "/deleteRmAxzyxmb")
    public Result<?> deleteRmAxzyxmb(@RequestParam(name = "id", required = true) String id) {
        rmAxzyxmbService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "单位信息-批量删除")
    @ApiOperation(value = "单位信息-批量删除", notes = "单位信息-批量删除")
    @PostMapping(value = "/deleteBatchRmAxzyxmb")
    public Result<?> deleteBatchRmAxzyxmb(@RequestParam(name = "ids", required = true) String ids) {
        this.rmAxzyxmbService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportRmAxzyxmb")
    public ModelAndView exportRmAxzyxmb(HttpServletRequest request, RmAxzyxmb rmAxzyxmb) {
        // Step.1 组装查询条件
        QueryWrapper<RmAxzyxmb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxzyxmb, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<RmAxzyxmb> pageList = rmAxzyxmbService.list(queryWrapper);
        List<RmAxzyxmb> exportList = null;

        // 过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
        } else {
            exportList = pageList;
        }

        // Step.3 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "单位信息"); //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.CLASS, RmAxzyxmb.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("单位信息报表", "导出人:" + sysUser.getRealname(), "单位信息"));
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
        return mv;
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importRmAxzyxmb/{mainId}")
    public Result<?> importRmAxzyxmb(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmAxzyxmb> list = ExcelImportUtil.importExcel(file.getInputStream(), RmAxzyxmb.class, params);
                for (RmAxzyxmb temp : list) {
                    temp.setMainId(mainId);
                }
                long start = System.currentTimeMillis();
                rmAxzyxmbService.saveBatch(list);
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                return Result.OK("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-单位信息-end----------------------------------------------*/

    /*--------------------------------子表处理-河段主要指标-begin----------------------------------------------*/

    /**
     * 通过主表ID查询
     *
     * @return
     */
    @AutoLog(value = "河段主要指标-通过主表ID查询")
    @ApiOperation(value = "河段主要指标-通过主表ID查询", notes = "河段主要指标-通过主表ID查询")
    @GetMapping(value = "/listRmAxhdzyzbByMainId")
    public Result<?> listRmAxhdzyzbByMainId(RmAxhdzyzb rmAxhdzyzb,
                                            @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                            @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                            HttpServletRequest req) {
        QueryWrapper<RmAxhdzyzb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxhdzyzb, req.getParameterMap());
        Page<RmAxhdzyzb> page = new Page<RmAxhdzyzb>(pageNo, pageSize);
        IPage<RmAxhdzyzb> pageList = rmAxhdzyzbService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmAxhdzyzb
     * @return
     */
    @AutoLog(value = "河段主要指标-添加")
    @ApiOperation(value = "河段主要指标-添加", notes = "河段主要指标-添加")
    @PostMapping(value = "/addRmAxhdzyzb")
    public Result<?> addRmAxhdzyzb(@RequestBody RmAxhdzyzb rmAxhdzyzb) {

        rmAxhdzyzbService.save(rmAxhdzyzb);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmAxhdzyzb
     * @return
     */
    @AutoLog(value = "河段主要指标-编辑")
    @ApiOperation(value = "河段主要指标-编辑", notes = "河段主要指标-编辑")
    @PostMapping(value = "/editRmAxhdzyzb")
    public Result<?> editRmAxhdzyzb(@RequestBody RmAxhdzyzb rmAxhdzyzb) {
        rmAxhdzyzbService.updateById(rmAxhdzyzb);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "河段主要指标-通过id删除")
    @ApiOperation(value = "河段主要指标-通过id删除", notes = "河段主要指标-通过id删除")
    @PostMapping(value = "/deleteRmAxhdzyzb")
    public Result<?> deleteRmAxhdzyzb(@RequestParam(name = "id", required = true) String id) {
        rmAxhdzyzbService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "河段主要指标-批量删除")
    @ApiOperation(value = "河段主要指标-批量删除", notes = "河段主要指标-批量删除")
    @PostMapping(value = "/deleteBatchRmAxhdzyzb")
    public Result<?> deleteBatchRmAxhdzyzb(@RequestParam(name = "ids", required = true) String ids) {
        this.rmAxhdzyzbService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportRmAxhdzyzb")
    public ModelAndView exportRmAxhdzyzb(HttpServletRequest request, RmAxhdzyzb rmAxhdzyzb) {
        // Step.1 组装查询条件
        QueryWrapper<RmAxhdzyzb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxhdzyzb, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<RmAxhdzyzb> pageList = rmAxhdzyzbService.list(queryWrapper);
        List<RmAxhdzyzb> exportList = null;

        // 过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
        } else {
            exportList = pageList;
        }

        // Step.3 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "河段主要指标"); //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.CLASS, RmAxhdzyzb.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("河段主要指标报表", "导出人:" + sysUser.getRealname(), "河段主要指标"));
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
        return mv;
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importRmAxhdzyzb/{mainId}")
    public Result<?> importRmAxhdzyzb(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmAxhdzyzb> list = ExcelImportUtil.importExcel(file.getInputStream(), RmAxhdzyzb.class, params);
                for (RmAxhdzyzb temp : list) {
                    temp.setMainId(mainId);
                }
                long start = System.currentTimeMillis();
                rmAxhdzyzbService.saveBatch(list);
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                return Result.OK("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-河段主要指标-end----------------------------------------------*/

    /*--------------------------------子表处理-涉河部分工程信息-begin----------------------------------------------*/

    /**
     * 通过主表ID查询
     *
     * @return
     */
    @AutoLog(value = "涉河部分工程信息-通过主表ID查询")
    @ApiOperation(value = "涉河部分工程信息-通过主表ID查询", notes = "涉河部分工程信息-通过主表ID查询")
    @GetMapping(value = "/listRmAxshbfgcxxbByMainId")
    public Result<?> listRmAxshbfgcxxbByMainId(RmAxshbfgcxxb rmAxshbfgcxxb,
                                               @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                               @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                               HttpServletRequest req) {
        QueryWrapper<RmAxshbfgcxxb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxshbfgcxxb, req.getParameterMap());
        Page<RmAxshbfgcxxb> page = new Page<RmAxshbfgcxxb>(pageNo, pageSize);
        IPage<RmAxshbfgcxxb> pageList = rmAxshbfgcxxbService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmAxshbfgcxxb
     * @return
     */
    @AutoLog(value = "涉河部分工程信息-添加")
    @ApiOperation(value = "涉河部分工程信息-添加", notes = "涉河部分工程信息-添加")
    @PostMapping(value = "/addRmAxshbfgcxxb")
    public Result<?> addRmAxshbfgcxxb(@RequestBody RmAxshbfgcxxb rmAxshbfgcxxb) {
        rmAxshbfgcxxbService.save(rmAxshbfgcxxb);
//		String main_id = rmAxshbfgcxxbService.selectXmxx(rmAxshbfgcxxb.getId());
//		String gcmc = rmAxshbfgcxxb.getGcmc();
//		String sjhd = rmAxshbfgcxxb.getSjhd();
//		rmAxshbfgcxxbService.insertHdzyzb(UUID.randomUUID().toString().replace("-", ""),sjhd,main_id);
//		String id = UUID.randomUUID().toString().replace("-", "");
//		rmAxshbfgcxxbService.insertFxJscg(id,gcmc,main_id);
        String geoinfo = null;
        try {
            generateGeom(rmAxshbfgcxxb);
            geoinfo = rmAxshbfgcxxbService.getGeojson(rmAxshbfgcxxb.getId());
            rmAxshbfgcxxb.setGeoinfo(geoinfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        rmAxshbfgcxxbService.saveOrUpdate(rmAxshbfgcxxb);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmAxshbfgcxxb
     * @return
     */
    @AutoLog(value = "涉河部分工程信息-编辑")
    @ApiOperation(value = "涉河部分工程信息-编辑", notes = "涉河部分工程信息-编辑")
    @PostMapping(value = "/editRmAxshbfgcxxb")
    public Result<?> editRmAxshbfgcxxb(@RequestBody RmAxshbfgcxxb rmAxshbfgcxxb) {
        String geoinfo = null;
        if (rmAxshbfgcxxb.getJd() != null && rmAxshbfgcxxb.getWd() != null) {
            updateGeom(rmAxshbfgcxxb);
            geoinfo = rmAxshbfgcxxbService.getGeojson(rmAxshbfgcxxb.getId());
            rmAxshbfgcxxb.setGeoinfo(geoinfo);
        }
        rmAxshbfgcxxb.setGeoinfo(geoinfo);
        rmAxshbfgcxxbService.updateById(rmAxshbfgcxxb);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "涉河部分工程信息-通过id删除")
    @ApiOperation(value = "涉河部分工程信息-通过id删除", notes = "涉河部分工程信息-通过id删除")
    @PostMapping(value = "/deleteRmAxshbfgcxxb")
    public Result<?> deleteRmAxshbfgcxxb(@RequestParam(name = "id", required = true) String id) {
        rmAxshbfgcxxbService.removeById(id);
        rmAxshbfgcxxbService.delshbfgc(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "涉河部分工程信息-批量删除")
    @ApiOperation(value = "涉河部分工程信息-批量删除", notes = "涉河部分工程信息-批量删除")
    @PostMapping(value = "/deleteBatchRmAxshbfgcxxb")
    public Result<?> deleteBatchRmAxshbfgcxxb(@RequestParam(name = "ids", required = true) String ids) {
        this.rmAxshbfgcxxbService.removeByIds(Arrays.asList(ids.split(",")));
        List<String> gspIds = Arrays.asList(ids.split(","));
        for (int i = 0; i < gspIds.size(); i++) {
            rmAxshbfgcxxbService.delshbfgc(gspIds.get(i));
        }
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportRmAxshbfgcxxb")
    public ModelAndView exportRmAxshbfgcxxb(HttpServletRequest request, RmAxshbfgcxxb rmAxshbfgcxxb) {
        // Step.1 组装查询条件
        QueryWrapper<RmAxshbfgcxxb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxshbfgcxxb, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<RmAxshbfgcxxb> pageList = rmAxshbfgcxxbService.list(queryWrapper);
        List<RmAxshbfgcxxb> exportList = null;

        // 过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
        } else {
            exportList = pageList;
        }

        // Step.3 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "涉河部分工程信息"); //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.CLASS, RmAxshbfgcxxb.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("涉河部分工程信息报表", "导出人:" + sysUser.getRealname(), "涉河部分工程信息"));
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
        return mv;
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importRmAxshbfgcxxb/{mainId}")
    public Result<?> importRmAxshbfgcxxb(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        String geoinfo = null;
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmAxshbfgcxxb> list = ExcelImportUtil.importExcel(file.getInputStream(), RmAxshbfgcxxb.class, params);
                for (RmAxshbfgcxxb temp : list) {
                    temp.setMainId(mainId);
                    temp.setId(UUID.randomUUID().toString().replace("-", ""));
                    generateGeom(temp);
                    geoinfo = rmAxshbfgcxxbService.getGeojson(temp.getId());
                    temp.setGeoinfo(geoinfo);
                }
                long start = System.currentTimeMillis();
                rmAxshbfgcxxbService.saveBatch(list);

                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                return Result.OK("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-涉河部分工程信息-end----------------------------------------------*/

    /*--------------------------------子表处理-涉河工程主要指标表-begin----------------------------------------------*/

    /**
     * 通过主表ID查询
     *
     * @return
     */
    @AutoLog(value = "涉河工程主要指标表-通过主表ID查询")
    @ApiOperation(value = "涉河工程主要指标表-通过主表ID查询", notes = "涉河工程主要指标表-通过主表ID查询")
    @GetMapping(value = "/listRmAxshgczyzbbByMainId")
    public Result<?> listRmAxshgczyzbbByMainId(RmAxshgczyzbb rmAxshgczyzbb,
                                               @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                               @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                               HttpServletRequest req) {
        QueryWrapper<RmAxshgczyzbb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxshgczyzbb, req.getParameterMap());
        Page<RmAxshgczyzbb> page = new Page<RmAxshgczyzbb>(pageNo, pageSize);
        IPage<RmAxshgczyzbb> pageList = rmAxshgczyzbbService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmAxshgczyzbb
     * @return
     */
    @AutoLog(value = "涉河工程主要指标表-添加")
    @ApiOperation(value = "涉河工程主要指标表-添加", notes = "涉河工程主要指标表-添加")
    @PostMapping(value = "/addRmAxshgczyzbb")
    public Result<?> addRmAxshgczyzbb(@RequestBody RmAxshgczyzbb rmAxshgczyzbb) {
        if (rmAxshgczyzbb.getRtqdhzb() != null && rmAxshgczyzbb.getRtqdzzb() != null) {
            String rtqdhzb = rmAxshgczyzbb.getRtqdhzb().toString();
            String rtqdzzb = rmAxshgczyzbb.getRtqdzzb().toString();
            String geoinfo = this.geoinfo.geoinfo(rtqdhzb, rtqdzzb);
            rmAxshgczyzbb.setGeoinfo(geoinfo);
        } else if (rmAxshgczyzbb.getRtqdhzb() != null && rmAxshgczyzbb.getRtqdzzb() != null
                && rmAxshgczyzbb.getCtzdhzb() != null && rmAxshgczyzbb.getCtzdzzb() != null) {
            String rtqdhzb = rmAxshgczyzbb.getRtqdhzb().toString();
            String rtqdzzb = rmAxshgczyzbb.getRtqdzzb().toString();
            String Ctzdhzb = rmAxshgczyzbb.getCtzdhzb().toString();
            String Ctzdzzb = rmAxshgczyzbb.getCtzdzzb().toString();
            String geoinfo = this.geoinfo.geoinfo(rtqdhzb + "," + Ctzdhzb, rtqdzzb + "," + Ctzdzzb);
            rmAxshgczyzbb.setGeoinfo(geoinfo);
        }
        rmAxshgczyzbbService.save(rmAxshgczyzbb);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmAxshgczyzbb
     * @return
     */
    @AutoLog(value = "涉河工程主要指标表-编辑")
    @ApiOperation(value = "涉河工程主要指标表-编辑", notes = "涉河工程主要指标表-编辑")
    @PostMapping(value = "/editRmAxshgczyzbb")
    public Result<?> editRmAxshgczyzbb(@RequestBody RmAxshgczyzbb rmAxshgczyzbb) {
	/*	if(jd!=null&&wd!=null){
			String geoinfo = this.geoinfo.geoinfo(jd, wd);
			rmAxshgczyzbb.setGeoinfo(geoinfo);
		}else */
        if (rmAxshgczyzbb.getRtqdhzb() != null && rmAxshgczyzbb.getRtqdzzb() != null &&
                rmAxshgczyzbb.getCtzdhzb() == null && rmAxshgczyzbb.getCtzdzzb() == null) {
            String rtqdhzb = rmAxshgczyzbb.getRtqdhzb().toString();
            String rtqdzzb = rmAxshgczyzbb.getRtqdzzb().toString();
            String geoinfo = this.geoinfo.geoinfo(rtqdhzb, rtqdzzb);
            rmAxshgczyzbb.setGeoinfo(geoinfo);
        } else if (rmAxshgczyzbb.getRtqdhzb() != null && rmAxshgczyzbb.getRtqdzzb() != null
                && rmAxshgczyzbb.getCtzdhzb() != null && rmAxshgczyzbb.getCtzdzzb() != null) {
            String rtqdhzb = rmAxshgczyzbb.getRtqdhzb().toString();
            String rtqdzzb = rmAxshgczyzbb.getRtqdzzb().toString();
            String Ctzdhzb = rmAxshgczyzbb.getCtzdhzb().toString();
            String Ctzdzzb = rmAxshgczyzbb.getCtzdzzb().toString();
            String geoinfo = this.geoinfo.geoinfo(rtqdhzb + "," + Ctzdhzb, rtqdzzb + "," + Ctzdzzb);
            rmAxshgczyzbb.setGeoinfo(geoinfo);
        }
        rmAxshgczyzbbService.updateById(rmAxshgczyzbb);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "涉河工程主要指标表-通过id删除")
    @ApiOperation(value = "涉河工程主要指标表-通过id删除", notes = "涉河工程主要指标表-通过id删除")
    @PostMapping(value = "/deleteRmAxshgczyzbb")
    public Result<?> deleteRmAxshgczyzbb(@RequestParam(name = "id", required = true) String id) {
        rmAxshgczyzbbService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "涉河工程主要指标表-批量删除")
    @ApiOperation(value = "涉河工程主要指标表-批量删除", notes = "涉河工程主要指标表-批量删除")
    @PostMapping(value = "/deleteBatchRmAxshgczyzbb")
    public Result<?> deleteBatchRmAxshgczyzbb(@RequestParam(name = "ids", required = true) String ids) {
        this.rmAxshgczyzbbService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportRmAxshgczyzbb")
    public ModelAndView exportRmAxshgczyzbb(HttpServletRequest request, RmAxshgczyzbb rmAxshgczyzbb) {
        // Step.1 组装查询条件
        QueryWrapper<RmAxshgczyzbb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxshgczyzbb, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<RmAxshgczyzbb> pageList = rmAxshgczyzbbService.list(queryWrapper);
        List<RmAxshgczyzbb> exportList = null;

        // 过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
        } else {
            exportList = pageList;
        }

        // Step.3 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "涉河工程主要指标表"); //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.CLASS, RmAxshgczyzbb.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("涉河工程主要指标表报表", "导出人:" + sysUser.getRealname(), "涉河工程主要指标表"));
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
        return mv;
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importRmAxshgczyzbb/{mainId}")
    public Result<?> importRmAxshgczyzbb(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmAxshgczyzbb> list = ExcelImportUtil.importExcel(file.getInputStream(), RmAxshgczyzbb.class, params);
                for (RmAxshgczyzbb temp : list) {
                    temp.setMainId(mainId);
                }
                long start = System.currentTimeMillis();
                rmAxshgczyzbbService.saveBatch(list);
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                return Result.OK("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-涉河工程主要指标表-end----------------------------------------------*/

    /*--------------------------------子表处理-分析计算主要成果-begin----------------------------------------------*/

    /**
     * 通过主表ID查询
     *
     * @return
     */
    @AutoLog(value = "分析计算主要成果-通过主表ID查询")
    @ApiOperation(value = "分析计算主要成果-通过主表ID查询", notes = "分析计算主要成果-通过主表ID查询")
    @GetMapping(value = "/listRmAxfxjszycgbByMainId")
    public Result<?> listRmAxfxjszycgbByMainId(RmAxfxjszycgb rmAxfxjszycgb,
                                               @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                               @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                               HttpServletRequest req) {
        QueryWrapper<RmAxfxjszycgb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxfxjszycgb, req.getParameterMap());
        Page<RmAxfxjszycgb> page = new Page<RmAxfxjszycgb>(pageNo, pageSize);
        IPage<RmAxfxjszycgb> pageList = rmAxfxjszycgbService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmAxfxjszycgb
     * @return
     */
    @AutoLog(value = "分析计算主要成果-添加")
    @ApiOperation(value = "分析计算主要成果-添加", notes = "分析计算主要成果-添加")
    @PostMapping(value = "/addRmAxfxjszycgb")
    public Result<?> addRmAxfxjszycgb(@RequestBody RmAxfxjszycgb rmAxfxjszycgb) {
        rmAxfxjszycgbService.save(rmAxfxjszycgb);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmAxfxjszycgb
     * @return
     */
    @AutoLog(value = "分析计算主要成果-编辑")
    @ApiOperation(value = "分析计算主要成果-编辑", notes = "分析计算主要成果-编辑")
    @PostMapping(value = "/editRmAxfxjszycgb")
    public Result<?> editRmAxfxjszycgb(@RequestBody RmAxfxjszycgb rmAxfxjszycgb) {
        rmAxfxjszycgbService.updateById(rmAxfxjszycgb);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "分析计算主要成果-通过id删除")
    @ApiOperation(value = "分析计算主要成果-通过id删除", notes = "分析计算主要成果-通过id删除")
    @PostMapping(value = "/deleteRmAxfxjszycgb")
    public Result<?> deleteRmAxfxjszycgb(@RequestParam(name = "id", required = true) String id) {
        rmAxfxjszycgbService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "分析计算主要成果-批量删除")
    @ApiOperation(value = "分析计算主要成果-批量删除", notes = "分析计算主要成果-批量删除")
    @PostMapping(value = "/deleteBatchRmAxfxjszycgb")
    public Result<?> deleteBatchRmAxfxjszycgb(@RequestParam(name = "ids", required = true) String ids) {
        this.rmAxfxjszycgbService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportRmAxfxjszycgb")
    public ModelAndView exportRmAxfxjszycgb(HttpServletRequest request, RmAxfxjszycgb rmAxfxjszycgb) {
        // Step.1 组装查询条件
        QueryWrapper<RmAxfxjszycgb> queryWrapper = QueryGenerator.initQueryWrapper(rmAxfxjszycgb, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<RmAxfxjszycgb> pageList = rmAxfxjszycgbService.list(queryWrapper);
        List<RmAxfxjszycgb> exportList = null;

        // 过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
        } else {
            exportList = pageList;
        }

        // Step.3 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "分析计算主要成果"); //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.CLASS, RmAxfxjszycgb.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("分析计算主要成果报表", "导出人:" + sysUser.getRealname(), "分析计算主要成果"));
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
        return mv;
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importRmAxfxjszycgb/{mainId}")
    public Result<?> importRmAxfxjszycgb(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmAxfxjszycgb> list = ExcelImportUtil.importExcel(file.getInputStream(), RmAxfxjszycgb.class, params);
                for (RmAxfxjszycgb temp : list) {
                    temp.setMainId(mainId);
                }
                long start = System.currentTimeMillis();
                rmAxfxjszycgbService.saveBatch(list);
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                return Result.OK("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-分析计算主要成果-end----------------------------------------------*/

    /*--------------------------------子表处理-影响情况及消除或减轻影响措施-begin----------------------------------------------*/

    /**
     * 通过主表ID查询
     *
     * @return
     */
    @AutoLog(value = "影响情况及消除或减轻影响措施-通过主表ID查询")
    @ApiOperation(value = "影响情况及消除或减轻影响措施-通过主表ID查询", notes = "影响情况及消除或减轻影响措施-通过主表ID查询")
    @GetMapping(value = "/listRmYxqkByMainId")
    public Result<?> listRmYxqkByMainId(RmYxqk rmYxqk,
                                        @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                        @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                        HttpServletRequest req) {
        QueryWrapper<RmYxqk> queryWrapper = QueryGenerator.initQueryWrapper(rmYxqk, req.getParameterMap());
        Page<RmYxqk> page = new Page<RmYxqk>(pageNo, pageSize);
        IPage<RmYxqk> pageList = rmYxqkService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param rmYxqk
     * @return
     */
    @AutoLog(value = "影响情况及消除或减轻影响措施-添加")
    @ApiOperation(value = "影响情况及消除或减轻影响措施-添加", notes = "影响情况及消除或减轻影响措施-添加")
    @PostMapping(value = "/addRmYxqk")
    public Result<?> addRmYxqk(@RequestBody RmYxqk rmYxqk) {
        rmYxqkService.save(rmYxqk);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param rmYxqk
     * @return
     */
    @AutoLog(value = "影响情况及消除或减轻影响措施-编辑")
    @ApiOperation(value = "影响情况及消除或减轻影响措施-编辑", notes = "影响情况及消除或减轻影响措施-编辑")
    @PostMapping(value = "/editRmYxqk")
    public Result<?> editRmYxqk(@RequestBody RmYxqk rmYxqk) {
        rmYxqkService.updateById(rmYxqk);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "影响情况及消除或减轻影响措施-通过id删除")
    @ApiOperation(value = "影响情况及消除或减轻影响措施-通过id删除", notes = "影响情况及消除或减轻影响措施-通过id删除")
    @PostMapping(value = "/deleteRmYxqk")
    public Result<?> deleteRmYxqk(@RequestParam(name = "id", required = true) String id) {
        rmYxqkService.removeById(id);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "影响情况及消除或减轻影响措施-批量删除")
    @ApiOperation(value = "影响情况及消除或减轻影响措施-批量删除", notes = "影响情况及消除或减轻影响措施-批量删除")
    @PostMapping(value = "/deleteBatchRmYxqk")
    public Result<?> deleteBatchRmYxqk(@RequestParam(name = "ids", required = true) String ids) {
        this.rmYxqkService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     *
     * @return
     */
    @RequestMapping(value = "/exportRmYxqk")
    public ModelAndView exportRmYxqk(HttpServletRequest request, RmYxqk rmYxqk) {
        // Step.1 组装查询条件
        QueryWrapper<RmYxqk> queryWrapper = QueryGenerator.initQueryWrapper(rmYxqk, request.getParameterMap());
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

        // Step.2 获取导出数据
        List<RmYxqk> pageList = rmYxqkService.list(queryWrapper);
        List<RmYxqk> exportList = null;

        // 过滤选中数据
        String selections = request.getParameter("selections");
        if (oConvertUtils.isNotEmpty(selections)) {
            List<String> selectionList = Arrays.asList(selections.split(","));
            exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
        } else {
            exportList = pageList;
        }

        // Step.3 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        mv.addObject(NormalExcelConstants.FILE_NAME, "影响情况及消除或减轻影响措施"); //此处设置的filename无效 ,前端会重更新设置一下
        mv.addObject(NormalExcelConstants.CLASS, RmYxqk.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("影响情况及消除或减轻影响措施报表", "导出人:" + sysUser.getRealname(), "影响情况及消除或减轻影响措施"));
        mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
        return mv;
    }

    /**
     * 导入
     *
     * @return
     */
    @RequestMapping(value = "/importRmYxqk/{mainId}")
    public Result<?> importRmYxqk(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<RmYxqk> list = ExcelImportUtil.importExcel(file.getInputStream(), RmYxqk.class, params);
                for (RmYxqk temp : list) {
                    temp.setMainId(mainId);
                }
                long start = System.currentTimeMillis();
                rmYxqkService.saveBatch(list);
                log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                return Result.OK("文件导入成功！数据行数：" + list.size());
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error("文件导入失败:" + e.getMessage());
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.error("文件导入失败！");
    }

    /*--------------------------------子表处理-影响情况及消除或减轻影响措施-end----------------------------------------------*/

    /**
     * 创建空间图形
     */
    private void generateGeom(RmAxshbfgcxxb rmAxshbfgcxxb) {
        String id = rmAxshbfgcxxb.getId();
        String a = rmAxshbfgcxxb.getJd();
        String b = rmAxshbfgcxxb.getWd();
        String gcmc = rmAxshbfgcxxb.getGcmc();
        Double jd = null;
        Double wd = null;
        if (a == null || b == null) {
            rmAxshbfgcxxbService.addgshbfgc2(null, id, gcmc);
        } else if (pdjwd.isLONG("a") && pdjwd.isLA("b")) {
            jd = Double.valueOf(a);
            wd = Double.valueOf(b);
        } else if (a.contains("°") && b.contains("°")) {
            jd = zbzh.tranformPos(a);//转成数值
            wd = zbzh.tranformPos(b);
        } else {
            jd = Double.valueOf(a);
            wd = Double.valueOf(b);
        }

        if (jd > 39000000 || wd > 39000000) {
            if (jd > wd) {
                rmAxshbfgcxxbService.addgshbfgc3("POINT(" + jd + " " + wd + ")", id, gcmc);
            } else {
                rmAxshbfgcxxbService.addgshbfgc3("POINT(" + wd + " " + jd + ")", id, gcmc);
            }
        } else if (jd > 180 || wd > 180) {
            if (jd < wd) {
                rmAxshbfgcxxbService.addgshbfgc("POINT(" + jd + " " + wd + ")", id, gcmc);
            } else {
                rmAxshbfgcxxbService.addgshbfgc("POINT(" + wd + " " + jd + ")", id, gcmc);
            }
        } else {
            if (jd > wd) {
                rmAxshbfgcxxbService.addgshbfgc2("POINT(" + jd + " " + wd + ")", id, gcmc);
            } else {
                rmAxshbfgcxxbService.addgshbfgc2("POINT(" + wd + " " + jd + ")", id, gcmc);
            }
        }
    }

    /**
     * 更新空间图形
     */
    private void updateGeom(RmAxshbfgcxxb RmAxshbfgcxxb) {
        String id = RmAxshbfgcxxb.getId();
        String a = RmAxshbfgcxxb.getJd();
        String b = RmAxshbfgcxxb.getWd();
        String gcmc = RmAxshbfgcxxb.getGcmc();
        Double jd = null;
        Double wd = null;
        if (a == null || b == null) {
            rmAxshbfgcxxbService.addgshbfgc2(null, id, gcmc);
        } else if (pdjwd.isLONG("a") && pdjwd.isLA("b")) {
            jd = Double.valueOf(a);
            wd = Double.valueOf(b);
        } else if (a.contains("°") && b.contains("°")) {
            jd = zbzh.tranformPos(a);//转成数值
            wd = zbzh.tranformPos(b);
        } else {
            jd = Double.valueOf(a);
            wd = Double.valueOf(b);
        }
        if (jd > 39000000 || wd > 39000000) {
            if (jd > wd) {
                rmAxshbfgcxxbService.updshbfgc2("POINT(" + jd + " " + wd + ")", gcmc, id);
            } else {
                rmAxshbfgcxxbService.updshbfgc2("POINT(" + wd + " " + jd + ")", gcmc, id);
            }
        } else if (jd > 180 || wd > 180) {
            if (jd < wd) {
                rmAxshbfgcxxbService.updshbfgc("POINT(" + jd + " " + wd + ")", gcmc, id);
            } else {
                rmAxshbfgcxxbService.updshbfgc("POINT(" + wd + " " + jd + ")", gcmc, id);
            }
        } else {
            if (jd > wd) {
                rmAxshbfgcxxbService.updshbfgc3("POINT(" + jd + " " + wd + ")", gcmc, id);
            } else {
                rmAxshbfgcxxbService.updshbfgc3("POINT(" + wd + " " + jd + ")", gcmc, id);
            }
        }
    }

    /**
     * 创建空间图形
     */
    private void generateGeom2(RmAxxmxx rmAxxmxx) {
        String id = rmAxxmxx.getId();
        String jszt = rmAxxmxx.getJszt();
        String xmmc = rmAxxmxx.getXmmc();
        String a = null;
        String b = null;
        try {
            a = rmAxxmxx.getHzb().toString();
            b = rmAxxmxx.getZzb().toString();
            Double jd = null;
            Double wd = null;
            if (pdjwd.isLONG("a") && pdjwd.isLA("b")) {
                jd = Double.valueOf(a);
                wd = Double.valueOf(b);
            } else if (a.contains("°") && b.contains("°")) {
                jd = zbzh.tranformPos(a);//转成数值
                wd = zbzh.tranformPos(b);
            } else {
                jd = Double.valueOf(a);
                wd = Double.valueOf(b);
            }

            if (jd > 39000000 || wd > 39000000) {
                if (jd > wd) {
                    rmAxxmxxService.addXmxx2("POINT(" + jd + " " + wd + ")", id, jszt, xmmc);
                } else {
                    rmAxxmxxService.addXmxx2("POINT(" + wd + " " + jd + ")", id, jszt, xmmc);
                }
            } else if (jd > 180 || wd > 180) {
                if (jd < wd) {
                    rmAxxmxxService.addXmxx("POINT(" + jd + " " + wd + ")", id, jszt, xmmc);
                } else {
                    rmAxxmxxService.addXmxx("POINT(" + wd + " " + jd + ")", id, jszt, xmmc);
                }
            } else {
                if (jd > wd) {
                    rmAxxmxxService.addXmxx3("POINT(" + jd + " " + wd + ")", id, jszt, xmmc);
                } else {
                    rmAxxmxxService.addXmxx3("POINT(" + wd + " " + jd + ")", id, jszt, xmmc);
                }
            }
        } catch (NullPointerException e) {
            rmAxxmxxService.addXmxx2(null, id, jszt, xmmc);
            log.error(e.getMessage());
        }

    }

    /**
     * 更新空间图形
     */
    private void updateGeom2(RmAxxmxx rmAxxmxx) {
        String id = rmAxxmxx.getId();
        String a = rmAxxmxx.getHzb().toString();
        String b = rmAxxmxx.getZzb().toString();
        String jszt = rmAxxmxx.getJszt();
        String xmmc = rmAxxmxx.getXmmc();
        Double jd = null;
        Double wd = null;
        if (pdjwd.isLONG("a") && pdjwd.isLA("b")) {
            jd = Double.valueOf(a);
            wd = Double.valueOf(b);
        } else if (a.contains("°") && b.contains("°")) {
            jd = zbzh.tranformPos(a);//转成数值
            wd = zbzh.tranformPos(b);
        } else {
            jd = Double.valueOf(a);
            wd = Double.valueOf(b);
        }
        if (jd > 39000000 || wd > 39000000) {
            if (jd > wd) {
                rmAxxmxxService.updXmxx2("POINT(" + jd + " " + wd + ")", id, jszt, xmmc);
            } else {
                rmAxxmxxService.updXmxx2("POINT(" + wd + " " + jd + ")", id, jszt, xmmc);
            }
        } else if (jd > 180 || wd > 180) {
            if (jd < wd) {
                rmAxxmxxService.updXmxx("POINT(" + jd + " " + wd + ")", id, jszt, xmmc);
            } else {
                rmAxxmxxService.updXmxx("POINT(" + wd + " " + jd + ")", id, jszt, xmmc);
            }
        } else {
            if (jd > wd) {
                rmAxxmxxService.updXmxx3("POINT(" + jd + " " + wd + ")", id, jszt, xmmc);
            } else {
                rmAxxmxxService.updXmxx3("POINT(" + wd + " " + jd + ")", id, jszt, xmmc);
            }
        }
    }


}