using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using ESRI.ArcGIS.Geodatabase;
using Kingo.RuleCheck.XJRuleCheck;

namespace Kingo.RuleCheck
{
    /// <summary>
    /// 单图斑建库人工核查
    /// </summary>
    public class RGJCCheck : RuleCheckBase_DTB
    {

        List<string> ruleMethodNames = new List<string> {
        "DDTC301","DDTC302","DDTC303","DDTC304","DL301","DL302","DL303","GD301","GD302","GD303","GD304","GD305","SX301","SX302","SX303","JSYD301","JSYD302","JSYD303","QT301","QT302","MS001","JW001","BB001","BB002","QT303","DDTC305","DDTC306","HCD001"       
        };

        public override List<RuleEntity> ExcuteCheck(string sourePath, IWorkspace workspace)
        {
            return this.StartCheck(sourePath, workspace, ruleMethodNames);
        }

        public override List<RuleEntity> ExcuteCheck(string sourePath, Dictionary<string, IFeatureClass> workspace)
        {
            return this.StartCheck(sourePath, workspace, ruleMethodNames);
        }

        public override List<RuleEntity> ExcuteCheck(IWorkspace workspace, List<string> layerNames, List<string> dataSetNames)
        {
            return this.StartCheck(workspace, ruleMethodNames, layerNames, dataSetNames);
        }

        public override List<RuleEntity> ExcuteCheck(string tbbsm, string sourePath, Dictionary<string, IFeatureClass> workspace)
        {
            return this.StartCheck(tbbsm, sourePath, workspace, ruleMethodNames);
        }

        /// <summary>
        /// 漏斗样式筛选，若已存在该错误则不再添加
        /// </summary>
        /// <param name="rstList"></param>
        private void AddErrors(List<RuleEntity> rstList)
        {
            rstList.ForEach(r =>
            {
                if (AllRGError.FirstOrDefault(t => t.ErrorId == r.ErrorId && !r.ErrorId.StartsWith("规则检查失败")) == null)
                    AllRGError.Add(r);
            });
        }

        /// <summary>
        /// 临时用地图斑检查
        /// </summary>
        /// <param name="dr"></param>
        /// <returns></returns>
        public List<RuleEntity> DDTC301()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and DDTCBZ='1301'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "临时用地图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DDTC301";
                        rst.RuleName = "临时用地图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "临时用地图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DDTC301",
                    RuleName = "临时用地图斑检查"
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 光伏板区图斑检查
        /// </summary>
        /// <param name="dr"></param>
        /// <returns></returns>
        public List<RuleEntity> DDTC302()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DDTCBZ='1302'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "光伏板区图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DDTC302";
                        rst.RuleName = "光伏板区图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "光伏板区图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DDTC302",
                    RuleName = "光伏板区图斑检查"
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 推土区图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> DDTC303()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DDTCBZ='1303'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "推土区图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DDTC303";
                        rst.RuleName = "推土区图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "推土区图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DDTC303",
                    RuleName = "推土区图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 拆除未尽区图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> DDTC304()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DDTCBZ='1304'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "拆除未尽区图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DDTC304";
                        rst.RuleName = "拆除未尽区图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "拆除未尽区图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DDTC304",
                    RuleName = "拆除未尽区图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }


        /// <summary>
        /// 荒草特征图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> DDTC305()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DDTCBZ in ('1306','1307')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "荒草特征图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DDTC305";
                        rst.RuleName = "荒草特征图斑检查";
                        rst.RuleContent = "提取图斑“单独图层代码”字段标记为“1306”“1307”的图斑，纳入人工核查。";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "荒草特征图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DDTC305",
                    RuleName = "荒草特征图斑检查",
                    RuleContent = "提取图斑“单独图层代码”字段标记为“1306”“1307”的图斑，纳入人工核查。",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }
        /// <summary>
        /// 翻土特征图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> DDTC306()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DDTCBZ='1308'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "翻土特征图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DDTC306";
                        rst.RuleName = "翻土特征图斑检查";
                        rst.RuleContent = "提取图斑“单独图层代码”字段标记为“1308”的图斑，纳入人工核查。";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "翻土特征图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DDTC306",
                    RuleName = "翻土特征图斑检查",
                    RuleContent = "提取图斑“单独图层代码”字段标记为“1308”的图斑，纳入人工核查。",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }
        /// <summary>
        /// 荒草地图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> HCD001()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DLBM='0404'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "荒草地图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "HCD001";
                        rst.RuleName = "荒草地图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "荒草地图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "HCD001",
                    RuleName = "荒草地图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }
        /// <summary>
        /// 路面范围图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> DL301()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  DDTCBZ='1305'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "存在路面范围图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DL301";
                        rst.RuleName = "路面范围图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "存在路面范围图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DL301",
                    RuleName = "路面范围图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 一般道路图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> DL302()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE TBBSM='{TBBSM}' and  (DDTCBZ NOT IN ('1301','1302','1303','1304','1305') OR DDTCBZ IS NULL) AND  DLBM IN ('1001','1002','1003','1004','1004A','1006')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "公路图斑和铁路图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DL302";
                        rst.RuleName = "一般道路图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "公路图斑和铁路图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DL302",
                    RuleName = "一般道路图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        public List<RuleEntity> DL303()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  (DDTCBZ NOT IN ('1301','1302','1303','1304','1305') OR DDTCBZ IS NULL) AND  DLBM IN ('1001A','1002A','1003A')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "道路附属设施图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "DL303";
                        rst.RuleName = "一般道路图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "道路附属设施图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "DL303",
                    RuleName = "一般道路图斑检查"
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 耕地升级图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> GD301()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX A LEFT JOIN (SELECT BGHTBBSM,SUM(TBBGMJ) AS BGMJ FROM DTBDLTBGXGC WHERE ((BGQDLBM='0102' OR  BGQDLBM='0103') AND BGHDLBM='0101') OR (BGQDLBM='0103' AND BGHDLBM='0102') GROUP BY BGHTBBSM ) B ON A.BSM=B.BGHTBBSM WHERE  A.TBBSM='{TBBSM}' and ((A.DDTCBZ NOT IN ('1301','1302','1303','1304','1306','1307','1308') OR DDTCBZ IS NULL) OR A.DDTCBZ IS NULL) AND  A.ZZSXDM<>'WG' AND A.DLBM IN ({DLParams.gd_dlbms}) AND  (B.BGMJ/A.TBMJ>0.3 OR B.BGMJ>2000)";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "发生耕地升级的图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "GD301";
                        rst.RuleName = "耕地升级图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    ErrorId = "规则检查失败：" + ex.Message,
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "发生耕地升级的图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "GD301",
                    RuleName = "耕地升级图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 耕地降级图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> GD302()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX A LEFT JOIN (SELECT BGHTBBSM,SUM(TBBGMJ) AS BGMJ FROM DTBDLTBGXGC WHERE ((BGHDLBM='0102' OR  BGHDLBM='0103') AND BGQDLBM='0101') OR (BGQDLBM='0102' AND BGHDLBM='0103') GROUP BY BGHTBBSM ) B ON A.BSM=B.BGHTBBSM WHERE  A.TBBSM='{TBBSM}' and ((A.DDTCBZ NOT IN ('1301','1302','1303','1304','1306','1307','1308') OR DDTCBZ IS NULL) OR A.DDTCBZ IS NULL) AND  A.ZZSXDM<>'WG' AND A.DLBM IN ({DLParams.gd_dlbms}) AND  (B.BGMJ/A.TBMJ>0.3 OR B.BGMJ>2000)";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "发生耕地降低的图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "GD302";
                        rst.RuleName = "耕地降级图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorId = "规则检查失败：" + ex.Message,
                    ErrorTip = "发生耕地降低的图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "GD302",
                    RuleName = "耕地降级图斑检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }


        /// <summary>
        /// 一般耕地图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> GD303()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT * FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM IN ({DLParams.gd_dlbms}) AND ZZSXDM<>'WG' ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "一般耕地图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "GD303";
                        rst.RuleName = "一般耕地图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "一般耕地图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "GD303",
                    RuleName = "一般耕地图斑检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 撂荒耕地上图检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> GD304()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            return rstList;
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and DLBM IN ({DLParams.gd_dlbms}) AND ZZSXDM='WG' AND (DDTCBZ NOT IN ('1301','1302','1303','1304') OR DDTCBZ IS NULL) ";
                //待实现排除 不满足GD101规则图斑 
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "撂荒耕地上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "GD304";
                        rst.RuleName = "撂荒耕地上图检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    ErrorId = "规则检查失败：" + ex.Message,
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "撂荒耕地上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "GD304",
                    RuleName = "撂荒耕地上图检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }


        ///// <summary>
        ///// 荒草地上图检查
        ///// </summary>
        ///// <returns></returns>
        //public List<RuleEntity> GD305()
        //{
        //    List<RuleEntity> rstList = new List<RuleEntity>();
        //    try
        //    {
        //        string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and (DDTCBZ NOT IN ('1301','1302','1303','1304') OR DDTCBZ IS NULL) AND DLBM='0404' AND (ZZSXDM IS NULL OR ZZSXDM='') ";
        //        //待实现排除 不满足GD102规则图斑 
        //        DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
        //        if (dataTable != null)
        //        {
        //            rstList = new List<RuleEntity>();
        //            foreach (DataRow item in dataTable.Rows)
        //            {
        //                RuleEntity rst = new RuleEntity();
        //                rst.CheckObject = "DTBDLTBGX";
        //                rst.ErrorId = item["BSM"]?.ToString();
        //                rst.BGFWBSM = item["BSM"]?.ToString();
        //                rst.ErrorTip = "荒草地地上图情况待核查";
        //                rst.ErrorType = "三类错误（人工核查）";
        //                rst.RuleCode = "GD305";
        //                rst.RuleName = "荒草地上图检查";
        //                rstList.Add(rst);
        //            }
        //        }
        //        AddErrors(rstList);
        //    }
        //    catch (Exception ex)
        //    {
        //        RuleEntity ruleEntity = new RuleEntity()
        //        {
        //            CheckObject = "DTBDLTBGX",
        //            ErrorTip = "荒草地地上图情况待核查",
        //            ErrorType = "三类错误（人工核查）",
        //            RuleCode = "GD305",
        //            RuleName = "荒草地上图检查",
        //            ErrorId = "规则检查失败：" + ex.Message,
        //        };
        //        rstList.Add(ruleEntity);
        //    }
        //    return rstList;
        //}

        public List<RuleEntity> SX301()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and (DDTCBZ NOT IN ('1301','1302','1303','1304','1306','1307','1308') OR DDTCBZ IS NULL) AND (DLBM LIKE '02%' OR DLBM in ('0301','0301K','0302','0302K','0305','0307','0307K','0403K','0404A','1104','1104A','1104K')) AND (ZZSXDM='' OR ZZSXDM IS NULL) AND  TBXHDM NOT IN ('LQYD')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "恢复属性为空的【园地/林地/草地/坑塘水面】地类上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "SX301";
                        rst.RuleName = "涉及标注恢复属性图斑上图检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "恢复属性为空的【园地/林地/草地/坑塘水面】地类上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "SX301",
                    RuleName = "涉及标注恢复属性图斑上图检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        public List<RuleEntity> SX302()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and (DDTCBZ NOT IN ('1301','1302','1303','1304','1306','1307','1308') OR DDTCBZ IS NULL) AND (DLBM LIKE '02%' OR DLBM in ('0301','0301K','0302','0302K','0305','0307','0307K','0403K','0404A','1104','1104A','1104K')) AND ZZSXDM='JKHF'";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "恢复属性为即可恢复的【园地/林地/草地/坑塘水面】上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "SX302";
                        rst.RuleName = "涉及标注恢复属性图斑属性检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    ErrorId = "规则检查失败：" + ex.Message,
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "恢复属性为即可恢复的【园地/林地/草地/坑塘水面】上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "SX302",
                    RuleName = "涉及标注恢复属性图斑属性检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        public List<RuleEntity> SX303()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE   TBBSM='{TBBSM}' and (DDTCBZ NOT IN ('1301','1302','1303','1304','1306','1307','1308') OR DDTCBZ IS NULL) AND (DLBM LIKE '02%' OR DLBM in ('0301','0301K','0302','0302K','0305','0307','0307K','0403K','0404A','1104','1104A','1104K')) AND ZZSXDM='GCHF' ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "恢复属性为工程恢复的【园地/林地/草地/坑塘水面】上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "SX303";
                        rst.RuleName = "涉及标注恢复属性图斑属性检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "恢复属性为工程恢复的【园地/林地/草地/坑塘水面】上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "SX303",
                    RuleName = "涉及标注恢复属性图斑属性检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }


        /// <summary>
        /// 建设用地图斑上图检查（不包括空闲地）
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> JSYD301()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and DLBM IN ({DLParams.jsyd_dlbms}) AND DLBM<>'1201' AND (DDTCBZ NOT IN ('1301','1302','1303','1304','1305') OR DDTCBZ IS NULL) ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "建设用地地类上图待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "JSYD301";
                        rst.RuleName = "建设用地图斑上图检查（不包括空闲地）";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    ErrorId = "规则检查失败：" + ex.Message,
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "建设用地地类上图待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "JSYD301",
                    RuleName = "建设用地图斑上图检查（不包括空闲地）",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 空闲地图斑上图检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> JSYD302()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM ='1201' AND  (DDTCBZ NOT IN ('1301','1302','1303','1304') OR DDTCBZ IS NULL) ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "空闲地上图待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "JSYD302";
                        rst.RuleName = "空闲地图斑上图检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    ErrorId = "规则检查失败：" + ex.Message,
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "空闲地上图待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "JSYD302",
                    RuleName = "空闲地图斑上图检查"
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 设施农用地图斑上图检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> JSYD303()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM ='1202' AND  (DDTCBZ NOT IN ('1301','1302','1303','1304') OR DDTCBZ IS NULL) ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "设施农用地上图待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "JSYD303";
                        rst.RuleName = "设施农用地图斑上图检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    ErrorId = "规则检查失败：" + ex.Message,
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "设施农用地上图待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "JSYD303",
                    RuleName = "设施农用地图斑上图检查",
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 农用地变未利用地上图检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> QT301()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX A LEFT JOIN (SELECT BGHTBBSM,SUM(TBBGMJ) AS BGMJ FROM DTBDLTBGXGC WHERE BGQDLBM IN ({DLParams.nyd_dlbms}) AND BGHDLBM IN ({DLParams.wlyd_dlbms}) GROUP BY BGHTBBSM ) B ON A.BSM=B.BGHTBBSM WHERE  A.TBBSM='{TBBSM}' and ((A.DDTCBZ NOT IN ('1301','1302','1303','1304') OR DDTCBZ IS NULL) OR A.DDTCBZ IS NULL) AND   A.DLBM IN ({DLParams.wlyd_dlbms}) AND  (B.BGMJ/A.TBMJ>0.3 OR B.BGMJ>=600)";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "农用地变未利用地上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "QT301";
                        rst.RuleName = "农用地变未利用地上图检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "农用地变未利用地上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "QT301",
                    RuleName = "农用地变未利用地上图检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 湿地类图斑上图检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> QT302()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and (DDTCBZ NOT IN ('1301','1302','1303','1304') OR DDTCBZ IS NULL) AND DLBM IN ({DLParams.sd_dlbms})  ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "湿地类图斑上图情况待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "QT302";
                        rst.RuleName = "湿地类图斑上图检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "湿地类图斑上图情况待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "QT302",
                    RuleName = "湿地类图斑上图检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 申请灭失图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> MS001()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM IN ('9903')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "申请灭失图斑检查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "MS001";
                        rst.RuleName = "申请灭失图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "申请灭失图斑检查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "MS001",
                    RuleName = "申请灭失图斑检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 界线外图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> JW001()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM IN ('9902')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "界线外图斑检查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "JW001";
                        rst.RuleName = "界线外图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "界线外图斑检查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "JW001",
                    RuleName = "界线外图斑检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 相对于基础库不变图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> BB001()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM IN ('9904') and (DDTCBZ  = '' or DDTCBZ is null) ";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "相对于基础库不变图斑检查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "BB001";
                        rst.RuleName = "相对于基础库不变图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "相对于基础库不变图斑检查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "BB001",
                    RuleName = "相对于基础库不变图斑检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 补充材料图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> BB002()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string sql = $"SELECT BSM FROM DTBDLTBGX WHERE  TBBSM='{TBBSM}' and  DLBM IN ('9905')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "DTBDLTBGX";
                        rst.ErrorId = item["BSM"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "补充材料图斑检查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "BB002";
                        rst.RuleName = "补充材料图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "DTBDLTBGX",
                    ErrorTip = "补充材料图斑检查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "BB002",
                    RuleName = "补充材料图斑检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }

        /// <summary>
        /// 其他类图斑检查
        /// </summary>
        /// <returns></returns>
        public List<RuleEntity> QT303()
        {
            List<RuleEntity> rstList = new List<RuleEntity>();
            try
            {
                string whereSql = string.Join("','", AllRGError.Select(x => x.ErrorId).ToArray());
                string sql = string.IsNullOrEmpty(whereSql) ? $"SELECT BSM FROM DTBDLTBGX where TBBSM='{TBBSM}'" : $"SELECT BSM FROM DTBDLTBGX where TBBSM='{TBBSM}' and bsm not in ('{whereSql}')";
                DataTable dataTable = Kingo.RuleCheck.CheckHelper.SQLiteDBOperate.Instance.ExceDataTable(SourcePath, sql);
                if (dataTable != null)
                {
                    rstList = new List<RuleEntity>();
                    foreach (DataRow item in dataTable.Rows)
                    {
                        RuleEntity rst = new RuleEntity();
                        rst.CheckObject = "BGFW";
                        rst.ErrorId = item["bsm"]?.ToString();
                        rst.BGFWBSM = item["BSM"]?.ToString();
                        rst.ErrorTip = "其他类图斑待核查";
                        rst.ErrorType = "三类错误（人工核查）";
                        rst.RuleCode = "QT303";
                        rst.RuleName = "其他类图斑检查";
                        rstList.Add(rst);
                    }
                }
                AddErrors(rstList);
            }
            catch (Exception ex)
            {
                RuleEntity ruleEntity = new RuleEntity()
                {
                    CheckObject = "BGFW",
                    ErrorTip = "其他类图斑待核查",
                    ErrorType = "三类错误（人工核查）",
                    RuleCode = "QT303",
                    RuleName = "其他类图斑检查",
                    ErrorId = "规则检查失败：" + ex.Message,
                };
                rstList.Add(ruleEntity);
            }
            return rstList;
        }
    }
}