using System;

namespace CustomDataProvider.CSVDataProvider
{
        // Represents information about fields in the data source.
        internal struct CsvColumn
        {
                private readonly string _fieldName;
                private readonly Type _dataType;

                // Creates a new instance of the CsvColumn class.
                // The fieldName parameter is the name of the field represented by this instance of the CsvColumn.
                // The dataType parameter is the Type of the field represented by this instance of the CsvColumn.
                public CsvColumn(string fieldName, Type dataType)
                {
                        if (fieldName == null)
                                throw new ArgumentNullException("fieldName");
                        if (dataType == null)
                                throw new ArgumentNullException("dataType");
                        _fieldName = fieldName;
                        _dataType = dataType;
                }


                // Gets the name of the field represented by this instance of the CsvColumn.
                public string FieldName
                {
                        get { return _fieldName; }
                }


                // Gets the the Type of the field represented by this instance of the CsvColumn.
                public Type DataType
                {
                        get { return _dataType; }
                }


               // Returns a String that represents this instance of the CsvColumn.
                public override string ToString()
                {
                        return String.Concat(new string[] {FieldName, "(", DataType.ToString(), ")"});
                }


                // Determines whether two CsvColumn instances are equal.
                // The obj represents the CsvColumn to compare with the current CsvColumn.
                // Returns True if the specified CsvColumn is equal to the current CsvColumn; otherwise, False.
                public override bool Equals(object obj)
                {
                        bool flag;

                        if (obj is CsvColumn)
                        {
                                flag = Equals((CsvColumn) obj);
                        }
                        else
                        {
                                flag = false;
                        }
                        return flag;
                }

                private bool Equals(CsvColumn column)
                {
                        return column.FieldName == FieldName;
                }


                // Serves as a hash function for a CsvColumn, suitable for use in hashing algorithms and data structures like a hash table.
               // Returns a hash code for the current CsvColumn instance.
                public override int GetHashCode()
                {
                        return (FieldName.GetHashCode() + DataType.GetHashCode());
                }
        }
}

using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using GrapeCity.ActiveReports.Extensibility.Data;

namespace CustomDataProvider.CSVDataProvider
{

        // Provides an implementation of IDataReader for the .NET Framework CSV Data Provider.
        internal class CsvDataReader : IDataReader
        {
                //NOTE: HashcodeProvider and Comparer need to be case-insensitive since TypeNames are capitalized differently in places. 
                                //Otherwise data types end up as strings when using Int32 vs int32.
                private Hashtable _typeLookup =
                        new Hashtable(StringComparer.Create(CultureInfo.InvariantCulture, false));
                private Hashtable _columnLookup = new Hashtable();
                private object[] _columns;
                private TextReader _textReader;
                private object[] _currentRow;


                //The regular expressions are set to be pre-compiled to make it faster. Since we were concerned about
                //multi-threading, we made the properties read-only so no one can change any properties on these objects.
                private static readonly Regex _rxDataRow = new Regex(@",(?=(?:[^""]*""[^""]*"")*(?![^""]*""))", RegexOptions.Compiled);
                        //Used to parse the data rows.

                private static readonly Regex _rxHeaderRow =
                        new Regex(@"(?<fieldName>(\w*\s*)*)\((?<fieldType>\w*)\)", RegexOptions.Compiled); 
                        //Used to parse the header rows.

        
                // Creates a new instance of the CsvDataReader class.
                // The textReader parameter represents the TextReader to use to read the data.
                public CsvDataReader(TextReader textReader)
                {
                        _textReader = textReader;
                        ParseCommandText();
                }

        
                // Parses the passed-in command text.
                private void ParseCommandText()
                {
                        if (_textReader.Peek() == -1)
                                return; //Command text is empty or at the end already.

                        FillTypeLookup();

                        string header = _textReader.ReadLine();
                        header = AddDefaultTypeToHeader(header);

                        if (!ParseHeader(header))
                                throw new InvalidOperationException(
                                        "Field names and types are not defined. The first line in the CommandText must contain the field names and data types. e.g FirstName(string)");
                }

                //A hashtable is used to return a type for the string value used in the header text.
                private void FillTypeLookup()
                {
                        _typeLookup.Add("string", typeof (String));
                        _typeLookup.Add("byte", typeof (Byte));
                        _typeLookup.Add("boolean", typeof (Boolean));
                        _typeLookup.Add("datetime", typeof (DateTime));
                        _typeLookup.Add("decimal", typeof (Decimal));
                        _typeLookup.Add("double", typeof (Double));
                        _typeLookup.Add("int16", typeof (Int16));
                        _typeLookup.Add("int32", typeof (Int32));
                        _typeLookup.Add("int", typeof (Int32));
                        _typeLookup.Add("integer", typeof (Int32));
                        _typeLookup.Add("int64", typeof (Int64));
                        _typeLookup.Add("sbyte", typeof (SByte));
                        _typeLookup.Add("single", typeof (Single));
                        _typeLookup.Add("time", typeof (DateTime));
                        _typeLookup.Add("date", typeof (DateTime));
                        _typeLookup.Add("uint16", typeof (UInt16));
                        _typeLookup.Add("uint32", typeof (UInt32));
                        _typeLookup.Add("uint64", typeof (UInt64));
                }

        
                // Returns a type based on the string value passed in from the header text string. If no match is found, a string type is returned.
                // The fieldType parameter represents the String value from the header command text string.
                private Type GetFieldTypeFromString(string fieldType)
                {
                        if (_typeLookup.Contains(fieldType))
                                return _typeLookup[fieldType] as Type;
                        return typeof (String);
                }

        
                // Parses the first line in the passed-in command text string to create the field names and field data types. The field information
                // is stored in a CsvColumn struct, and these column info items are stored in an ArrayList. The column name is also added
                // to a hashtable for easy lookup later.
        
                // The header parameter represents the header string that contains all the fields.
                // Returns True if it can parse the header string; otherwise False.
                private bool ParseHeader(string header)
                {
                        string fieldName;
                        int index = 0;
                        if (header.IndexOf("(") == -1)
                                return false;

                        MatchCollection matches = _rxHeaderRow.Matches(header);
                        _columns = new object[matches.Count];
                        foreach (Match match in matches)
                        {
                                fieldName = match.Groups["fieldName"].Value;
                                Type fieldType = GetFieldTypeFromString(match.Groups["fieldType"].Value);
                                _columns.SetValue(new CsvColumn(fieldName, fieldType), index);
                                _columnLookup.Add(fieldName, index);
                                index++;
                        }

                        return true;
                }

        
                // Ensures that the header contains columns in the form of name(type)
                // The line parameter represents the raw header line from the file to fix up.
                // Returns a modified header with default types appended to column names.
                private static string AddDefaultTypeToHeader(string line)
                {
                        const string ColumnWithDataTypeRegex = @"[""]?\w+[\""]?\(.+\)";
                        string[] columns = line.Split(new string[] { "," }, StringSplitOptions.None);
                        string ret = null;
                        foreach (string column in columns)
                        {
                                if (!string.IsNullOrEmpty(ret))
                                        ret += ",";
                                if (!Regex.Match(column, ColumnWithDataTypeRegex).Success)
                                {
                                        ret += column + "(string)";
                                }
                                else
                                {
                                        ret += column;
                                }
                        }
                        return ret;
                }

        
                // Parses a row of data using a regular expression and stores the information inside an object array that is the current row of data.
                // If the row does not have the correct number of fields, an exception is raised.
                // The dataRow parameter represents the String value representing a comma delimited data row.
                // Returns True if it can parse the data string; otherwise False.
                private bool ParseDataRow(string dataRow)
                {
                        int index = 0;
                        string[] tempData = _rxDataRow.Split(dataRow);

                        _currentRow = new object[tempData.Length];
                        if (tempData.Length != _columns.Length)
                        {
                                string error =
                                        string.Format(CultureInfo.InvariantCulture,
                                                      "Invalid row \"{0}\". The row does not contain the same number of data columns as the table header definition.",
                                                      dataRow);
                                throw new InvalidOperationException(error);
                        }
                        for (int i = 0; i < tempData.Length; i++)
                        {
                                string value = tempData[i];

                                if (value.Length > 1)
                                {
                                        if (value.IndexOf('"', 0) == 0 && value.IndexOf('"', 1) == value.Length - 1)
                                                value = value.Substring(1, value.Length - 2);
                                }
                                _currentRow.SetValue(ConvertValue(GetFieldType(index), value), index);
                                index++;
                        }
                        return true;
                }

        
                // Coverts the string value coming from the command text to the appropriate data type, based on the field's type.
                // This also checks a few string value rules to decide if a String.Empty of System.Data.DBNull needs to be returned.
                // The type parameter represents the Type of the current column the data belongs to.
                // The originalValue parameter represents the String value coming from the command text.
                // Returns the object resulting from the converted string, based on the type.
                private object ConvertValue(Type type, string originalValue)
                {
                        Type fieldType = type;
                        CultureInfo invariantCulture = CultureInfo.InvariantCulture;
                        try
                        {
                                if (originalValue == "\"\"" || originalValue == " ")
                                        return string.Empty;
                                if (originalValue == "")
                                        return DBNull.Value;
                                if (originalValue == "DBNull")
                                        return DBNull.Value;
                                if (fieldType.Equals(typeof (String)))
                                        return originalValue.Trim();
                                if (fieldType.Equals(typeof (Int32)))
                                        return Convert.ToInt32(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Boolean)))
                                        return Convert.ToBoolean(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (DateTime)))
                                        return Convert.ToDateTime(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Decimal)))
                                        return Convert.ToDecimal(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Double)))
                                        return Convert.ToDouble(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Int16)))
                                        return Convert.ToInt16(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Int64)))
                                        return Convert.ToInt64(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Single)))
                                        return Convert.ToSingle(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (Byte)))
                                        return Convert.ToByte(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (SByte)))
                                        return Convert.ToSByte(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (UInt16)))
                                        return Convert.ToUInt16(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (UInt32)))
                                        return Convert.ToUInt32(originalValue, invariantCulture);
                                if (fieldType.Equals(typeof (UInt64)))
                                        return Convert.ToUInt64(originalValue, invariantCulture);
                        }
                        catch (Exception e)
                        {
                                throw new InvalidOperationException(
                                        string.Format("Input value '{0}' could not be converted to the type '{1}'.", originalValue, type), e);
                        }
                        //If no match is found return DBNull instead.
                        return DBNull.Value;
                }

                #region IDataReader Members

        
                // Advances the CsvDataReader to the next record.
                // Returns True if there are more rows; otherwise, False.
                public bool Read()
                {
                        if (_textReader.Peek() > -1)
                                ParseDataRow(_textReader.ReadLine());
                        else
                                return false;

                        return true;
                }

                #endregion

                #region IDisposable Members

        
                // Releases the resources used by the CsvDataReader.
                public void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }

                private void Dispose(bool disposing)
                {
                        if (disposing)
                        {
                                if (_textReader != null)
                                        _textReader.Close();
                        }

                        _typeLookup = null;
                        _columnLookup = null;
                        _columns = null;
                        _currentRow = null;
                }

        
                // Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.
                ~CsvDataReader()
                {
                        Dispose(false);
                }

                #endregion

                #region IDataRecord Members

        
                // Gets the number of columns in the current row.
                public int FieldCount
                {
                        get { return _columns.Length; }
                }

        
                // The i parameter represents the index of the field to find.
                // Returns the Type information corresponding to the type of Object that would be returned from GetValue.
                public Type GetFieldType(int i)
                {
                        if (i > _columns.Length - 1)
                                return null;

                        return ((CsvColumn) _columns.GetValue(i)).DataType;
                }

        
                // Gets the name for the field to find.
                // The i parameter represents the index of the field to find. 
                // Returns the name of the field or an empty string (""), if there is no value to return.
                public string GetName(int i)
                {
                        if (i > _columns.Length - 1)
                                return string.Empty;


                        return ((CsvColumn) _columns.GetValue(i)).FieldName;
                }

        
                // The name parameter represents the name of the field to find. 
                // Returns the index of the named field.
                public int GetOrdinal(string name)
                {
                        object value = _columnLookup[name];
                        if (value == null)
                                throw new IndexOutOfRangeException("name");
                        return (int) value;
                }

        
                // The i parameter represents the index of the field to find. 
                // Returns the Object which contains the value of the specified field.
                public object GetValue(int i)
                {
                        if (i > _columns.Length - 1)
                                return null;

                        return _currentRow.GetValue(i);
                }

                public virtual IDataReader GetData(int fieldIndex)
                {
                        throw new NotSupportedException();
                }

                #endregion
        }
}

using System;
using System.IO;
using GrapeCity.ActiveReports.Extensibility.Data;

namespace CustomDataProvider.CSVDataProvider
{

       // Provides the IDbCommand implementation for the .NET Framework CSV Data Provider.
        public sealed class CsvCommand : IDbCommand
        {
                private string _commandText;
                private IDbConnection _connection;
                private int _commandTimeout;
                private CommandType _commandType;

        
                /// Creates a new instance of the CsvCommand class.
                public CsvCommand()
                        : this(string.Empty)
                {
                }

        
                // Creates a new instance of the CsvCommand class with command text.
                // The commandText parameter represents the command text.
                public CsvCommand(string commandText)
                        : this(commandText, null)
                {
                }

        
                // Creates a new instance of the CsvCommand class with command text and a CsvConnection.
                // The commandText parameter represents the command text.
                // The connection parameter represents a CsvConnection to a data source.?
                public CsvCommand(string commandText, CsvConnection connection)
                {
                        _commandText = commandText;
                        _connection = connection;
                }

        
                // Gets or sets the command to execute at the data source.
                public string CommandText
                {
                        get { return _commandText; }
                        set { _commandText = value; }
                }

        
                // Gets or sets the wait time before terminating an attempt to execute the command and generating an error.
                public int CommandTimeout
                {
                        get { return _commandTimeout; }

                        set { _commandTimeout = value; }
                }

        
                // Gets or sets a value indicating how the CommandText property is interpreted.
               // Remarks: We don't use this one for the Csv Data Provider.
                public CommandType CommandType
                {
                        get { return _commandType; }

                        set { _commandType = value; }
                }

        
               // Gets or sets the CsvConnection used by this instance of the CsvCommand.
                public IDbConnection Connection
                {
                        get { return _connection; }

                        set { _connection = value; }
                }

        
                // Sends the CommandText to the CsvConnection, and builds a CsvDataReader using one of the CommandBehavior values.
                // The behavior parameter represents a CommandBehavior value.
                // Returns a CsvDataReader object.
                public IDataReader ExecuteReader(CommandBehavior behavior)
                {
                        return new CsvDataReader(new StringReader(_commandText));
                }

        
               // Returns a string that represents the command text with the parameters expanded into constants.
                public string GenerateRewrittenCommandText()
                {
                        return _commandText;
                }

        
                // Sends the CommandText to the CsvConnection and builds a CsvDataReader.
                // Returns a CsvDataReader object.
                public IDataReader ExecuteReader()
                {
                        return ExecuteReader(CommandBehavior.SchemaOnly);
                }

                #region Non implemented IDbCommand Members

                public IDataParameterCollection Parameters
                {
                        get { throw new NotImplementedException(); }
                }

                public IDbTransaction Transaction
                {
                        get { throw new NotImplementedException(); }

                        set { throw new NotImplementedException(); }
                }

                public void Cancel()
                {
                        
                }

                public IDataParameter CreateParameter()
                {
                        throw new NotImplementedException();
                }

                #endregion

                #region IDisposable Members

        
                // Releases the resources used by the CsvCommand.
                public void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }


                private void Dispose(bool disposing)
                {
                        if (disposing)
                        {
                                if (_connection != null)
                                {
                                        _connection.Dispose();
                                        _connection = null;
                                }
                        }
                }

                #endregion
        }
}

using System;
using System.Collections.Specialized;
using GrapeCity.ActiveReports.Extensibility.Data;

namespace CustomDataProvider.CSVDataProvider
{

        // Provides an implementation of IDbConnection for the .NET Framework CSV Data Provider.
        public sealed class CsvConnection : IDbConnection
        {
                private string _localizedName;

        
                // Creates a new instance of the CsvConnection class.
                public CsvConnection()
                {
                        _localizedName = "Csv";
                }

        
                // Creates a new instance of the CsvConnection class.
                // The localizedName parameter represents the localized name for the CsvConnection instance.
                public CsvConnection(string localizeName)
                {
                        _localizedName = localizeName;
                }

                #region IDbConnection Members

        
               // Gets or sets the string used to open the connection to the data source.
               // Remarks: We don't use this one for the Csv Data Provider.
                public string ConnectionString
                {
                        get { return string.Empty; }

                        set { ; }
                }

        
                // Gets the amount of time to wait while trying to establish a connection before terminating the attempt and generating an error.
                // Remarks: We don't use this one for the Csv Data Provider.
                public int ConnectionTimeout
                {
                        get { throw new NotImplementedException(); }
                }

        
               // Begins a data source transaction.   
               // Returns an object representing the new transaction.
               // Remarks: We don't use this one for the Csv Data Provider.
                public IDbTransaction BeginTransaction()
                {
                        return null;
                }

        
               // Opens a data source connection.     
               // Remarks: We don't use this one for the Csv Data Provider.
                public void Open()
                {
                        ;
                }

        
                // Closes the connection to the data source. This is the preferred method of closing any open connection.
                public void Close()
                {
                        Dispose();
                }

        
               // Creates and returns a CsvCommand object associated with the CsvConnection.
                public IDbCommand CreateCommand()
                {
                        return new CsvCommand(string.Empty);
                }

                public IDataProviderService DataProviderService
                {
                        get { return null; }
                        set { }
                }

                #endregion

                #region IDisposable Members

        
               // Releases the resources used by the CsvConnection.
                public void Dispose()
                {
                        Dispose(true);
                        GC.SuppressFinalize(this);
                }

                private void Dispose(bool disposing)
                {
                }

        
                // Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.
                ~CsvConnection()
                {
                        Dispose(false);
                }

                #endregion

                #region IExtension Members

        
                // Gets the localized name of the CsvConnection.
                public string LocalizedName
                {
                        get { return _localizedName; }
                }

        
                // Specifies any configuration information for this extension.
                // The configurationSettings parameter represents a NameValueCollection of the settings.
                public void SetConfiguration(NameValueCollection configurationSettings)
                {
                }

                #endregion
        }
}

using GrapeCity.ActiveReports.Extensibility.Data;
using GrapeCity.BI.Data.DataProviders;

namespace CustomDataProvider.CSVDataProvider
{

       // Implements the DataProviderFactory for .NET Framework CSV Data Provider.
        public class CsvDataProviderFactory : DataProviderFactory
        {
        
                // Creates new instance of the CsvDataProviderFactory class.
                public CsvDataProviderFactory()
                {
                }
        
               // Returns a new instance of the the CsvCommand.
                public override IDbCommand CreateCommand()
                {
                        return new CsvCommand();
                }
        
               // Returns a new instance of the the CsvConnection.
                public override IDbConnection CreateConnection()
                {
                        return new CsvConnection();
                }
        }
}

using System;
using System.Collections.Generic;
using System.Drawing.Design;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Windows.Forms.Design;
namespace CustomDataProvider.CSVDataProvider
{
    public sealed class QueryEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.DropDown;
        }

        public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
        {
            IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
            var path = "";
            var btn = new Button();
            btn.Text = "Select CSV File...";
            var pdg = btn.Padding;
            pdg.Bottom += 2;
            btn.Padding = pdg;
            btn.Click += delegate
            {
                using (var openDlg = new OpenFileDialog())
                {
                    openDlg.Filter = "CSV Files (*.csv)|*.csv|All Files (*.*)|*.*";
                    if (openDlg.ShowDialog() != DialogResult.OK)
                        path = "";
                    else
                        path = openDlg.FileName;
                }
            };
            edSvc.DropDownControl(btn);
            if (string.IsNullOrEmpty(path)) return string.Empty;
            if (!File.Exists(path)) return string.Empty;
            return GetCSVQuery(path);
        }
        private object GetCSVQuery(string path)
        {
            StreamReader sr = null;
            try
            {
                sr = new StreamReader(path);
                string ret = string.Empty;
                string currentLine;
                int line = 0;
                while ((currentLine = sr.ReadLine()) != null)
                {
                    if (line == 0)
                        ret += ProcessColumnsDefinition(currentLine) + "\r\n";
                    else
                        ret += currentLine + "\r\n";
                    line++;
                }
                return ret;
            }
            catch (IOException)
            {
                return string.Empty;
            }
            finally
            {
                if (sr != null)
                    sr.Close();
            }
        }
        private string ProcessColumnsDefinition(string currentLine)
        {
            const string ColumnWithDataTypeRegex = @"[""]?\w+[\""]?\(.+\)";
            string[] columns = currentLine.Split(new string[] { "," }, StringSplitOptions.None);
            string ret = null;
            foreach (string column in columns)
            {
                if (!string.IsNullOrEmpty(ret))
                    ret += ",";
                if (!Regex.Match(column, ColumnWithDataTypeRegex).Success)
                {
                    ret += column + "(string)";
                }
                else
                {
                    ret += column;
                }
            }
            return ret;
        }
    }
}