package cn.com.goldenwater.dcproj.controller.index;

import cn.com.goldenwater.core.web.BaseController;
import cn.com.goldenwater.core.web.BaseResponse;
import cn.com.goldenwater.dcproj.vo.PblmObj;
import cn.com.goldenwater.dcproj.vo.RsvrObj;
import cn.com.goldenwater.dcproj.dto.ExcelInspPersDto;
import cn.com.goldenwater.dcproj.model.*;
import cn.com.goldenwater.dcproj.param.*;
import cn.com.goldenwater.dcproj.service.*;
import cn.com.goldenwater.dcproj.utils.LoadExcel;
import cn.com.goldenwater.id.util.UuidUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * 只作为excel数据定制化业务处理
 */
@RestController
@RequestMapping("/excel")
public class ImportExcelController extends BaseController {
    @Autowired
    private BisInspRsvrRgstrService rsvrRgstrService;
    @Autowired
    private BisInspAllObjService objService;
    @Autowired
    private AttRsBaseService attRsBaseService;
    @Autowired
    private BisInspRsvrProjectService rsvrProjectService;
    @Autowired
    private BisInspAllService inspAllService;
    @Autowired
    private AttAdXBaseService attAdXBaseService;
    @Autowired
    private BisInspSelAreaService bisInspSelAreaService;
    @Autowired
    private BisInspAllRlationPersService bisInspAllRlationPersService;
    @Autowired
    private BisInspAllRlationService bisInspAllRlationService;

    @GetMapping("/getExcelPers/{month}")
    public BaseResponse getExcelPers(@PathVariable String month) throws Exception {
        String filePath = "D:\\data\\" + month + "月小水库附表1-6.xlsx";
        List<RsvrObj> rsBaseParamList = new ArrayList<>();
        Map<String, Object> params = new HashMap<>();
        List<ExcelInspPersDto> inspPersDtos = LoadExcel.getExcelPers(filePath);
        String iOrgId = "";
        String iSheng = "";
        String iShengCode = "";
        String iPersName = "";
        String iPersId = "";
        String iGroupId = "";
        for (ExcelInspPersDto pers : inspPersDtos) {
            String sheng = pers.getGroName();
            String shengCode = getAdCd(sheng, "", "");
            String orgId = pers.getOrgId();
            String persName = pers.getHeadman();
            String persId = "";
            //把人员进行数据库匹配，如果匹配不上则新增，返回每个人员的id
            Map<String, String> map = this.addPers(pers);
            persId = map.get("one");
            BisInspAllParam bisInspAllParam = new BisInspAllParam();
            BisInspAll bisInspAll;
            bisInspAllParam.setInspYear("2019");
            bisInspAllParam.setInspMnth("0" + month);
            String pid = "001" + orgId;//6位
            //如果是Excel中该机构第一条数据，则把该机构下本月所有批次和所有的组删除
            if (!iOrgId.equals(orgId)) {
                iOrgId = orgId;
                bisInspAllParam.setId(pid + "0");
                //inspAllService.deleteBy(bisInspAllParam);
            }
            bisInspAllParam.setId("");
            bisInspAllParam.setPid(pid);
            //查询该机构本月批次,因为之前已经把该机构下所有批次及组都删除了，只新增了一个批次，所以可以用getBy获取单个批次
            BisInspAll bisInspAlls = inspAllService.getBy(bisInspAllParam);
            //如果该机构本月下有批次，则新建督查组并记录组id
            String groupId = "";
            if (bisInspAlls != null) {
                pid = bisInspAlls.getId();//9位
                bisInspAllParam.setPid(pid);
                //查找批次下的督查组的最大ID
                String maxId = inspAllService.selectMax(bisInspAllParam);
                if (StringUtils.isBlank(maxId)) {
                    maxId = pid + "001";
                } else {
                    maxId = "00" + (Integer.parseInt(maxId) + 1);
                }
                groupId = maxId;
                //查找批次下该省份的督查组数量
                bisInspAllParam.setPnm(sheng);
                int count = inspAllService.selectCount(bisInspAllParam);
                //督查组名称为省份加顺序号
                String pNm = sheng + (count + 1) + "组";
                bisInspAll = new BisInspAll();
                bisInspAll.setId(maxId);
                bisInspAll.setPid(pid);
                bisInspAll.setPnm(pNm);
                Date date = new SimpleDateFormat("yyyy/MM/dd").parse("2019/0" + month + "/30");
                bisInspAll.setEntm(date);
                date = new SimpleDateFormat("yyyy/MM/dd").parse("2019/0" + month + "/01");
                bisInspAll.setSttm(date);
                bisInspAll.setInspYear("2019");
                bisInspAll.setInspMnth("0" + month);
                bisInspAll.setInspTask(shengCode);
                inspAllService.insert(bisInspAll);
                System.out.println("新增bis_insp_all p&c" + pNm);
            }
            //如果没有有对应批次则新建批次和督查组
            else {
                bisInspAll = new BisInspAll();
                Date date = new SimpleDateFormat("yyyy/MM/dd").parse("2019/0" + month + "/30");
                bisInspAll.setEntm(date);
                date = new SimpleDateFormat("yyyy/MM/dd").parse("2019/0" + month + "/01");
                bisInspAll.setSttm(date);
                BisInspAllParam newInspAllParam = new BisInspAllParam();
                newInspAllParam.setInspYear("2019");
                newInspAllParam.setInspMnth("");
                newInspAllParam.setPid(pid);
                String maxId = inspAllService.selectMax(newInspAllParam);
                if (StringUtils.isBlank(maxId)) {
                    maxId = pid + "001";
                } else {
                    maxId = "00" + (Integer.parseInt(maxId) + 1);
                }
                groupId = maxId;
                bisInspAll.setId(maxId);
                bisInspAll.setPid(pid);
                bisInspAll.setInspYear("2019");
                bisInspAll.setInspMnth("0" + month);
                bisInspAll.setPnm("2019年" + month + "月督查工作");
                inspAllService.insert(bisInspAll);
                String litter = maxId + "001";
                bisInspAll.setId(litter);
                bisInspAll.setPid(maxId);
                bisInspAll.setPnm(sheng + "1组");
                bisInspAll.setInspTask(shengCode);
                inspAllService.insert(bisInspAll);
                System.out.println("新增bis_insp_all p&c" + sheng + "1组");
            }
            //把督查组与省份关联起来
            BisInspSelAreaParam selAreaParam = new BisInspSelAreaParam();
            selAreaParam.setAdCode(shengCode);
            selAreaParam.setId(groupId);
            //首先查询督查组与该省份是否已经关联
            List<BisInspSelArea> selAreas = bisInspSelAreaService.findList(selAreaParam);
            if (selAreas == null || selAreas.size() == 0) {
                BisInspSelArea selArea = new BisInspSelArea();
                selArea.setId(groupId);
                selArea.setAdName(sheng);
                selArea.setAdCode(shengCode);
                bisInspSelAreaService.insert(selArea);
            }
            //把人员与督查组关联起来，首先清空该组下的人员关系
            BisInspAllRlationParam rlationParam = new BisInspAllRlationParam();
            rlationParam.setId(groupId);
            bisInspAllRlationService.deleteBy(rlationParam);
            BisInspAllRlation rlation = new BisInspAllRlation();
            rlation.setId(groupId);
            rlation.setPersid(map.get("one"));
            rlation.setPertype("1");
            bisInspAllRlationService.insert(rlation);
            rlation.setPersid(map.get("two"));
            rlation.setPertype("2");
            bisInspAllRlationService.insert(rlation);
            rlation.setPersid(map.get("three"));
            rlation.setPertype("3");
            bisInspAllRlationService.insert(rlation);
        }

        List<RsvrObj> rsvrObjList = LoadExcel.getRsvrObjList(filePath);
        int count = 0;
        for (RsvrObj obj : rsvrObjList) {
            String rsCode = "";
            String country = obj.getCountry();
            obj.setRsvrNm(obj.getRsvrNm().replace("水库水库", "水库"));
            String localtion = obj.getProvince() + "-" + obj.getCity() + "-" + country;
            if (!obj.getProvince().contains("省")) {
                if (!obj.getCity().endsWith("市")) {
                    localtion = obj.getProvince() + "省-" + obj.getCity() + "市-" + country;
                } else {
                    localtion = obj.getProvince() + "省-" + obj.getCity() + "-" + country;
                }
            }
            String adCd = getAdCd(obj.getProvince(), obj.getCity(), country);
            String rsName = obj.getRsvrNm();
            String guiMo = obj.getGuimo();
            AttRsBaseParam rsBaseParam = new AttRsBaseParam();
            rsBaseParam.setAdmDiv(adCd);
            rsBaseParam.setRsName(rsName);
            List<AttRsBase> rsBaseList = attRsBaseService.findRsList(rsBaseParam);
            BisInspRsvrRgstrParam bisInspRsvrRgstrParam = new BisInspRsvrRgstrParam();
            bisInspRsvrRgstrParam.setAdCode(adCd);
            bisInspRsvrRgstrParam.setRsvrNm(rsName);
            List<BisInspRsvrRgstr> rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
            if (rsBaseList == null || rsBaseList.isEmpty()) {
                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                    rsBaseParam.setAdmDiv(adCd.substring(0, 4));
                    rsBaseParam.setLocation(localtion);
                    rsBaseList = attRsBaseService.findRsList(rsBaseParam);
                    if (rsBaseList == null || rsBaseList.isEmpty()) {
                        bisInspRsvrRgstrParam.setAdCode(adCd.substring(0, 4));
                        bisInspRsvrRgstrParam.setLocation(localtion);
                        rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
                        if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                            rsBaseParam.setAdmDiv(adCd.substring(0, 2));
                            rsBaseParam.setLocation("");
                            rsBaseList = attRsBaseService.findRsList(rsBaseParam);
                            if (rsBaseList == null || rsBaseList.isEmpty()) {
                                bisInspRsvrRgstrParam.setAdCode(adCd.substring(0, 2));
                                bisInspRsvrRgstrParam.setLocation("");
                                rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
                                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                    System.out.println("缺失：" + obj.toString());
                                } else {
                                    if (rsvrRgstrs.size() > 0) {
                                        System.out.println("查询出多条水库：" + rsvrRgstrs.toString());
                                    }
                                    rsCode = rsvrRgstrs.get(0).getRsCode();
                                }
                            } else {
                                if (rsBaseList.size() > 0) {
                                    System.out.println("查询出多条水库：" + rsBaseList.toString());
                                }
                                rsCode = rsBaseList.get(0).getRsCode();
                            }
                        } else {
                            if (rsvrRgstrs.size() > 0) {
                                System.out.println("查询出多条水库：" + rsvrRgstrs.toString());
                            }
                            rsCode = rsvrRgstrs.get(0).getRsCode();
                        }
                    } else {
                        if (rsBaseList.size() > 0) {
                            System.out.println("查询出多条水库：" + rsBaseList.toString());
                        }
                        rsCode = rsBaseList.get(0).getRsCode();
                    }
                } else {
                    if (rsvrRgstrs.size() > 0) {
                        System.out.println("查询出多条水库：" + rsvrRgstrs.toString());
                    }
                    rsCode = rsvrRgstrs.get(0).getRsCode();
                }
            } else {
                if (rsBaseList.size() > 0) {
                    System.out.println("查询出多条水库：" + rsBaseList.toString());
                    rsBaseParam.setEngScal(guiMo);
                    rsBaseList = attRsBaseService.findRsList(rsBaseParam);
                }
                rsCode = rsBaseList.get(0).getRsCode();
            }
            if (rsBaseList == null || rsBaseList.isEmpty()) {
                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                    System.out.println("缺失：" + obj.toString());
                } else {

                }
            }


        }
        params.put("count", rsBaseParamList.size());
        params.put("data", rsBaseParamList);
        return buildSuccessResponse(params);
    }

    @GetMapping("/get/{month}")
    public BaseResponse getExcel(@PathVariable String month) throws Exception {
        String filePath = "D:\\data\\" + month + "月小水库附表1-6.xlsx";
        List<RsvrObj> rsBaseParamList = new ArrayList<>();
        Map<String, Object> params = new HashMap<>();
        String result = "";
        List<RsvrObj> rsvrObjList = LoadExcel.getRsvrObjList(filePath);
        int count = 0;
        for (RsvrObj obj : rsvrObjList) {
            String rsCode = "";
            String regId = "";
            String country = obj.getCountry();
            obj.setRsvrNm(obj.getRsvrNm().replace("水库水库", "水库"));
            String localtion = obj.getProvince() + "-" + obj.getCity() + "-" + country;
            if (!obj.getProvince().contains("省")) {
                if (!obj.getCity().endsWith("市")) {
                    localtion = obj.getProvince() + "省-" + obj.getCity() + "市-" + country;
                } else {
                    localtion = obj.getProvince() + "省-" + obj.getCity() + "-" + country;
                }
            }
            String adCd = getAdCd(obj.getProvince(), obj.getCity(), country);
            Map<String, String> ads = getAdCds(obj.getProvince(), obj.getCity(), country);
            obj.setProvinceCode(ads.get("sheng"));
            obj.setCityCode(ads.get("shi"));
            obj.setCountryCode(ads.get("xian"));
            if (ads.get("xian") != null) {
                adCd = ads.get("xian");
            }
            String rsName = obj.getRsvrNm();
            if (!rsName.contains("水库") && !rsName.contains("库")) {
                rsName += "水库";
            }
            String guiMo = obj.getGuimo();
            AttRsBaseParam rsBaseParam = new AttRsBaseParam();
            rsBaseParam.setAdmDiv(adCd);
            rsBaseParam.setRsName(rsName);
            List<AttRsBase> rsBaseList = attRsBaseService.findRsList(rsBaseParam);
            BisInspRsvrRgstrParam bisInspRsvrRgstrParam = new BisInspRsvrRgstrParam();
            bisInspRsvrRgstrParam.setAdCode(adCd);
            bisInspRsvrRgstrParam.setRsvrNm(rsName);
            List<BisInspRsvrRgstr> rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
            if (rsBaseList == null || rsBaseList.isEmpty()) {
                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                    rsBaseParam.setAdmDiv(adCd.substring(0, 4));
                    rsBaseParam.setLocation(localtion);
                    rsBaseList = attRsBaseService.findRsList(rsBaseParam);
                    if (rsBaseList == null || rsBaseList.isEmpty()) {
                        bisInspRsvrRgstrParam.setAdCode(adCd.substring(0, 4));
                        bisInspRsvrRgstrParam.setLocation(localtion);
                        rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
                        if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                            rsBaseParam.setAdmDiv(adCd.substring(0, 2));
                            rsBaseParam.setLocation("");
                            rsBaseList = attRsBaseService.findRsList(rsBaseParam);
                            if (rsBaseList == null || rsBaseList.isEmpty()) {
                                bisInspRsvrRgstrParam.setAdCode(adCd.substring(0, 2));
                                bisInspRsvrRgstrParam.setLocation("");
                                rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
                                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                    System.out.println("缺失：" + obj.toString());
                                    result += "缺失：" + obj.toString() + "\n";
                                } else {
                                    if (rsvrRgstrs.size() > 1) {
                                        for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                            if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                                rsCode = rsvrRgstr.getRsCode();
                                                break;
                                            }
                                        }
                                        if (StringUtils.isBlank(rsCode)) {
                                            System.out.println("登记表查询出多条水库并未匹配上：" + rsBaseList.toString());
                                            result += "登记表查询出多条水库并未匹配上：" + obj.toString() + "\n";
                                        }
                                    }
                                }
                            } else {
                                if (rsBaseList.size() > 1) {
                                    for (AttRsBase attRsBase : rsBaseList) {
                                        if (rsName.equals(attRsBase.getRsName())) {
                                            rsCode = attRsBase.getRsCode();
                                            break;
                                        }
                                    }
                                    if (StringUtils.isBlank(rsCode)) {
                                        bisInspRsvrRgstrParam.setAdCode(adCd.substring(0, 2));
                                        bisInspRsvrRgstrParam.setLocation(localtion);
                                        rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
                                        if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                            result += "基础表查出多条数据并无法匹配，登记表未查出数据：" + obj.toString() + "\n";
                                        } else {
                                            if (rsvrRgstrs.size() > 1) {
                                                for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                                    if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                                        rsCode = rsvrRgstr.getRsCode();
                                                        break;
                                                    }
                                                }
                                                if (StringUtils.isBlank(rsCode)) {
                                                    result += "基础表查出多条数据并无法匹配，登记表查出多条数据并无法匹配：" + obj.toString() + "\n";
                                                }
                                            } else {
                                                BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                                regId = rsvrRgstr.getRgstrId();
                                                rsCode = rsvrRgstr.getRsCode();
                                            }
                                        }
                                    } else {
                                        bisInspRsvrRgstrParam.setAdCode("");
                                        bisInspRsvrRgstrParam.setRsvrNm("");
                                        bisInspRsvrRgstrParam.setRsCode(rsCode);
                                        if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                            System.out.println("基础表查询出水库但在登记表无记录：" + rsBaseList.toString());
                                        } else {
                                            if (rsvrRgstrs.size() == 1) {
                                                BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                                regId = rsvrRgstr.getRgstrId();
                                                rsCode = rsvrRgstr.getRsCode();
                                            } else {
                                                for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                                    if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                                        regId = rsvrRgstr.getRgstrId();
                                                        rsCode = rsvrRgstr.getRsCode();
                                                    }
                                                }
                                            }
                                        }
                                    }
                                } else {
                                    rsCode = rsBaseList.get(0).getRsCode();
                                    bisInspRsvrRgstrParam.setAdCode("");
                                    bisInspRsvrRgstrParam.setRsvrNm("");
                                    bisInspRsvrRgstrParam.setRsCode(rsCode);
                                    if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                        System.out.println("基础表查询出水库但在登记表无记录：" + rsBaseList.toString());
                                    } else {
                                        if (rsvrRgstrs.size() == 1) {
                                            BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                            regId = rsvrRgstr.getRgstrId();
                                            rsCode = rsvrRgstr.getRsCode();
                                        } else {
                                            for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                                if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                                    regId = rsvrRgstr.getRgstrId();
                                                    rsCode = rsvrRgstr.getRsCode();
                                                    break;
                                                }
                                            }
                                            if (StringUtils.isBlank(regId)) {
                                                result += "基础表有匹配数据，登记表查出多条并无法匹配：" + obj.toString() + "\n";
                                            }
                                        }
                                    }
                                }
                            }
                        } else {
                            if (rsvrRgstrs.size() > 1) {
                                for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                    if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                        rsCode = rsvrRgstr.getRsCode();
                                        regId = rsvrRgstr.getRgstrId();
                                        break;
                                    }
                                }
                                if (StringUtils.isBlank(regId)) {
                                    System.out.println("登记表查询出多条水库并未匹配上：" + rsBaseList.toString());
                                    result += "基础表无匹配，登记表查询出多条水库并未匹配上：" + obj.toString() + "\n";
                                }
                            } else {
                                BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                regId = rsvrRgstr.getRgstrId();
                                rsCode = rsvrRgstr.getRsCode();
                            }
                        }
                    } else {
                        if (rsBaseList.size() > 1) {
                            for (AttRsBase attRsBase : rsBaseList) {
                                if (rsName.equals(attRsBase.getRsName())) {
                                    rsCode = attRsBase.getRsCode();
                                    break;
                                }
                            }
                            if (StringUtils.isBlank(rsCode)) {
                                bisInspRsvrRgstrParam.setAdCode(adCd.substring(0, 4));
                                bisInspRsvrRgstrParam.setLocation(localtion);
                                rsvrRgstrs = rsvrRgstrService.findList(bisInspRsvrRgstrParam);
                                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                    result += "基础表查出多条数据并无法匹配，登记表未查出数据：" + obj.toString() + "\n";
                                } else {
                                    if (rsvrRgstrs.size() > 1) {
                                        for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                            if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                                rsCode = rsvrRgstr.getRsCode();
                                                break;
                                            }
                                        }
                                        if (StringUtils.isBlank(rsCode)) {
                                            result += "基础表查出多条数据并无法匹配，登记表查出多条数据并无法匹配：" + obj.toString() + "\n";
                                        }
                                    } else {
                                        BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                        regId = rsvrRgstr.getRgstrId();
                                        rsCode = rsvrRgstr.getRsCode();
                                    }
                                }
                            } else {
                                bisInspRsvrRgstrParam.setAdCode("");
                                bisInspRsvrRgstrParam.setRsvrNm("");
                                bisInspRsvrRgstrParam.setRsCode(rsCode);
                                if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                    System.out.println("基础表查询出水库但在登记表无记录：" + rsBaseList.toString());
                                } else {
                                    if (rsvrRgstrs.size() == 1) {
                                        BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                        regId = rsvrRgstr.getRgstrId();
                                        rsCode = rsvrRgstr.getRsCode();
                                    } else {
                                        for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                            if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                                regId = rsvrRgstr.getRgstrId();
                                                rsCode = rsvrRgstr.getRsCode();
                                            }
                                        }
                                    }
                                }
                            }
                        } else {
                            rsCode = rsBaseList.get(0).getRsCode();
                            bisInspRsvrRgstrParam.setAdCode("");
                            bisInspRsvrRgstrParam.setRsvrNm("");
                            bisInspRsvrRgstrParam.setRsCode(rsCode);
                            if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                                System.out.println("基础表查询出水库但在登记表无记录：" + rsBaseList.toString());
                            } else {
                                if (rsvrRgstrs.size() == 1) {
                                    BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                    regId = rsvrRgstr.getRgstrId();
                                    rsCode = rsvrRgstr.getRsCode();
                                } else {
                                    for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                        if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                            regId = rsvrRgstr.getRgstrId();
                                            rsCode = rsvrRgstr.getRsCode();
                                            break;
                                        }
                                    }
                                    if (StringUtils.isBlank(regId)) {
                                        result += "基础表有匹配数据，登记表查出多条并无法匹配：" + obj.toString() + "\n";
                                    }
                                }
                            }
                        }
                    }
                } else {
                    if (rsvrRgstrs.size() > 1) {
                        for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                            if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                rsCode = rsvrRgstr.getRsCode();
                                regId = rsvrRgstr.getRgstrId();
                                break;
                            }
                        }
                        if (StringUtils.isBlank(regId)) {
                            System.out.println("登记表查询出多条水库并未匹配上：" + rsBaseList.toString());
                            result += "基础表无匹配，登记表查询出多条水库并未匹配上：" + obj.toString() + "\n";
                        }
                    } else {
                        BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                        regId = rsvrRgstr.getRgstrId();
                        rsCode = rsvrRgstr.getRsCode();
                    }
                }
            } else {
                if (rsBaseList.size() == 1) {
                    rsCode = rsBaseList.get(0).getRsCode();
                    bisInspRsvrRgstrParam.setAdCode("");
                    bisInspRsvrRgstrParam.setRsvrNm("");
                    bisInspRsvrRgstrParam.setRsCode(rsCode);
                    if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                        System.out.println("基础表查询出水库但在登记表无记录：" + rsBaseList.toString());
                    } else {
                        if (rsvrRgstrs.size() == 1) {
                            BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                            regId = rsvrRgstr.getRgstrId();
                            rsCode = rsvrRgstr.getRsCode();
                        } else {
                            for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                    regId = rsvrRgstr.getRgstrId();
                                    rsCode = rsvrRgstr.getRsCode();
                                    break;
                                }
                            }
                            if (StringUtils.isBlank(regId)) {
                                result += "基础表有匹配数据，登记表查出多条并无法匹配：" + obj.toString() + "\n";
                            }
                        }
                    }
                } else {
                    for (AttRsBase attRsBase : rsBaseList) {
                        if (rsName.equals(attRsBase.getRsName())) {
                            rsCode = attRsBase.getRsCode();
                            break;
                        }
                    }
                    if (StringUtils.isBlank(rsCode)) {
                        System.out.println("查询出多条水库并未匹配上：" + rsBaseList.toString());
                        result += "查询出多条水库并未匹配上：" + obj.toString() + "\n";
                    } else {
                        bisInspRsvrRgstrParam.setAdCode("");
                        bisInspRsvrRgstrParam.setRsvrNm("");
                        bisInspRsvrRgstrParam.setRsCode(rsCode);
                        if (rsvrRgstrs == null || rsvrRgstrs.isEmpty()) {
                            System.out.println("基础表查询出水库但在登记表无记录：" + rsBaseList.toString());
                        } else {
                            if (rsvrRgstrs.size() == 1) {
                                BisInspRsvrRgstr rsvrRgstr = rsvrRgstrs.get(0);
                                regId = rsvrRgstr.getRgstrId();
                                rsCode = rsvrRgstr.getRsCode();
                            } else {
                                for (BisInspRsvrRgstr rsvrRgstr : rsvrRgstrs) {
                                    if (rsName.equals(rsvrRgstr.getRsvrNm())) {
                                        regId = rsvrRgstr.getRgstrId();
                                        rsCode = rsvrRgstr.getRsCode();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (StringUtils.isNotBlank(rsCode) && StringUtils.isNotBlank(regId)) {
                System.out.println("正常获取到水库编码和登记表id");
            } else {
                if (StringUtils.isBlank(rsCode) && StringUtils.isBlank(regId)) {
                    System.out.println("未获取到水库编码和登记表id-" + obj.toString());
                    result += "-未获取到水库编码和登记表id-" + obj.toString() + "--";
                } else if (StringUtils.isBlank(rsCode)) {
                    System.out.println("未获取到水库编码-" + obj.toString());
                    result += "-未获取到水库编码-" + obj.toString() + "--";
                } else if (StringUtils.isBlank(regId)) {
                    System.out.println("未获取到登记表id-" + obj.toString());
                    result += "-未获取到登记表id-" + obj.toString() + "--";
                }
            }

//            BisInspAll bisInspAll=new BisInspAll();
//            for (AttRsBase rsBase : rsBaseList) {
//                rsCode = rsBase.getRsCode();
//                BisInspAllObjParam allObjParam = new BisInspAllObjParam();
//                allObjParam.setCode(rsCode);
//                allObjParam.setPtype("1");
//                allObjParam.setId(bisInspAll.getId());
//                allObjParam.setNm(rsBase.getRsName());
//                List<BisInspAllObj> allObjList=objService.findList(allObjParam);
//                BisInspAllObj allObj=null;
//                for(BisInspAllObj bisInspAllObj:allObjList){
//                    if(bisInspAllObj.getId().contains(bisInspAll.getId())){
//                        allObj=bisInspAllObj;
//                        break;
//                    }
//                }
//                if (allObj != null) {
//                    addRsvr(allObj, obj, rsBase);
//                } else {
//                    allObj = new BisInspAllObj();
//                    allObj.setId(allObjParam.getId());
//                    allObj.setCode(rsCode);
//                    if (StringUtils.isNotBlank(rsBase.getCenterXGd())) {
//                        allObj.setLgtd(Double.parseDouble(rsBase.getCenterXGd()));
//                    }
//                    if (StringUtils.isNotBlank(rsBase.getCenterYGd())) {
//                        allObj.setLttd(Double.parseDouble(rsBase.getCenterYGd()));
//                    }
//                    if (StringUtils.isNotBlank(rsBase.getCenterX())){
//                        allObj.setLgtdpc(Double.parseDouble(rsBase.getCenterX()));
//                    }
//                    if(StringUtils.isNotBlank(rsBase.getCenterY())) {
//                        allObj.setLttdpc(Double.parseDouble(rsBase.getCenterY()));
//                    }
//                    allObj.setObjId(UuidUtil.uuid());
//                    allObj.setNm(rsBase.getRsName());
//                    allObj.setPtype("1");
//                objService.insert(allObj);
//                    System.out.println("无督查任务水库：" + rsName);
//                    addRsvr(allObj, obj, rsBase);
//
//                }
//            }
        }
        params.put("count", rsBaseParamList.size());
        params.put("data", rsBaseParamList);
        return buildSuccessResponse(result);
    }

    private void addRsvr(BisInspAllObj allObj, RsvrObj obj, AttRsBase rsBase) {
        BisInspRsvrRgstrParam inspRsvrRgstrParam = new BisInspRsvrRgstrParam();
        inspRsvrRgstrParam.setObjId(allObj.getObjId());
        inspRsvrRgstrParam.setRsvrNm(allObj.getNm());
        inspRsvrRgstrParam.setRsCode(allObj.getCode());
        BisInspRsvrRgstr inspRsvrRgstr = rsvrRgstrService.getBy(inspRsvrRgstrParam);
        if (inspRsvrRgstr != null) {
            inspRsvrRgstr.setNote(obj.getNote());
            if (StringUtils.isNotBlank(obj.getTop())) {
                inspRsvrRgstr.setTotCap(Double.parseDouble(obj.getTop()));
            }
            inspRsvrRgstr.setEngScal(obj.getGuimo());

            BisInspRsvrProjectParam rsvrProjectParam = new BisInspRsvrProjectParam();
            rsvrProjectParam.setRgstrId(inspRsvrRgstr.getRgstrId());
            BisInspRsvrProject inspRsvrProject = rsvrProjectService.getBy(rsvrProjectParam);
            if (inspRsvrProject != null) {
                inspRsvrProject.setPoorCountry(obj.getPoor());
                rsvrProjectService.update(inspRsvrProject);
            } else {
                inspRsvrProject = new BisInspRsvrProject();
                inspRsvrProject.setId(UuidUtil.uuid());
                inspRsvrProject.setPoorCountry(obj.getPoor());
                inspRsvrProject.setRgstrId(inspRsvrRgstr.getRgstrId());
                rsvrProjectService.insert(inspRsvrProject);
            }
            inspRsvrRgstr.setReverStat("2");
            inspRsvrProject.setStatus("2");
            rsvrRgstrService.update(inspRsvrRgstr);
        } else {
            String rgstrId = UuidUtil.uuid();
            inspRsvrRgstr = new BisInspRsvrRgstr();
            inspRsvrRgstr.setEngScal(obj.getGuimo());
            inspRsvrRgstr.setRgstrId(rgstrId);
            inspRsvrRgstr.setReverStat("2");
            inspRsvrRgstr.setObjId(allObj.getObjId());
            inspRsvrRgstr.setNote(obj.getNote());
            inspRsvrRgstr.setRsvrAdmName(rsBase.getRsAdmName());
            if (StringUtils.isNotBlank(obj.getTop())) {
                inspRsvrRgstr.setTotCap(Double.parseDouble(obj.getTop()));
            }
            inspRsvrRgstr.setRsCode(rsBase.getRsCode());
            inspRsvrRgstr.setIntm(new Date());
            inspRsvrRgstr.setUptm(new Date());
            inspRsvrRgstr.setLocation(rsBase.getLocation());
            inspRsvrRgstr.setDamType(rsBase.getDamType());
            inspRsvrRgstr.setAdCode(rsBase.getAdmDiv());
            inspRsvrRgstr.setState("2");
            inspRsvrRgstr.setCompDateStr(rsBase.getCompDateStr());
            inspRsvrRgstr.setHystSite(rsBase.getRsLoc());
            if (StringUtils.isNotBlank(rsBase.getCenterYGd())) {
                inspRsvrRgstr.setRsvrLat(Double.parseDouble(rsBase.getCenterYGd()));
            }
            if (StringUtils.isNotBlank(rsBase.getCenterXGd())) {
                inspRsvrRgstr.setRsvrLong(Double.parseDouble(rsBase.getCenterXGd()));
            }
            inspRsvrRgstr.setRsvrNm(rsBase.getRsName());
            rsvrRgstrService.insert(inspRsvrRgstr);
            BisInspRsvrProject inspRsvrProject = new BisInspRsvrProject();
            inspRsvrProject.setId(UuidUtil.uuid());
            inspRsvrProject.setPoorCountry(obj.getPoor());
            inspRsvrProject.setRgstrId(inspRsvrRgstr.getRgstrId());
            rsvrProjectService.insert(inspRsvrProject);
        }
    }

    @Autowired
    private BisInspPblmService inspPblmService;
    @Autowired
    private ObjInspPblmsService inspPblmsService;

    @GetMapping("/getPblm/{month}")
    public BaseResponse getPblm(@PathVariable String month) throws Exception {
        Map<String, Object> objectMap = new HashMap<>();
        String filePath = "D:\\data\\" + month + "月小水库附表1-6.xlsx";
        List<PblmObj> rsvrObjList1 = new ArrayList<>();
        List<PblmObj> rsvrObjList = LoadExcel.getPblmObjList(filePath);
        List<AttRsBaseParam> rsBaseParams = new ArrayList<>();
        for (PblmObj pblmObj : rsvrObjList) {
            BisInspAllParam inspAllParam = new BisInspAllParam();
            inspAllParam.setPnm(pblmObj.getProvince() + "组");
            inspAllParam.setId("001");
            inspAllParam.setInspMnth("0" + month);
            inspAllParam.setInspYear("2019");
            inspAllParam.setNm(pblmObj.getRsvrNm());
            BisInspAll bisInspAll = inspAllService.getOne(inspAllParam);
            AttRsBaseParam rsBaseParam = new AttRsBaseParam();
            rsBaseParam.setAdmDivName(pblmObj.getCountry());
            rsBaseParam.setRsName(pblmObj.getRsvrNm());
            rsBaseParam.setEngScal(pblmObj.getGuimo());
            rsBaseParam.setLocation(pblmObj.getProvince());
            String rsAdmName = pblmObj.getOrgNm();
            if ("黑圈水库".equals(pblmObj.getRsvrNm())) {
                System.out.println("停一下");
            }
            if (rsAdmName.contains(pblmObj.getCountry())) {
                rsAdmName = rsAdmName.replace(pblmObj.getCountry(), "");
            }
            rsBaseParam.setRsAdmName(rsAdmName);
            List<AttRsBase> rsBases = attRsBaseService.findRsList(rsBaseParam);
            if (rsBases == null && rsBases.isEmpty()) {
                rsBaseParam.setRsAdmName("");
                rsBases = attRsBaseService.findRsList(rsBaseParam);
            }
            if (rsBases == null && rsBases.isEmpty()) {
                rsBaseParams.add(rsBaseParam);
                rsvrObjList1.add(pblmObj);
                continue;
            }
            for (AttRsBase rsBase : rsBases) {
                BisInspAllObjParam inspAllObjParam = new BisInspAllObjParam();
                inspAllObjParam.setCode(rsBase.getRsCode());
                inspAllObjParam.setId(bisInspAll.getId());
                BisInspAllObj allObj = objService.getBy(inspAllObjParam);
                if (allObj == null) {
                    allObj = new BisInspAllObj();
                    allObj.setId(bisInspAll.getId());
                    allObj.setCode(rsBase.getRsCode());
                    allObj.setLgtd(Double.parseDouble(rsBase.getCenterXGd()));
                    allObj.setLttd(Double.parseDouble(rsBase.getCenterYGd()));
                    allObj.setLgtdpc(Double.parseDouble(rsBase.getCenterX()));
                    allObj.setLttdpc(Double.parseDouble(rsBase.getCenterY()));
                    allObj.setObjId(UuidUtil.uuid());
                    allObj.setNm(rsBase.getRsName());
                    allObj.setPtype("1");
                    objService.insert(allObj);
                    String rgstrId = UuidUtil.uuid();
                    BisInspRsvrRgstr inspRsvrRgstr = new BisInspRsvrRgstr();
                    inspRsvrRgstr.setEngScal(rsBase.getEngScal());
                    inspRsvrRgstr.setRgstrId(rgstrId);
                    inspRsvrRgstr.setReverStat("2");
                    inspRsvrRgstr.setObjId(allObj.getObjId());

                    inspRsvrRgstr.setRsvrAdmName(rsBase.getRsAdmName());
                    inspRsvrRgstr.setTotCap(rsBase.getTotCap());
                    inspRsvrRgstr.setRsCode(rsBase.getRsCode());
                    inspRsvrRgstr.setIntm(new Date());
                    inspRsvrRgstr.setUptm(new Date());
                    inspRsvrRgstr.setLocation(rsBase.getLocation());
                    inspRsvrRgstr.setDamType(rsBase.getDamType());
                    inspRsvrRgstr.setAdCode(rsBase.getAdmDiv());
                    inspRsvrRgstr.setState("2");
                    inspRsvrRgstr.setCompDateStr(rsBase.getCompDateStr());
                    inspRsvrRgstr.setHystSite(rsBase.getRsLoc());
                    inspRsvrRgstr.setRsvrLat(Double.parseDouble(rsBase.getCenterYGd()));
                    inspRsvrRgstr.setRsvrLong(Double.parseDouble(rsBase.getCenterXGd()));
                    inspRsvrRgstr.setRsvrNm(rsBase.getRsName());
                    rsvrRgstrService.insert(inspRsvrRgstr);
                }
                BisInspRsvrRgstrParam inspRsvrRgstrParam = new BisInspRsvrRgstrParam();
                inspRsvrRgstrParam.setObjId(allObj.getObjId());
                inspRsvrRgstrParam.setRsCode(rsBase.getRsCode());
                BisInspRsvrRgstr bisInspRsvrRgstr = rsvrRgstrService.getBy(inspRsvrRgstrParam);
                ObjInspPblmsParam inspPblmsParam = new ObjInspPblmsParam();
                String snNum = pblmObj.getSnNum();
                if (snNum.contains(".")) {
                    snNum = pblmObj.getSnNum().substring(0, pblmObj.getSnNum().indexOf("."));
                }
                inspPblmsParam.setSnNum(snNum);
                String attach = pblmObj.getAttach().replace("附件", "");
                inspPblmsParam.setAttach(attach);
                inspPblmsParam.setInspPblmCate(pblmObj.getPblmCate());
                inspPblmsParam.setType(allObj.getPtype());
                //金结构机电设备
                String checkPoint = pblmObj.getCheckPoint().replaceAll("[\\t\\n\\r]", "");
                if ("工程维修".equals(checkPoint)) {
                    checkPoint = "工程维护";
                }
                if ("金结构机电设备".equals(checkPoint)) {
                    checkPoint = "金结机电设备";
                }
                inspPblmsParam.setCheckPoint(checkPoint);
                ObjInspPblms objInspPblms = inspPblmsService.getBy(inspPblmsParam);
                if (objInspPblms == null) {
                    System.out.println(objInspPblms.getInspPblmsName());
                    continue;

                }
                BisInspPblm bisInspPblm = new BisInspPblm();
                bisInspPblm.setPblmId(UuidUtil.uuid());
                bisInspPblm.setObjId(allObj.getObjId());
                bisInspPblm.setRegid(bisInspRsvrRgstr.getRgstrId());
                bisInspPblm.setObjType("1");
                bisInspPblm.setVillType("0");
                bisInspPblm.setPblmsTypeId(objInspPblms.getGuid());
                bisInspPblm.setInspPblmCate(pblmObj.getPblmCate());
                bisInspPblm.setInspPblmName(pblmObj.getPblmName());
                bisInspPblm.setInspPblmDesc(pblmObj.getPblmDesc());
                bisInspPblm.setInspPblmCode(pblmObj.getSnNum());
                bisInspPblm.setCollTime(bisInspRsvrRgstr.getIntm());
//            inspPblmService.insert(bisInspPblm);
            }

        }
        objectMap.put("count", rsvrObjList1.size());
        objectMap.put("data", rsvrObjList1);
        return buildSuccessResponse(objectMap);
    }

    public String getAdCd(String sheng, String shi, String xian) {
        String adCd = "";
        AttAdXBaseParam attAdXBaseParam = new AttAdXBaseParam();
        AttAdXBase attAdXBase;
        if (StringUtils.isNotBlank(sheng)) {
            attAdXBaseParam.setAdName(sheng);
            attAdXBaseParam.setAdGrad("2");
            attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if (attAdXBase != null) {
                String shengCode = attAdXBase.getAdCode();
                attAdXBaseParam.setAdFcode(shengCode);
                adCd = shengCode;
            } else {
                attAdXBaseParam.setAdName("");
                attAdXBaseParam.setAdFullName(sheng);
                attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
                if (attAdXBase != null) {
                    String shengCode = attAdXBase.getAdCode();
                    attAdXBaseParam.setAdFcode(shengCode);
                    adCd = shengCode;
                }
            }
        }
        if (StringUtils.isNotBlank(shi)) {
            attAdXBaseParam.setAdName(shi);
            attAdXBaseParam.setAdGrad("3");
            attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if (attAdXBase != null) {
                String shiCode = attAdXBase.getAdCode();
                attAdXBaseParam.setAdFcode(shiCode);
                adCd = shiCode;
            } else {
                attAdXBaseParam.setAdName("");
                attAdXBaseParam.setAdFullName(shi);
                attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
                if (attAdXBase != null) {
                    String shiCode = attAdXBase.getAdCode();
                    attAdXBaseParam.setAdFcode(shiCode);
                    adCd = shiCode;
                }
            }
        }
        if (StringUtils.isNotBlank(xian)) {
            attAdXBaseParam.setAdName(xian);
            attAdXBaseParam.setAdGrad("4");
            attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if (attAdXBase != null) {
                adCd = attAdXBase.getAdCode();
            } else {
                attAdXBaseParam.setAdName("");
                attAdXBaseParam.setAdFullName(xian);
                attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
                if (attAdXBase != null) {
                    adCd = attAdXBase.getAdCode();
                }
            }
        }
        return adCd;
    }

    public Map<String, String> getAdCds(String sheng, String shi, String xian) {
        Map<String, String> map = new HashMap<>();
        String adCd = "";
        AttAdXBaseParam attAdXBaseParam = new AttAdXBaseParam();
        attAdXBaseParam.setAdName(sheng);
        attAdXBaseParam.setAdGrad("2");
        AttAdXBase attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
        if (attAdXBase != null) {
            String shengCode = attAdXBase.getAdCode();
            attAdXBaseParam.setAdFcode(shengCode);
            adCd = shengCode;
            map.put("sheng", shengCode);
        } else {
            attAdXBaseParam.setAdName("");
            attAdXBaseParam.setAdFullName(sheng);
            attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if (attAdXBase != null) {
                String shengCode = attAdXBase.getAdCode();
                attAdXBaseParam.setAdFcode(shengCode);
                adCd = shengCode;
                map.put("sheng", shengCode);
            }
        }
        if (StringUtils.isBlank(shi)) {
            shi = "市辖区";
        }
        if (StringUtils.isNotBlank(shi)) {
            attAdXBaseParam.setAdName(shi);
            attAdXBaseParam.setAdGrad("3");
            attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if (attAdXBase != null) {
                String shiCode = attAdXBase.getAdCode();
                attAdXBaseParam.setAdFcode(shiCode);
                adCd = shiCode;
                map.put("shi", shiCode);
            } else {
                attAdXBaseParam.setAdName("");
                attAdXBaseParam.setAdFullName(shi);
                attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
                if (attAdXBase != null) {
                    String shiCode = attAdXBase.getAdCode();
                    attAdXBaseParam.setAdFcode(shiCode);
                    adCd = shiCode;
                    map.put("shi", shiCode);
                }
            }
        }
        if (StringUtils.isNotBlank(xian)) {
            attAdXBaseParam.setAdName(xian);
            attAdXBaseParam.setAdGrad("4");
            attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if (attAdXBase != null) {
                adCd = attAdXBase.getAdCode();
                map.put("xian", adCd);
            } else {
                attAdXBaseParam.setAdName("");
                attAdXBaseParam.setAdFullName(xian);
                attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
                if (attAdXBase != null) {
                    adCd = attAdXBase.getAdCode();
                    map.put("xian", adCd);
                }
            }
        }
        return map;
    }

    public Map<String, String> addPers(ExcelInspPersDto persDto) {
        Map<String, String> map = new HashMap<>();
        String sheng = persDto.getGroName();
        String shengCode = getAdCd(sheng, "", "");
        String orgId = persDto.getOrgId();
        String persName = persDto.getHeadman();
        String persId = "";
        String headerNm = persDto.getHeadNm();
        String memeber = persDto.getMembers();
        String memNm = persDto.getMemNm();
        String comPer = persDto.getConPers();
        String comNm = persDto.getConNm();
        persId = this.addOnePers(orgId, persName, headerNm);
        map.put("one", persId);
        persId = this.addOnePers(orgId, memeber, memNm);
        map.put("two", persId);
        persId = this.addOnePers(orgId, comPer, comNm);
        map.put("three", persId);
        return map;
    }

    public String addOnePers(String orgId, String persName, String dpp) {
        String persId = "";
        BisInspAllRlationPersParam persParam = new BisInspAllRlationPersParam();
        persParam.setOrgId(orgId);
        persParam.setPersName(persName);
        List<BisInspAllRlationPers> rlationPers = bisInspAllRlationPersService.findList(persParam);
        if (rlationPers != null && rlationPers.size() > 0) {
            BisInspAllRlationPers rlationPer = rlationPers.get(0);
            persId = rlationPer.getGuid();
        } else {
            persId = UuidUtil.uuid();
            BisInspAllRlationPers rlationPer = new BisInspAllRlationPers();
            rlationPer.setGuid(persId);
            rlationPer.setOrgId(orgId);
            rlationPer.setPersName(persName);
            if (dpp.contains("/")) {
                String[] strs = dpp.split("/");
                for (int i = 0; i < strs.length; i++) {
                    if (i == 0) {
                        rlationPer.setDpnm(strs[0]);
                    } else if (i == 1) {
                        rlationPer.setDppost(strs[1]);
                    }
                }
            } else {
                rlationPer.setDppost(dpp);
            }
            persParam.setPersName("");
            int count = bisInspAllRlationPersService.selectCount(persParam);
            String phone = orgId + String.format("%08", count + 1);//其中0表示补零而不是补空格，6表示至少6位
            rlationPer.setMobilenumb(phone);
            bisInspAllRlationPersService.insert(rlationPer);
        }
        return persId;
    }
}