public void SetUp()
        {
            _mockRequestData = MockRepository.GenerateMock<IDataTableRequestCollection>();
            _mockRequestData.Stub(x => x.Echo).Return(Guid.NewGuid().ToString());

            _wrapper = new DataTableWrapper<IDataTableSerializer>(_mockRequestData, null);
        }
        private static DataSourceResult ToDataSourceResult(this DataTableWrapper enumerable, DataSourceRequest request)
        {
            List <IFilterDescriptor> source = new List <IFilterDescriptor>();

            if (request.Filters != null)
            {
                source.AddRange(request.Filters);
            }
            if (source.Any <IFilterDescriptor>())
            {
                var dataTable = enumerable.Table;
                source.SelectMemberDescriptors().Each <FilterDescriptor>(delegate(FilterDescriptor f) {
                    f.MemberType = GetFieldByTypeFromDataColumn(dataTable, f.Member);
                });
            }
            List <GroupDescriptor> list2 = new List <GroupDescriptor>();

            if (request.Groups != null)
            {
                list2.AddRange(request.Groups);
            }
            if (list2.Any <GroupDescriptor>())
            {
                var dataTable = enumerable.Table;
                list2.Each <GroupDescriptor>(delegate(GroupDescriptor g) {
                    g.MemberType = GetFieldByTypeFromDataColumn(dataTable, g.Member);
                });
            }
            DataSourceResult result = enumerable.AsEnumerable <System.Data.DataRowView>().ToDataSourceResult(request);

            result.Data = result.Data.SerializeToDictionary(enumerable.Table);
            return(result);
        }
 public void TearDown()
 {
     _mockItem = null;
     _columnNames = null;
     _expectedValuesArray = null;
     _wrapper = null;
 }
        public async Task WriteDataTableAsync()
        {
            using (var dataTable = new DataTable {
                TableName = "DataTable", Locale = CultureInfo.InvariantCulture
            })
            {
                dataTable.Columns.Add("ID", typeof(int));
                dataTable.Columns.Add("Text", typeof(string));
                for (var i = 0; i < 100; i++)
                {
                    var row = dataTable.NewRow();
                    row["ID"]   = i;
                    row["Text"] = i.ToString(CultureInfo.CurrentCulture);
                    dataTable.Rows.Add(row);
                }

                var writeFile = new CsvFile {
                    ID = "Test.txt", FileName = UnitTestInitializeCsv.GetTestPath("Test.txt"), SqlStatement = "Hello"
                };
                using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
                {
                    var writer = new CsvFileWriter(writeFile, processDisplay);
                    using (var reader = new DataTableWrapper(dataTable))
                    {
                        // await reader.OpenAsync(processDisplay.CancellationToken);
                        Assert.AreEqual(100, await writer.WriteAsync(reader, processDisplay.CancellationToken));
                    }
                }

                Assert.IsTrue(File.Exists(writeFile.FileName));
            }
        }
        public void SetUp()
        {
            _mockRequestData = MockRepository.GenerateMock<IDataTableRequestCollection>();
            _mockRequestData.Stub(x => x.SerializeAsDataContract()).Return(false);

            _wrapper = new DataTableWrapper<IDataTableSerializer>(_mockRequestData, null);
        }
 public void GetColumnTest()
 {
     using (var test = new DataTableWrapper(m_DataTable))
     {
         //await test.OpenAsync(UnitTestInitializeCsv.Token);
         Assert.AreEqual(m_DataTable.Columns[0].ColumnName, test.GetColumn(0).Name);
     }
 }
Esempio n. 7
0
        public void SetUp()
        {
            _mockRequestData = MockRepository.GenerateMock <IDataTableRequestCollection>();
            _mockRequestData.Stub(x => x.Echo).Return(null);
            _mockRequestData.Stub(x => x.SerializeAsDataContract()).Return(false);

            _wrapper = new DataTableWrapper <IDataTableSerializer>(_mockRequestData, null);
        }
 public void GetFieldTypeTest()
 {
     using (var test = new DataTableWrapper(m_DataTable))
     {
         Assert.AreEqual(DataType.Integer.GetNetType(), test.GetFieldType(0));
         Assert.AreEqual(typeof(string), test.GetFieldType(1));
     }
 }
Esempio n. 9
0
        public static LinearFitBySvd Regress(MultivariateLinearFitParameters parameters, out string[] paramNames)
        {
            DataColumnCollection        table        = parameters.Table;
            IAscendingIntegerCollection selectedCols = parameters.SelectedDataColumns;
            var selectedColsWODependent = new AscendingIntegerCollection(selectedCols);

            selectedColsWODependent.RemoveAt(parameters.DependentColumnIndexIntoSelection);

            IAscendingIntegerCollection validRows = DataTableWrapper.GetCollectionOfValidNumericRows(parameters.Table, selectedCols);

            parameters.SelectedDataRows = validRows;

            IROMatrix <double> xbase;

            if (parameters.IncludeIntercept)
            {
                xbase = DataTableWrapper.ToROColumnMatrixWithIntercept(parameters.Table, selectedColsWODependent, validRows);
            }
            else
            {
                xbase = DataTableWrapper.ToROColumnMatrix(parameters.Table, selectedColsWODependent, validRows);
            }

            paramNames = new string[xbase.ColumnCount];
            if (parameters.IncludeIntercept)
            {
                paramNames[0] = "Intercept";
                for (int i = 0; i < selectedColsWODependent.Count; i++)
                {
                    paramNames[i + 1] = table[selectedColsWODependent[i]].Name;
                }
            }
            else
            {
                for (int i = 0; i < selectedColsWODependent.Count; i++)
                {
                    paramNames[i] = table[selectedColsWODependent[i]].Name;
                }
            }

            // Fill the y and the error array
            double[] yarr = new double[validRows.Count];
            double[] earr = new double[validRows.Count];

            var ycol = (Altaxo.Data.INumericColumn)table[selectedCols[parameters.DependentColumnIndexIntoSelection]];

            for (int i = 0; i < validRows.Count; i++)
            {
                yarr[i] = ycol[validRows[i]];
                earr[i] = 1;
            }

            var fit =
                new LinearFitBySvd(
                    xbase, yarr, earr, xbase.RowCount, xbase.ColumnCount, 1E-5);

            return(fit);
        }
Esempio n. 10
0
        public void SetUp()
        {
            _mockRequestData = MockRepository.GenerateMock <IDataTableRequestCollection>();
            _mockRequestData.Stub(x => x.SerializeAsDataContract()).Return(true);

            _dataTableSerializers = DataCollection.GenerateCollection();

            _wrapper = new DataTableWrapper <IDataTableSerializer>(_mockRequestData, _dataTableSerializers);
        }
Esempio n. 11
0
        public void SetUp()
        {
            _expectedEchoValue = _random.Next(1, int.MaxValue);

            _mockRequestData = MockRepository.GenerateMock <IDataTableRequestCollection>();
            _mockRequestData.Stub(x => x.Echo).Return(_expectedEchoValue.ToString(CultureInfo.InvariantCulture));

            _wrapper = new DataTableWrapper <IDataTableSerializer>(_mockRequestData, null);
        }
        public void SetUp()
        {
            _expectedEchoValue = _random.Next(1, int.MaxValue);

            _mockRequestData = MockRepository.GenerateMock<IDataTableRequestCollection>();
            _mockRequestData.Stub(x => x.Echo).Return(_expectedEchoValue.ToString(CultureInfo.InvariantCulture));

            _wrapper = new DataTableWrapper<IDataTableSerializer>(_mockRequestData, null);
        }
        public async Task GetInt32Test()
        {
            using (var test = new DataTableWrapper(m_DataTable))
            {
                await test.ReadAsync(UnitTestInitializeCsv.Token);

                Assert.IsInstanceOfType(test.GetInt32(0), typeof(Int32));
            }
        }
        public async Task GetDateTimeTest()
        {
            using (var test = new DataTableWrapper(m_DataTable))
            {
                //await test.OpenAsync(UnitTestInitializeCsv.Token);
                await test.ReadAsync(UnitTestInitializeCsv.Token);

                Assert.IsInstanceOfType(test.GetDateTime(4), typeof(DateTime));
            }
        }
 public void DataTableWrapperOpenCloseTest()
 {
     using (var test = new DataTableWrapper(m_DataTable))
     {
         test.Read();
         Assert.IsFalse(test.IsClosed);
         test.Close();
         Assert.IsTrue(test.IsClosed);
     }
 }
        public void SetUp()
        {
            _columnNames = new List<string> { Guid.NewGuid().ToString(), Guid.NewGuid().ToString() };
            _expectedValuesArray = new object[] { Guid.NewGuid().ToString(), Guid.NewGuid().ToString() };

            _mockItem = MockRepository.GenerateMock<IDataTableSerializer>();
            _mockItem.Stub(x => x.ColumnNames()).Return(_columnNames); // property name
            _mockItem.Stub(x => x.ToObjectArray()).Return(_expectedValuesArray); // properties value

            _wrapper = new DataTableWrapper<IDataTableSerializer>(null, new List<IDataTableSerializer>{ _mockItem });
        }
 public void GetOrdinalTest()
 {
     using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
     {
         using (var test = new DataTableWrapper(m_DataTable))
         {
             //await test.OpenAsync(processDisplay.CancellationToken);
             Assert.AreEqual(2, test.GetOrdinal("ColText1"));
         }
     }
 }
 public void GetFieldTypeTest()
 {
     using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
     {
         using (var test = new DataTableWrapper(m_DataTable))
         {
             //await test.OpenAsync(processDisplay.CancellationToken);
             Assert.AreEqual(DataType.Integer.GetNetType(), test.GetFieldType(0));
         }
     }
 }
 public async Task ReadTestAsync()
 {
     using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
     {
         using (var test = new DataTableWrapper(m_DataTable))
         {
             //await test.OpenAsync(processDisplay.CancellationToken);
             Assert.IsTrue(await test.ReadAsync(processDisplay.CancellationToken));
         }
     }
 }
Esempio n. 20
0
        private IEnumerable <GridColumnBase <T> > GetColumnsForDataTable(DataTableWrapper dataTableWrapper)
        {
            var dataTable = dataTableWrapper.Table;

            if (dataTable == null)
            {
                return(Enumerable.Empty <GridColumnBase <T> >());
            }
            return(dataTable.Columns.OfType <DataColumn>()
                   .Select(c => CreateBoundColumn(c.ColumnName, c.DataType)));
        }
        public async Task GetValueTest()
        {
            using (var test = new DataTableWrapper(m_DataTable))
            {
                await test.ReadAsync(UnitTestInitializeCsv.Token);

                Assert.IsInstanceOfType(test.GetValue(0), typeof(int));
                Assert.IsInstanceOfType(test.GetValue(1), typeof(string));
                Assert.IsInstanceOfType(test.GetValue(4), typeof(DateTime));
            }
        }
 public void GetNameTest()
 {
     using (var test = new DataTableWrapper(m_DataTable))
     {
         Assert.AreEqual(m_DataTable.Columns[0].ColumnName, test.GetName(0));
         Assert.AreEqual("Text", test.GetName(1));
         Assert.AreEqual("ColText1", test.GetName(2));
         Assert.AreEqual("ColText2", test.GetName(3));
         Assert.AreEqual("ColTextDT", test.GetName(4));
     }
 }
 public void GetDataTypeNameTest()
 {
     using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
     {
         using (var test = new DataTableWrapper(m_DataTable))
         {
             // await test.OpenAsync(processDisplay.CancellationToken);
             var typeName = test.GetDataTypeName(0);
             Assert.IsTrue(typeName.Equals("int") || typeName.Equals("Int32") || typeName.Equals("Int64") ||
                           typeName.Equals("long"));
         }
     }
 }
        public async Task GetValuesTest()
        {
            using (var test = new DataTableWrapper(m_DataTable))
            {
                await test.ReadAsync(UnitTestInitializeCsv.Token);

                var objects = new object[test.FieldCount];
                test.GetValues(objects);
                Assert.IsInstanceOfType(objects[0], typeof(int));
                Assert.IsInstanceOfType(objects[1], typeof(string));
                Assert.IsInstanceOfType(objects[4], typeof(DateTime));
            }
        }
        public async Task GetDataTableAsyncTest1Async()
        {
            using (var pd = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
            {
                using (var test = new DataTableWrapper(m_DataTable))
                {
                    var dt = await test.GetDataTableAsync(200, false, true, false, false, false, null,
                                                          pd.CancellationToken);

                    Assert.AreEqual(m_DataTable, dt);
                }
            }
        }
        public async Task WriteFileLocked()
        {
            using (var dataTable = new DataTable {
                TableName = "DataTable", Locale = CultureInfo.InvariantCulture
            })
            {
                dataTable.Columns.Add("ID", typeof(int));
                dataTable.Columns.Add("Text", typeof(string));
                for (var i = 0; i < 5; i++)
                {
                    var row = dataTable.NewRow();
                    row["ID"]   = i;
                    row["Text"] = i.ToString(CultureInfo.InvariantCulture);
                    dataTable.Rows.Add(row);
                }

                var writeFile = new CsvFile
                {
                    ID           = "Test.txt",
                    FileName     = UnitTestInitializeCsv.GetTestPath("WriteFileLocked.txt"),
                    InOverview   = false,
                    SqlStatement = "dummy"
                };
                FileSystemUtils.FileDelete(writeFile.FileName);
                using (var file = new StreamWriter(writeFile.FileName))
                {
                    await file.WriteLineAsync("Hello");

                    try
                    {
                        using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
                        {
                            var writer = new CsvFileWriter(writeFile, processDisplay);
                            using (var reader = new DataTableWrapper(dataTable))
                            {
                                await writer.WriteAsync(reader, processDisplay.CancellationToken);
                            }
                        }

                        Assert.Fail("Exception not thrown");
                    }
                    catch (FileWriterException)
                    {
                    }

                    await file.WriteLineAsync("World");
                }

                FileSystemUtils.FileDelete(writeFile.FileName);
            }
        }
Esempio n. 27
0
        public void SetUp()
        {
            _columnNames = new List <string> {
                Guid.NewGuid().ToString(), Guid.NewGuid().ToString()
            };
            _expectedArray = new object[] { Guid.NewGuid().ToString(), Guid.NewGuid().ToString() };

            _mockItem = MockRepository.GenerateMock <IDataTableSerializer>();
            _mockItem.Stub(x => x.ColumnNames()).Return(_columnNames);     // property name
            _mockItem.Stub(x => x.ToObjectArray()).Return(_expectedArray); // properties value

            _wrapper = new DataTableWrapper <IDataTableSerializer>(null, new List <IDataTableSerializer> {
                _mockItem
            });
        }
 public void Initialize(CellInfo cell, DataTableWrapper data)
 {
     if (cell != null &&
         cell.CellDescr != null &&
         cell.CellDescr.Value != null)
     {
         txtValue.Text = cell.CellDescr.Value.DisplayValue;
     }
     else
     {
         txtValue.Text = String.Empty;
     }
     tupleCtrl.Initialize(cell);
     dataGrid.Initialize(data);
 }
        public async Task DataTableWrapperProperties()
        {
            using (var test = new DataTableWrapper(m_DataTable))
            {
                await test.ReadAsync(UnitTestInitializeCsv.Token);

                Assert.AreEqual(m_DataTable.Rows.Count, test.RecordsAffected, "RecordsAffected");
                Assert.AreEqual(1, test.Percent, "Percent");
                Assert.AreEqual(1, test.RecordNumber, "RecordNumber");
                Assert.AreEqual(1, test.StartLineNumber, "StartLineNumber");
                Assert.AreEqual(1, test.EndLineNumber, "EndLineNumber");
                Assert.AreEqual(m_DataTable.Columns.Count, test.Depth, "Depth");
                Assert.AreEqual(true, test.HasRows, "HasRows");
            }
        }
        public async Task GetSampleValuesAsync()
        {
            using (var dataTable = UnitTestStatic.GetDataTable(150, false))
            {
                using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
                {
                    using (var reader = new DataTableWrapper(dataTable))
                    {
                        var res = await DetermineColumnFormat
                                  .GetSampleValuesAsync(reader, 100, new[] { 0, 1 }, 20, null, processDisplay.CancellationToken)
                                  .ConfigureAwait(false);

                        Assert.AreEqual(20, res[0].Values.Count);
                    }
                }
            }
        }
        public async Task DetermineColumnFormatGetSampleValuesNoColumns()
        {
            using (var dt = new DataTable())
            {
                using (var processDisplay = new CustomProcessDisplay(UnitTestInitializeCsv.Token))
                {
                    using (var reader = new DataTableWrapper(dt))
                    {
                        var temp = await DetermineColumnFormat
                                   .GetSampleValuesAsync(reader, 0, new[] { 0 }, 20, null,
                                                         processDisplay.CancellationToken).ConfigureAwait(false);

                        Assert.AreEqual(0, temp.Count);
                    }
                }
            }
        }
 public void GetDataTypeNameTestAsync()
 {
     using (var test = new DataTableWrapper(m_DataTable))
     {
         Assert.AreEqual(DataType.Integer.GetNetType().Name, test.GetDataTypeName(0));
         Assert.AreEqual(nameof(String), test.GetDataTypeName(1));
         Assert.AreEqual(nameof(DateTime), test.GetDataTypeName(4));
         try
         {
             Assert.AreEqual(nameof(DateTime), test.GetDataTypeName(5));
             Assert.Fail("Expected exception");
         }
         catch (Exception)
         {
             //fine
         }
     }
 }
 public void GetOrdinalTest()
 {
     using (var test = new DataTableWrapper(m_DataTable))
     {
         //await test.OpenAsync(UnitTestInitializeCsv.Token);
         Assert.AreEqual(0, test.GetOrdinal(m_DataTable.Columns[0].ColumnName));
         Assert.AreEqual(4, test.GetOrdinal("ColTextDT"));
         try
         {
             Assert.AreEqual(-1, test.GetOrdinal("Nonsense"));
             Assert.Fail("Expected exception");
         }
         catch (Exception)
         {
             //fine
         }
     }
 }
        public async Task GetInt64Test()
        {
            using (var dt2 = m_DataTable.Copy())
            {
                dt2.Columns.Add("myInt", typeof(long));
                foreach (DataRow row in dt2.Rows)
                {
                    row[5] = 1123482452;
                }

                using (var test = new DataTableWrapper(dt2))
                {
                    await test.ReadAsync(UnitTestInitializeCsv.Token);

                    Assert.AreEqual(1123482452, test.GetInt64(5));
                }
            }
        }
        public async Task GetDecimalTest()
        {
            using (var dt2 = m_DataTable.Copy())
            {
                dt2.Columns.Add("myInt", typeof(decimal));
                foreach (DataRow row in dt2.Rows)
                {
                    row[5] = 223311.37334;
                }

                using (var test = new DataTableWrapper(dt2))
                {
                    //await test.OpenAsync(UnitTestInitializeCsv.Token);
                    await test.ReadAsync(UnitTestInitializeCsv.Token);

                    Assert.AreEqual((decimal)223311.37334, test.GetDecimal(5));
                }
            }
        }
 public void TearDown()
 {
     _mockRequestData = null;
     _wrapper = null;
 }
        /// <summary>
        /// This is an example to show how you might transform the data results. Typically this stuff is pushed further back into a business layer or in a repository of some sort.
        /// </summary>
        /// <param name="instance"></param>
        /// <returns></returns>
        public DataTableWrapper<BrowserDataTableWrap> GetCollectionByDataTable(IList<KeyValue<string, object>> instance)
        {
            if (instance == null)
            {
                throw new WebFaultException<string>("there are no vars being passed in for the action", HttpStatusCode.BadRequest);
            }

            var hasGlobalSearch = instance.FirstOrDefault(i => i.Key.Contains(DataItemCollectionNames.SSearch.Replace("_", string.Empty)));

            var hasEcho = instance.FirstOrDefault(i => i.Key.Contains(DataItemPropertyNamesFrontEnd.Echo));

            var hasColSorted = instance.FirstOrDefault(i => i.Key.Contains(DataItemCollectionNames.SSortCol));

            var hasDisplayStart = instance.FirstOrDefault(i => i.Key.Contains(DataItemPropertyNamesFrontEnd.DisplayStart));

            var hasDisplayLength = instance.FirstOrDefault(i => i.Key.Contains(DataItemPropertyNamesFrontEnd.DisplayLength));

            // This may seem like a lot, but typically you set up 'defaults' in an IOC like Ninject, StructureMap, or Unity
            var trans = new DataTableRequestCollection
                {
                    Echo = hasEcho != null ? hasEcho.Value.ToString() : string.Empty,
                    GlobalSearch = hasGlobalSearch != null ? hasGlobalSearch.Value.ToString() : string.Empty,
                    DataProperties = new Dictionary<string, string>(),
                    ColumnSortable = new Dictionary<string, bool>(),
                    ColumnRegExpression = new Dictionary<string, bool>(),
                    ColumnSearch = new Dictionary<string, string>(),
                    ColumnSearchable = new Dictionary<string, bool>(),
                    ColumnSortDirection = new Dictionary<string, string>(),
                    ColumnSorted = hasColSorted != null ? int.Parse(hasColSorted.Value.ToString()) : 0,
                    DisplayStart = hasDisplayStart != null ? int.Parse(hasDisplayStart.Value.ToString()) : 0,
                    DisplayLength = hasDisplayLength != null ? int.Parse(hasDisplayLength.Value.ToString()) : 0,
                };

            foreach (var i in instance.Where(i => i.Key.Contains(DataItemCollectionNames.MdataProp)))
            {
                trans.DataProperties.Add(new KeyValuePair<string, string>(i.Key, i.Value.ToString()));
            }

            var browserData = new BrowserData();

            var collectionByDataTable = !string.IsNullOrEmpty(trans.GlobalSearch)
                                            ? browserData.GetGlobalFiltered(trans.GlobalSearch)
                                            : browserData.GetFiltered(trans.SortedColumnSearchName,
                                                                      trans.SortedColumnSearchValue,
                                                                      trans.SortedColumnDirectionValue.ToLower() == "asc");

            // it's a cheat that says count all the data
            var totalRecords = GetAll().Count;

            // this is another cheat that says count all the filtered results
            var totalDisplay = collectionByDataTable.Count;

            // now we start to transform this class to a the one that implements the IDataTableSerializer
            var transformed = new List<BrowserDataTableWrap>();

            // simple loop
            foreach (var browser in browserData.Reduce(collectionByDataTable, trans.DisplayStart, trans.DisplayLength))
            {
                var browserDataTableWrap = new BrowserDataTableWrap
                    {
                        Engine = browser.Engine,
                        Grade = browser.Grade,
                        Name = browser.Name,
                        Platform = browser.Platform,
                        Version = browser.Version,
                    };

                transformed.Add(browserDataTableWrap);
            }

            // finally, input the results into the datatable
            var dataTableWrapper = new DataTableWrapper<BrowserDataTableWrap>(trans, transformed)
                {
                    TotalRecords = totalRecords, // typically this total would be return in database
                    TotalDisplayRecords = totalDisplay // this is the max amount of filtererd matches
                };

            return dataTableWrapper;
        }
 public void TearDown()
 {
     _wrapper = null;
 }
 public void SetUp()
 {
     _wrapper = new DataTableWrapper<IDataTableSerializer>(null, null);
 }
 public void TearDown()
 {
     _mockRequestData = null;
     _wrapper = null;
     _expectedEchoValue = -999999999;
 }