etl业务验证方法1

/* Copyright (c) 2015 Xiamen Weixin Software Co., Ltd. All rights reserved
 *
 * Create by huanglc@holworth.com at 2015-04-23 21:52:45
 *
 */

using System;
using System.Text;
using System.Collections.Generic;
using Contract.IService;
using Framework;
using System.Collections;
using Contract.Domain;
using BaseService;
using System.Linq;
namespace ETLBLL
{
    public class EtlCheckMethodService : BaseService.EntityService<Contract.Domain.EtlCheckMethod>, IEtlCheckMethodService
    {
        /// <summary>
        /// 检验是否>=0
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public object[] GEZero(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column, EtlDataMap etlDataMap)
        {
            object[] returnObject = new object[3];
            if (string.IsNullOrEmpty(obj))
            {
                returnObject[0] = false;
                returnObject[1] = "不能空";
                returnObject[2] = 0;
            }
            else
            {
                decimal a = 0;
                if (decimal.TryParse(obj, out a))
                {
                    if (a >= 0)
                    {
                        returnObject[0] = true;
                        returnObject[1] = "";
                        returnObject[2] = a;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = "小于0";

                    }

                }
                else
                {
                    returnObject[0] = false;
                    returnObject[1] = "不是数值";
                }

            }
            return returnObject;
        }
        /// <summary>
        /// 检验日期
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public object[] CheckDateTime(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column, EtlDataMap etlDataMap)
        {
            object[] returnObject = new object[3];
            if (string.IsNullOrEmpty(obj))
            {
                returnObject[0] = true;
                returnObject[2] = null;
            }
            else
            {
                DateTime a = DateTime.Now;
                if (DateTime.TryParse(obj, out a))
                {
                    returnObject[0] = true;
                    returnObject[2] = a;
                }
                else
                {
                    returnObject[0] = false;
                    returnObject[1] = "不是为日期类型";
                    
                }
            }
            return returnObject;

        }
        /// <summary>
        /// 检验数值
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public object[] CheckNumber(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column, EtlDataMap etlDataMap)
        {
              object[] returnObject = new object[3];
              if (string.IsNullOrEmpty(obj))
              {
                  returnObject[0] = true;
                  returnObject[1] = "";
                  returnObject[2] = 0;
              }
              else
              {
                  decimal a = 0;
                  if (decimal.TryParse(obj, out a))
                  {
                      returnObject[0] = true;
                      returnObject[2] = a;
                  }
                  else
                  {
                      returnObject[0] = false;
                      returnObject[1] = "不是为数值类型";
                  }
              }
              return returnObject;

        }
        public object[] CheckNull(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column, EtlDataMap etlDataMap)
        {
            object[] returnObject = new object[3];
            returnObject[0] = !string.IsNullOrEmpty(obj);
            returnObject[2] = obj;
            if (string.IsNullOrEmpty(obj))
            {
                returnObject[1] = "不能空";
            }
            return returnObject;
        }
        /// <summary>
        /// 验证范围
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        public object[] CheckRange(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column, EtlDataMap etlDataMap)
        {
            object[] returnObject = new object[3];
            returnObject[2] = obj;
            if (string.IsNullOrEmpty(obj))
            {
                returnObject[1] = "不能空";
                returnObject[0] = false;
            }
            else
            {
                if (obj.CompareTo(column.ExtendParameter) >= 0 && obj.CompareTo(column.ExtendParameter2) <= 0)
                {
                    returnObject[0] = true;
                   
                }
                else
                {
                    returnObject[0] = false;
                    returnObject[1] = string.Format("值不在{0}和{1}之间", column.ExtendParameter, column.ExtendParameter2);
                }
            }
            return returnObject;
        }

        public string getColumnPosition(EtlColumn c1)
        {
            string col1 = string.Empty;
            if (c1.MapIndex <= 90)
            {
                col1 = ((char)(c1.MapIndex.Value + 65)).ToString();

            }
            else
            {
                col1 = "A" + ((char)(c1.MapIndex.Value + 65 - 26)).ToString();
            }

            return col1;
        }
        /// <summary>
        /// 通用验证数值范围的方法
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="etlDataMap"></param>
        /// <returns></returns>
        public object[] CheckGennericNumber(string obj, System.Data.DataTable table, System.Data.DataRow row,
            EtlCheckMethod column, EtlDataMap etlDataMap)
        {

            //a>b
            object[] returnObject = new object[] { };
            string para1 = column.ExtendParameter;
            string para2 = column.ExtendParameter2;
            string para3 = column.ExtendParameter3;
            string[] ops = new[] { ">", "<", "=", "!=", ">=", "<=" };
            if (ops.Contains(para2))
            {

                if (para2 == ">")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    double a = 0;
                    if (!double.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    double b = 0;
                    if (!double.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) > 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}小于等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }

                }
                else if (para2 == "<")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    double a = 0;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    double b = 0;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) < 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}大于等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }
                else if (para2 == "=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    double a = 0;
                    if (!double.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    double b = 0;
                    if (!double.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) == 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}不等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }

                }
                else if (para2 == "!=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    double a = 0;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    double b = 0;
                    if (!double.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) > 0 || a.CompareTo(b) < 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }
                else if (para2 == ">=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    double a = 0;
                    if (!double.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    double b = 0;
                    if (!double.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) >= 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}小于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }
                else if (para2 == "<=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    double a = 0;
                    if (!double.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    double b = 0;
                    if (!double.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为数值类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) <= 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}大于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }

            }

            return null;
        }

        /// <summary>
        /// 验证日期在某两个范围日期之间
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="etlDataMap"></param>
        /// <returns></returns>
        public object[] CheckGennericDateRange(string obj, System.Data.DataTable table, System.Data.DataRow row,
            EtlCheckMethod column, EtlDataMap etlDataMap)
        {
            object[] returnObject = new object[]{};
            string para1 = column.ExtendParameter;
            string para2 = column.ExtendParameter2;

            DateTime a = DateTime.Now;

            if (!DateTime.TryParse(obj, out a))
            {
                returnObject[0] = false;
                returnObject[1] = "不是日期类型";
                return returnObject;
            }

            DateTime v1 = DateTime.Now;
            ; if (!DateTime.TryParse(column.ExtendParameter, out v1))
            {
                returnObject[0] = false;
                returnObject[1] = "第一个扩展参数不是日期类型";
                return returnObject;
            }
            DateTime v2 = DateTime.Now;
            ; if (!DateTime.TryParse(column.ExtendParameter2, out v2))
            {
                returnObject[0] = false;
                returnObject[1] = "二个扩展参数不是日期类型";
                return returnObject;
            }
            if (a.CompareTo(v1) >= 0 && a.CompareTo(v2) <= 0)
            {
                returnObject[0] = true;
                returnObject[2] = a;
                return returnObject;
            }
            else
            {
                returnObject[0] = false;
                returnObject[1] = string.Format("当前日期的范围不在{0}和{1}之间",v1,v2);
                return returnObject;
            }
            return null;
        }




        /// <summary>
        /// 通用验证日期范围法
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="etlDataMap"></param>
        /// <returns></returns>
        public object[] CheckGennericDate(string obj, System.Data.DataTable table, System.Data.DataRow row,
            EtlCheckMethod column, EtlDataMap etlDataMap)
        {
            //a>b
            object[] returnObject=new object[]{};
            string para1 = column.ExtendParameter;
            string para2 = column.ExtendParameter2;
            string para3 = column.ExtendParameter3;
            string[] ops = new[] {">", "<", "=", "!=", ">=", "<="};
            if (ops.Contains(para2))
            {
         
                if (para2 == ">")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    DateTime a = DateTime.Now;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    DateTime b = DateTime.Now;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) > 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}小于等于{2}",colPostion,c1.MapColumn,column.ExtendParameter3);
                        return returnObject;
                    }

                }else if (para2 == "<")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    DateTime a = DateTime.Now;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    DateTime b = DateTime.Now;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) < 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}大于等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }
                else if (para2 == "=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    DateTime a = DateTime.Now;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    DateTime b = DateTime.Now;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) ==0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}不等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }

                }
                else if (para2 == "!=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    DateTime a = DateTime.Now;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    DateTime b = DateTime.Now;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) > 0||a.CompareTo(b)<0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}等于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }
                else if (para2 == ">=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    DateTime a = DateTime.Now;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    DateTime b = DateTime.Now;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) >= 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}小于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }
                else if (para2 == "<=")
                {
                    if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
                    {
                        throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter));
                    }
                    var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
                    string colPostion = getColumnPosition(c1);
                    DateTime a = DateTime.Now;
                    if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
                    {
                        returnObject[1] = "不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    DateTime b = DateTime.Now;
                    if (!DateTime.TryParse(column.ExtendParameter3, out b))
                    {
                        returnObject[1] = "column.ExtendParameter3不是为日期类型";
                        returnObject[0] = false;
                        return returnObject;
                    }
                    if (a.CompareTo(b) <= 0)
                    {
                        returnObject[0] = true;
                        returnObject[2] = DateTime.Parse(obj);
                        return returnObject;
                    }
                    else
                    {
                        returnObject[0] = false;
                        returnObject[1] = string.Format("{0}列名为{1}大于{2}", colPostion, c1.MapColumn, column.ExtendParameter3);
                        return returnObject;
                    }
                }

            }

            return null;
        }

        /// <summary>
        /// 验证某个列日期不能大于某列
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="etlDataMap"></param>
        /// <returns></returns>
        public object[] CheckRangeDateTimeColumn(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column,EtlDataMap etlDataMap)
        {
             object[] returnObject = new object[3];
            string errorColumn = string.Empty;
            if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).Count() <= 0)
            {
                throw new Exception(string.Format("不存在映射列{0}",column.ExtendParameter));
            }
            if (etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter2)).Count() <= 0)
            {
                throw new Exception(string.Format("不存在映射列{0}", column.ExtendParameter2));
            }
            var c1 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter)).First();
            var c2 = etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter2)).First();
            DateTime a = DateTime.Now;
            if (!DateTime.TryParse(row[c1.MapIndex.Value].ToString(), out a))
            {
                returnObject[1] = "不是为日期类型";
                returnObject[0] = false;
                return returnObject;
            }
            DateTime v1 = a;
            if (!DateTime.TryParse(row[c2.MapIndex.Value].ToString(), out a))
            {
                returnObject[1] = "不是为日期类型";
                returnObject[0] = false;
                return returnObject;
            }
            DateTime v2 = a;

            if (v1.CompareTo(v2) <= 0)
            {
                returnObject[0] = true;
                returnObject[2] = DateTime.Parse(obj);
            }
            else
            {
                returnObject[0] = false;
                string col1 = string.Empty;
                string col2 = string.Empty;

                if (c1.MapIndex <= 90)
                {
                   col1 = ((char)(c1.MapIndex.Value + 65)).ToString();

                }
                else
                {
                    col1 = "A" + ((char)(c1.MapIndex.Value + 65 - 26)).ToString();
                }

                if (c2.MapIndex <= 90)
                {
                    col2 = ((char)(c2.MapIndex.Value + 65)).ToString();

                }
                else
                {
                    col2 = "A" + ((char)(c2.MapIndex.Value + 65 - 26)).ToString();
                }
                returnObject[1] = string.Format("{0}大于{1}",col1,col2);
            }
            return returnObject;
        }
        /// <summary>
        /// 判断列不能同时存在
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="table"></param>
        /// <param name="row"></param>
        /// <param name="column"></param>
        /// <param name="etlDataMap"></param>
        /// <returns></returns>
        public object[] CheckColumnSimpleExist(string obj, System.Data.DataTable table, System.Data.DataRow row, EtlCheckMethod column, EtlDataMap etlDataMap)
        {
           object[] returnObject = new object[3];
           int i= etlDataMap.ColumnList.Where(m => m.MapColumn.Equals(column.ExtendParameter) || m.MapColumn.Equals(column.ExtendParameter2)).Count();
           if (i == 0)
           {
               returnObject[0] = false;
               returnObject[1] = string.Format("{0}、{1}必须存在一列", column.ExtendParameter, column.ExtendParameter2);
           }
           else if (i > 1)
           {
               returnObject[0] = false;
               returnObject[1] = string.Format("{0}、{1}不能同时存在", column.ExtendParameter, column.ExtendParameter2);
           }
           else
           {
               returnObject[0] = true;
               returnObject[2] = obj;
           }
            
            return returnObject;
        }

    }
}