检测业务的总结

public boolean contractExtra(List<Record> contractExtraRecordList, String payContractName, String payContractNo) {
        // 是否在除外信息里,false:不在
        boolean isOk = false;
        // 遍历
        for (Record ContractRecord : contractExtraRecordList) {
            // 获取除外的合同的信息，合同姓名
            String ContractDefineName = ContractRecord.getStr("defineName");
            // 除外的合同编号
            String extraContractNo = null;
            // 除外的合同名称
            String extraContractName = null;
            // 拆分的数组
            String[] ContractDefineNameArray = null;
            // 获取第一个字符窜
            String firstChar = String.valueOf(ContractDefineName.charAt(0));
            if (firstChar.equals(";")) {
                ContractDefineNameArray = ContractDefineName.split(";");
                // 除外的合同编号 为空
                extraContractNo = ContractDefineNameArray[0];
                // 除外的合同名称
                extraContractName = ContractDefineNameArray[1];
                // a、定义表合同名称不为空，定义表合同编号为空，定义表合同名称与确认书表合同名称相同
                if (extraContractName != null && extraContractNo == null && extraContractName.equals(payContractName)) {
                    // 检测无问题
                    isOk = true;
                } else {
                    // 检测有问题
                    isOk = false;
                }
            } else {
                // 反之就是第一个不等于 ;
                ContractDefineNameArray = ContractDefineName.split(";");

                // 除外的合同编号
                extraContractNo = ContractDefineNameArray[0];
                // 除外的合同名称
                extraContractName = ContractDefineNameArray[1];
                // b、定义表合同名称为空，定义表合同编号不为空，定义表合同编号与确认书合同编号相同
                if (extraContractName.equals(null)) {
                    if (extraContractNo != null && extraContractName.equals(payContractName)) {
                        // 检测无问题
                        isOk = true;
                    }else {
                        // 检测有问题
                        isOk = false;
                    }
                } else {
                    // c、定义表合同名称与编号不为空，定义表合同名称、编号与确认书表合同名称、编号均相同
                    if (extraContractName.equals(payContractName) && extraContractNo.equals(payContractNo)) {
                        // 检测无问题
                        isOk = true;
                    } else {
                        // 检测有问题
                        isOk = false;
                    }
                }
            }
        }
        return isOk;
    }

public boolean contractExtra(List<Record> contractExtraRecordList, String payContractName, String payContractNo) {
        // 是否在除外信息里,false:不在
        boolean isOk = false;
        // 遍历
        for (Record contractExtraRecord : contractExtraRecordList) {
            // 获取除外信息
            String extraDefineName = contractExtraRecord.getStr("defineName");
            // 除外的合同编号
            String extraContractNo = null;
            // 除外的合同名称
            String extraContractName = null;
            // 获取第一个字符串
            String firstChar = String.valueOf(extraDefineName.charAt(0));
            if (firstChar.equals(";")) {
                // 第一个字符串为";"时,则除外的合同编号为空，只有合同名称
                // 以分号拆分
                String[] ContractDefineNameArray = extraDefineName.split(";");
                // 获取除外的合同名称
                extraContractName = ContractDefineNameArray[1];
                // 除外的合同名称与确认书表合同名称相同
                if (StringUtils.notBlank(extraContractName) && extraContractName.equals(payContractName)) {
                    // 检测无问题
                    isOk = true;
                    break;
                }
            } else {
                // 第一个字符串不为";"时，以分号拆分
                String[] ContractDefineNameArray = extraDefineName.split(";");
                // 除外的合同编号
                extraContractNo = ContractDefineNameArray[0];
                // 除外的合同名称
                extraContractName = ContractDefineNameArray[1];
                // 除外合同名称为空时，这说明除外信息只有合同编号
                if (StringUtils.isBlank(extraContractName)) {
                    if (StringUtils.notBlank(extraContractNo) && extraContractName.equals(payContractName)) {
                        // 检测无问题
                        isOk = true;
                        break;
                    }
                } else {
                    // 除外合同名称不为空时，这说明除外信息既有合同编号也有合同名称
                    // 除外的合同名称、编号与确认书表合同名称、编号均相同
                    if (extraContractName.equals(payContractName) && extraContractNo.equals(payContractNo)) {
                        // 检测无问题
                        isOk = true;
                        break;
                    }
                }
            }
        }
        return isOk;
    }

public boolean coreEnterpriseIdCheck(List<Record> extracoreEnterpriseIdRecordList, String payCoreEnterpriseId) {
        // 是否在除外信息里,false:不在
        boolean checkResut = false;
        // 遍历
        for (Record extracoreEnterpriseIdRecord : extracoreEnterpriseIdRecordList) {
            //获取除外的项目公司
            String extracoreEnterpriseId = extracoreEnterpriseIdRecord.getStr("defineName");
            //获取付款确认书的项目公司名称
            if (extracoreEnterpriseId.equals(payCoreEnterpriseId)) {
                //检测没问题
                checkResut = true;
                break;
            }
        }
        return checkResut ;
    }

    /** 判断项目公司是否除外
     * @param extraItemCompanyNameRecordList 
     *                除外的项目公司的集合
     * @param payItemCompanyName 付款确认书的项目公司名称   
     * @return checkResut   true/false 除外/没除外
     * 
     */
    public boolean itemCompanyNameCheck(List<Record> extraItemCompanyNameRecordList, String payItemCompanyName) {
        // 是否在除外信息里,false:不在
        boolean checkResut = false;
        // 遍历
        for (Record extraItemCompanyNameRecord : extraItemCompanyNameRecordList) {
            //获取除外的项目公司
            String extraItemCompanyName = extraItemCompanyNameRecord.getStr("defineName");
            //获取付款确认书的项目公司名称
            if (payItemCompanyName.equals(extraItemCompanyName)) {
                //检测没问题
                checkResut = true;
                break;
            }
        }
        return checkResut ;
    }

/** 判断pdf定义合同信息与付款确认书合同信息是否相同
     * @param pdfContractNo 
     *                 pdf定义的合同编号
     * @param pdfContractName
     *                 pdf的合同名称
     * @param payContractNo
     *                 付款确认书的合同编号
     * @param payContractName   
     *                 付款确认书的合同名称
     * @return checkResut true/false 相同/不相同
     */
    public boolean contractCheck(String pdfContractNo, String pdfContractName, String payContractNo, String payContractName) {
        boolean checkResut = false;
        //a、定义表合同名称不为空，定义表合同编号为空，定义表合同名称与确认书表合同名称相同
        if ( StringUtils.notBlank(pdfContractName)  && StringUtils.isBlank(pdfContractNo) &&  pdfContractName.equals(payContractName) ) {
            //检测冲突
            checkResut = true ; 
        }
        //b、定义表合同名称为空，定义表合同编号不为空，定义表合同编号与确认书合同编号相同
        else if ( StringUtils.isBlank(pdfContractName) &&  StringUtils.notBlank(pdfContractNo)  &&  pdfContractNo.equals(payContractNo)) {
            //检测冲突
            checkResut = true ; 
        }
        //c、定义表合同名称与编号不为空，定义表合同名称、编号与确认书表合同名称、编号均相同
        else if (StringUtils.notBlank(pdfContractName)  &&  StringUtils.notBlank(pdfContractNo)  &&  pdfContractName.equals(payContractName) &&
            pdfContractNo.equals(payContractNo)    ) {
            //检测冲突
            checkResut = true ; 
        }
        return checkResut ;
    }
    

/** 判断保理申请日是否在开始日结束日时间段内
     * @param startDate 
     *                 开始日
     * @param endDate
     *                 结束日
     * @param transferApplyDate
     *                 保理申请日期
     * @param checkResut   true/false 是/否
     */
    public boolean commonDateWays(Date startDate,  Date endDate, Date transferApplyDate) {
        boolean checkResut = false;
        //a、开始日期不为空，结束日期为空，保理申请日期大于开始日期                                                
        if (startDate !=null && endDate == null && transferApplyDate.getTime()> startDate.getTime()){
            // 保理申请日在开始日结束日时间段内
            checkResut = true ; 
        // b、结束日期不为空，开始日期为空，保理申请日期小于结束日期
        }else if (startDate ==null && endDate !=null && transferApplyDate.getTime() < endDate.getTime()){
                // 保理申请日在开始日结束日时间段内
                checkResut = true ; 
        // c、开始和结束日期均不为空，保理申请日期在开始和结束日期之间
        }else if (startDate !=null && endDate !=null && (transferApplyDate.getTime()> startDate.getTime() && 
                    transferApplyDate.getTime() <endDate.getTime())) {
            // 保理申请日在开始日结束日时间段内
            checkResut = true ; 
        }
        return checkResut ;
    }

/**
     *  校验发票号码
     *  2018年10月11日13:55:13
     *  @param pdfRecord 付款确认书对象
     *  @param invoiceNos  获取pdf定义的发票信息，即发票号
     *  @param suppliersName  供应商的name
     */
    public boolean checkoutInvoiceNo( String suppliersName,String invoiceNo ,String registerNumber) {
        //定义一个检测发票成功与否的标志位
        boolean checkResut = true;
        // 将发票号码字符串去掉所有空格
        invoiceNo.replace(" ", "");
        // pdf定义表数据发票号码不为空
        if (StringUtils.notBlank(invoiceNo)) {
            // 全角字符->半角字符 
            invoiceNo = BCConvertUtils.qj2bj(invoiceNo);
            String[] pdfInvoiceArr = invoiceNo.split(",");
            for (int k = 0; k < pdfInvoiceArr.length; k++) {
                // 如果invoiceNoArr的保存格式【111-222】,处理要分开
                if (pdfInvoiceArr[k].contains("-")) {
                    String[] invoiceNoLine = pdfInvoiceArr[k].split("-");
                    if (invoiceNoLine.length > 1) {
                        int numberOne = 0;
                        int numberEnd = 0;
                        // 将含有"-"的发票号顺番
                        // 获取字符串长度
                        if (!(invoiceNoLine[0].length() == invoiceNoLine[1].length())) {
                            // 数据校验不通过
                            AssertUtils.isTrue(false, "【" + suppliersName + "】<br>登记编号: "
                                    + registerNumber + "<br>的发票号码‘-‘两边的数据长度不相等");
                            checkResut = false;
                            break;
                        } else {
                            numberOne = Integer.parseInt(invoiceNoLine[0]);
                            numberEnd = Integer.parseInt(invoiceNoLine[1]);
                            if (numberOne > numberEnd) {
                                AssertUtils.isTrue(false, "【" + suppliersName + "】<br>登记编号: "
                                        + registerNumber + "<br>的前发票号码不能大于后发票号码");
                                checkResut = false;
                            }
                        }
                    }
                }
            }
        }

        return checkResut;
    }
    

/** 将发票号码字符串转换成发票号码List
     * @param  invoiceNo  pdf发票号码 
     * @param   pdfRecord   pdf对象
     * @param   suppliersName   供应商name
     */
    private List<String> getPdfInvoiceNoWays(String invoiceNo, Record pdfRecord, String suppliersName) {
        // 将发票号码字符串去掉所有空格
        invoiceNo.replace(" ", "");
        // 全角字符->半角字符 
        invoiceNo = BCConvertUtils.qj2bj(invoiceNo);
        // 先以","来分割字符串
        String[] invoiceNoComma = invoiceNo.split(",");
        // 定义发票号码List
        List<String> invoiceNoList = Lists.newArrayList();
        // 当发票号码格式等条件都正确时, 验证是否存在重复的发票号码
        //遍历数组
        for (int i = 0; i < invoiceNoComma.length; i++) {
            //再以"-"来分割字符串
            String[] invoiceNoLine = invoiceNoComma[i].split("-");
            // 若invoiceNoLine长度大于1,则需要顺番添加
            if(invoiceNoLine.length > 1)
            {
                //将含有"-"的发票号顺番
                // 获取字符串长度
                int length = invoiceNoLine[0].length();
                // 格式转化
                int numberOne = Integer.parseInt(invoiceNoLine[0]);
                int numberEnd = Integer.parseInt(invoiceNoLine[1]);
                int number = 0;
                // 将数字顺序添加进列表
                for (int j = 0; j <= numberEnd - numberOne; j++) {
                    if (j > 0) {
                        number = numberOne + j;
                    } else {
                        number = numberOne;
                    }
                    // 在字符串的左边补零
                    String invoiceNoRepair = String.format("%0" + length + "d", number);
                    // 添加进列表
                    invoiceNoList.add(invoiceNoRepair);
                }
            } else{
                invoiceNoList.add(invoiceNoLine[0]);
            }
        }
        // 判断数组中是否存在重复的发票号码
        for(int i = 0; i< invoiceNoList.size(); i++){
            for(int j = i+1; j<invoiceNoList.size(); j++){
                if(invoiceNoList.get(i).equals(invoiceNoList.get(j))){
                    // 数据校验不通过
                    AssertUtils.isTrue(false, "【" + suppliersName + "】<br>登记编号: "
                            + pdfRecord.getStr("registerNumber") + "<br>存在重复的发票号码");
                    break;
                }
            }
        }
        return  invoiceNoList  ;
    }
    
    

    /**
     * 检测发票号码
     * 2018年10月10日19:34:40
     *  @param payInfoRecord 付款确认书对象
     *  @param pdfRecord  pdf对象
     *  @param invoiceNos  获取pdf定义的发票信息，即发票号
     *  @param suppliersName  供应商的name
     *  @param uuid   pdfDefine(定义表的uuid)
     * @return
     * @throws ActiveRecordException 
     */
    public boolean checkInvoiceWays(Record payInfoRecord ,Record pdfRecord ) throws ActiveRecordException {
        //获取pdf出让人表的uuid
        String pdfGrantorPledgorInfosUuid = pdfRecord.getStr("grantorPledgorInfosUuid"); 
        // 获取付款确认书供应商的name
        String suppliersName=payInfoRecord.getStr("suppliersName");
        //获取注册号码
        String registerNumber =pdfRecord.getStr("registerNumber");
        //获取pdf自定义的发票号码
        String pdfDefineInvoiceNo=pdfRecord.getStr("invoiceNo");
        //校验发票号码格式是否正确
        boolean InvoicecheckResut= this.checkoutInvoiceNo(suppliersName,pdfDefineInvoiceNo,registerNumber);
        //定义一个检测结果的标志位
        boolean checkResut = true;
        if (InvoicecheckResut) {
            //获取付款确认书的发票号码
            String payInfoNo=payInfoRecord.getStr("invoiceNo");    
            String[] payInfoNoArr = payInfoNo.split(",");
            // 定义一个String集合，来存有冲突的发票号码
            List<String> clashInvoiceNoList= new ArrayList<String>();
            // 将pdf的发票号码字符串转换成发票号码List
            List<String> pdfInvoiceList = this.getPdfInvoiceNoWays(pdfDefineInvoiceNo,pdfRecord ,suppliersName);
            // 获取 付款确认书与pdf定义 相同的发票号码
            for (int i = 0; i < payInfoNoArr.length; i++) {
                for (String pdfInvoice : pdfInvoiceList) {
                    //存在相同
                    if(payInfoNoArr[i].equals(pdfInvoice)){
                        clashInvoiceNoList.add(payInfoNoArr[i]);
                    }
                }
            }
            // 如果存在冲突的发票号码
             if (clashInvoiceNoList !=null &&  clashInvoiceNoList.size() > 0 ) {
                 // 除外的发票号码的容器
                 List<String> pdfExtraInvoiceNoList = new ArrayList<String>();
                 //调用获取除外的信息的方法，获取除外的发票号码
                 List<Record> pdfDefineExtraInvoiceNoCheck = this.getPdfDefineExtra(pdfGrantorPledgorInfosUuid,"05");
                 // 发票除外号码不为空
                 if (pdfDefineExtraInvoiceNoCheck !=null && pdfDefineExtraInvoiceNoCheck.size() > 0) {
                     //遍历它
                     for (Record pdfDefineExtraRecord : pdfDefineExtraInvoiceNoCheck) {
                        // 获取除外的发票号码
                        String exceptInvoiceNo = pdfDefineExtraRecord.getStr("defineName"); 
                        // 校验发票号码格式是否正确
                        boolean InvoiceCheck = this.checkoutInvoiceNo(suppliersName,exceptInvoiceNo,registerNumber);
                        //如果通过
                        if (InvoiceCheck) {
                             // 将除外的发票号码字符串转换成发票号码List
                             List<String> pdfExtraInvoiceList = this.getPdfInvoiceNoWays(exceptInvoiceNo,pdfRecord ,suppliersName);
                             for (String pdfExtraInvoice : pdfExtraInvoiceList) {
                                 pdfExtraInvoiceNoList.add(pdfExtraInvoice);
                            }
                        }
                    }
                    // 判断有冲突的发票号码 在除外的发票号码中 是否都存在：
                    for (String clashInvoiceNo : clashInvoiceNoList) {// 有冲突的发票号码
                        //是否在除外发票中存在的标志位
                        boolean isok = false;
                        for (String extraInvoiceNo : pdfExtraInvoiceNoList) {// 除外的发票号码
                            if (extraInvoiceNo.equals(clashInvoiceNo)) {
                                isok = true; // 存在
                                break;
                            }
                        }
                        // 不存在,检测有问题
                        if (!isok) {
                            checkResut = false;
                            break;
                        }
                    }
                } else {
                    // 发票除外信息为空，检测有问题；
                    checkResut = false;
                }
            } else {
                // 不存在相同，则不冲突,检测无问题；
                checkResut = true;
            }
        }
        return checkResut;
    }

/**
     * 付款确认书中登检测
     * 2018年10月10日14:11:25
     * @param payInfoList  付款确认书
     * @throws ActiveRecordException
     * @throws ParseException 
     */
    public void doCheckWays(List<Record> payInfoList) throws ActiveRecordException, ParseException {
        // 遍历待检测数据
        for (Record payInfoRecord : payInfoList) {
            // 设置有问题的中登pdf定义表UUID
            String pdfDefineUuid = "";
            // 查询付款确认书对应供应商是否有曾用名
            List<Record> suppliersNameHistoryList = Db.find("SELECT distinct suppliers_name"
                    +"    FROM biz_suppliers_name_history"
                    +"    WHERE sys_status = 1"
                    +"    AND suppliers_name is not null AND suppliers_name!=‘‘"
                    +"    AND suppliers_id =?",payInfoRecord.getStr("suppliersId"));
            // 如果供应商曾用名不为空
            if (suppliersNameHistoryList != null && suppliersNameHistoryList.size() > 0) {
                for (Record suppliersNameHistory : suppliersNameHistoryList) {
                    // 获取供应商的名称
                    String suppliersName = suppliersNameHistory.getStr("suppliersName");
                    // 出让人的pdf中登定义冲突检测,获取有冲突的pdf定义表UUID
                    String checkPdfDefineUuid = suppliersNamePdfDefineCheck(suppliersName, payInfoRecord);
                    if (StringUtils.notBlank(checkPdfDefineUuid)) {
                        pdfDefineUuid = StringUtils.isBlank(pdfDefineUuid) ? (checkPdfDefineUuid) : (pdfDefineUuid + "," + checkPdfDefineUuid);
                    }
                }
            }
            // 若供应商曾用名信息表数据为空，直接以供应商信息表的供应商名称去做检测
            else {
                // 获取供应商信息表的供应商名称
                String suppliersName = payInfoRecord.getStr("suppliersName");
                // 出让人的pdf中登定义冲突检测,获取有冲突的pdf定义表UUID
                pdfDefineUuid = suppliersNamePdfDefineCheck(suppliersName, payInfoRecord);
            }

            // 定义一个该付款确认书检测是否无问题的标记位 true 没有问题 false 有问题
            String result = null;
            // 若 pdfDefineUuid 为空，则标记该付款确认书检测结果无问题，否则标记为有问题；
            if (StringUtils.isBlank(pdfDefineUuid)) {
                // 检测结果：正确
                result = CHECK_RESULT_0;
            } else {
                // 检测结果：错误
                result = CHECK_RESULT_1;
            }

            // 存在有疑问的中登资产信息，检测不通过
            payInfoRecord.set("checkResult", result);
            payInfoRecord.set("pdfDefineUuid", pdfDefineUuid);
        }
    }
    
    /** 出让人pdf定义冲突检测
     * @param suppliersName 
     *                 供应商的名称
     * @param payInfoRecord
     *                 付款确认书的对象
     * @throws ActiveRecordException 
     * @throws ParseException 
     */
    public String suppliersNamePdfDefineCheck(String suppliersName, Record payInfoRecord) throws ActiveRecordException, ParseException {
        // 设置有问题的中登信息ID
        String pdfDefineUuid = "";
        // 通过suppliersName 去获取审核通过的pdf定义信息表（pdfRecordList）的数据
        List<Record> pdfRecordsList = this.getPdfDefineInfosBysupplier(suppliersName);
        // 若获取的数据不为空
        if (pdfRecordsList !=null && pdfRecordsList.size() >0) {
            //遍历pdf定义信息表（pdfRecordList）的数据
            for (Record pdfRecord : pdfRecordsList) {
                // 获取pdf定义的发票信息，即发票号
                String invoiceNoPdfDefine = pdfRecord.getStr("invoiceNo");
                // 获取pdf定义的合同编号、合同名称
                String contractNoPdfDefine = pdfRecord.getStr("contractNo");
                String contractNamePdfDefine = pdfRecord.getStr("contractName");
                // 获取pdf定义的项目公司名称
                String pdfItemCompanyName = pdfRecord.getStr("itemCompanyName");
                // 获取pdf定义的核心企业名称
                String coreEnterpriseId = pdfRecord.getStr("coreEnterpriseId");
                // 发票号不为空时
                if (StringUtils.notBlank(invoiceNoPdfDefine) && invoiceNoPdfDefine.length() >0 ) {
                    // 检查pdf定义的发票和付款确认书发票是否有问题
                    boolean checkResutInvoice = this.checkInvoiceWays(payInfoRecord, pdfRecord);
                    // 如果为false, 则检测出有问题
                    if (!checkResutInvoice) {
                        // 检测不通过,记录有问题的pdf定义表UUID
                        pdfDefineUuid = StringUtils.isBlank(pdfDefineUuid) ? ("‘" + pdfRecord.getStr("uuid") + "‘")
                                : (pdfDefineUuid + ",‘" + pdfRecord.getStr("uuid") + "‘");
                        continue;
                    }else {
                        // 为true，检测没有问题，直接进行下一次循环
                        continue;
                    }
                }
                // pdf定义的合同编号、合同名称不同时为空时
                else if(StringUtils.isBlank(invoiceNoPdfDefine) && (StringUtils.notBlank(contractNoPdfDefine) || StringUtils.notBlank(contractNamePdfDefine))){
                    // 检查定义的合同编号、名称和付款确认书的合同编号、名称是否有问题
                    boolean checkResutContract=this.CheckContractWays(payInfoRecord,pdfRecord);
                    // 如果为false, 则检测出有问题
                    if (!checkResutContract) {
                        // 检测不通过,记录有问题的pdf定义表UUID
                        pdfDefineUuid = StringUtils.isBlank(pdfDefineUuid) ? ("‘" + pdfRecord.getStr("uuid") + "‘")
                                : (pdfDefineUuid + ",‘" + pdfRecord.getStr("uuid") + "‘");
                        continue;
                    }else {
                        // 为true，检测没有问题，直接进行下一次循环
                        continue;
                    }
                }
                // pdf定义的项目公司不为空时
                else if(StringUtils.isBlank(contractNoPdfDefine) && StringUtils.isBlank(contractNamePdfDefine)
                        && StringUtils.notBlank(pdfItemCompanyName)) {
                    // 项目公司检测
                    boolean checkItemCompany = this.checkItemCompanyWays(payInfoRecord,pdfRecord);
                    // 如果为false, 则检测出有问题
                    if (!checkItemCompany) {
                        // 检测不通过,记录有问题的pdf定义表UUID
                        pdfDefineUuid = StringUtils.isBlank(pdfDefineUuid) ? ("‘" + pdfRecord.getStr("uuid") + "‘")
                                : (pdfDefineUuid + ",‘" + pdfRecord.getStr("uuid") + "‘");
                        continue;
                    }else {
                        // 为true，检测没有问题，直接进行下一次循环
                        continue;
                    }
                }
                // pdf定义的核心企业名称不为空时
                else if(StringUtils.isBlank(pdfItemCompanyName) && StringUtils.notBlank(coreEnterpriseId)) {
                    //不为空时：检查定义的核心企业名称和付款确认书的核心企业名称是否有冲突
                    boolean checkCoreEnterprise=this.checkCoreEnterpriseWays(payInfoRecord,pdfRecord);
                    // 如果为false, 则检测出有问题
                    if ( !checkCoreEnterprise) {
                        // 检测不通过,记录有问题的pdf定义表UUID
                        pdfDefineUuid = StringUtils.isBlank(pdfDefineUuid) ? ("‘" + pdfRecord.getStr("uuid") + "‘")
                                : (pdfDefineUuid + ",‘" + pdfRecord.getStr("uuid") + "‘");
                        continue;
                    }else {
                        //为true，检测没有问题，直接进行下一次循环
                        continue;
                    }
                // pdf定义的开始日、结束日信息 
                }else {
                    // 获取pdf定义的开始日、结束日信息
                    Date startDate = pdfRecord.getDate("startDate");
                    Date endDate = pdfRecord.getDate("endDate");
                    // 保理申请日期
                    Date transferApplyDate = payInfoRecord.getDate("transferApplyDate");
                    // 定义的开始日、结束日不为空时
                    if (startDate != null && endDate != null ) {
                        // 检查定义的开始日、结束日和付款确认书保理申请日期是否有冲突
                        boolean checkDate = this.commonDateWays(startDate, endDate, transferApplyDate);
                        // 如果为false, 则检测出有问题
                        if ( !checkDate) {
                            // 检测不通过,记录有问题的pdf定义表UUID
                            pdfDefineUuid = StringUtils.isBlank(pdfDefineUuid) ? ("‘" + pdfRecord.getStr("uuid") + "‘")
                                    : (pdfDefineUuid + ",‘" + pdfRecord.getStr("uuid") + "‘");
                            continue;
                        }else {
                            //为true，检测没有问题，直接进行下一次循环
                            continue;
                        }
                    }else {
                        //为空时：进行下一次循环；
                        continue;
                    }
                }
            }
        }
        return pdfDefineUuid ;
    }

    /**
     * 核心企业检测
     * 
     * @param pdfRecord 定义表数据
     * @param payRecord 确认书表数据
     * @return true：检测通过 false：检测不通过
     * @throws ParseException 
     * @throws ActiveRecordException 
     */
    private boolean checkCoreEnterpriseWays(Record payRecord ,Record pdfRecord) throws ParseException, ActiveRecordException {
        //定义一个检测发票冲不冲突的标志位  false 冲突  true 不冲突
        boolean checkResut = true;
        //定义一个检测有无问题的标志位 false 有问题  true 没有问题
        boolean isOk=true;
        //获取pdf定义表数据的开始日，结束日
        Date startDate = pdfRecord.getDate("startDate");
        Date endDate= pdfRecord.getDate("endDate");  
        //获取保理申请日期 transfer_apply_date
        Date transferApplyDate=payRecord.getDate("transferApplyDate");
        
        //获取pdf的核心企业id
        String pdfCoreEnterpriseId = pdfRecord.getStr("coreEnterpriseId");
        //获取付款确认书的核心企业id
        String payCoreEnterpriseId = payRecord.getStr("coreEnterpriseId");
        
        
        //1、开始日、结束日有不为空的时，下面情况下检测冲突：
        if (startDate !=null || endDate !=null) {
            // 保理申请日在开始日结束日时间段内时
            if(commonDateWays(startDate,endDate, transferApplyDate)) {
                // 判断pdf项目公司信息和付款确认书的项目公司信息是否相同
                if(pdfCoreEnterpriseId.equals(payCoreEnterpriseId)) {
                    // 相同时检测冲突
                    checkResut = false; 
                }
            }
        }else {
            // 判断pdf项目公司信息和付款确认书的项目公司信息是否相同
            if(pdfCoreEnterpriseId.equals(payCoreEnterpriseId)) {
                // 相同时检测冲突
                checkResut = false; 
            }
        }
        
        //3、第1、2点检测冲突时，查询发票除外信息：
        if (!checkResut) {
            // 获取供应商的name
            String suppliersName=payRecord.getStr("suppliersName");
            // 获取pdf转让人表UUID
            String pdfGrantorPledgorInfosUuid = pdfRecord.getStr("grantorpledgorinfosuuid");
            
            //调用获取除外的信息的方法，获取除外的发票号码
            List<Record> pdfDefineExtraInvoiceNoCheck=this.getPdfDefineExtra(suppliersName, pdfGrantorPledgorInfosUuid,"05");
            //发票除外信息为空，
            if (pdfDefineExtraInvoiceNoCheck.size()== 0 ) {
                // 查询合同除外信息：
                List<Record> contractExtraRecordList=this.getPdfDefineExtra(suppliersName, pdfGrantorPledgorInfosUuid,"04");
                //合同除外信息为空
                if(contractExtraRecordList.size()==0){
                    //查询项目公司除外信息 
                    List<Record> extraItemCompanyNameRecordList = this.getPdfDefineExtra(suppliersName, pdfGrantorPledgorInfosUuid,"02");
                    // 项目公司除外信息为空，检测有问题；
                    if (extraItemCompanyNameRecordList.size()==0) {
                        //查询核心企业除外信息：
                        List<Record> extraCoreEnterpriseIdRecordList = this.getPdfDefineExtra(suppliersName, pdfGrantorPledgorInfosUuid,"01");
                        
                        //核心企业除外信息为空，检测有问题；
                        if (extraCoreEnterpriseIdRecordList.size()==0) {
                            //检测有问题；
                            isOk = false ;
                        }else {
                            //核心企业除外信息不为空，且除外的核心企业和付款确认书的核心企业相同，检测没问题；
                            isOk = coreEnterpriseIdCheck(extraCoreEnterpriseIdRecordList,payCoreEnterpriseId);
                        }
                    }
                    // 项目公司除外信息不为空，且除外的项目公司名称和付款确认书的项目公司名称相同，检测没问题；
                    else {
                        //获取付款确认书表数据的项目公司
                        String payItemCompanyName = payRecord.getStr("itemCompanyName");
                        isOk = itemCompanyNameCheck(extraItemCompanyNameRecordList,payItemCompanyName);
                    }
                }
                // 合同除外信息不为空，除外的合同信息和付款确认书的合同信息相同（判断是否相同的方式同第2点）时，检测无问题；否则检测有问题
                else {
                    // TODO 调用合同除外检测共通方法
                    String payContractNo = payRecord.getStr("contractNo");
                    String payContractName = payRecord.getStr("contractName");
                    isOk=this.contractExtra(contractExtraRecordList, payContractName, payContractNo);
                }
            }
            //发票除外信息不为空
            else {
                // 调用检测发票除外的的共通方法
                isOk = this.commonExceptInvoiceWays(pdfDefineExtraInvoiceNoCheck, payRecord,pdfRecord);
            }
        }else {
            //4、第1、2点检测不冲突时，则检测无问题；
        }
        return isOk;
    }