Beispiel #1
0
        public override void LoadViewFilters(bool enabledFilters)
        {
            base.LoadViewFilters(enabledFilters);
            var dataSource = Page.DataSource;
            var structure  = Page.DataSource.CurrentStructure;
            var filters    = dataSource.FindFiltersGroupByName("ViewFilters");

            if (filters != null)
            {
                structure.Filters.Remove(filters);
            }
            filters = structure.CreateFiltersGroup("ViewFilters", LogicalOperationStrict.And);
            DataSourceFilterExpression leftExpression  = structure.CreateDataSourceFilterExpression("SysWorkspace");
            DataSourceFilterExpression rightExpression = structure.CreateDataSourceFilterExpression(
                new object[] {
                //new Guid("0C039963-C53D-E111-851E-00155D04C01D")

                UserConnection.Workspace.Id
            });
            var filterItem = new DataSourceFilter(dataSource.Schema, Terrasoft.Core.Entities.FilterComparisonType.Equal,
                                                  leftExpression, rightExpression);

            filterItem.Name      = "All";
            filterItem.IsEnabled = true;
            filters.Add(filterItem);
            structure.Filters.Add(filters);
        }
Beispiel #2
0
 public override async Task InsertAsync()
 {
     var dataSource = DataSourceFilter.Elect(new RequestContext { DataSourceChoice = DataSourceChoice.Write });
     var dbSession = SessionStore.GetOrAddDbSession(dataSource);
     await dbSession.OpenConnectionAsync();
     var conn = dbSession.Connection as NpgsqlConnection;
     InitColumnMappings();
     var colNames = String.Join(",", ColumnMappings.Keys);
     var copyFromCommand = $"COPY {Table.Name} ({colNames}) FROM STDIN (FORMAT BINARY)";
     using (var writer = conn.BeginBinaryImport(copyFromCommand))
     {
         foreach (var row in Table.Rows)
         {
             writer.StartRow();
             foreach (var mappingKey in ColumnMappings.Keys)
             {
                 var colMapping = ColumnMappings[mappingKey];
                 var dbCellVal = row[colMapping.Column];
                 if (!String.IsNullOrEmpty(colMapping.DataTypeName))
                 {
                     writer.Write(dbCellVal, colMapping.DataTypeName);
                 }
                 else
                 {
                     writer.Write(dbCellVal);
                 }
             }
         }
         writer.Complete();
     }
 }
        /// <summary>
        /// Resets the filter set by this control.
        /// </summary>
        public void ResetFilter()
        {
            DataSourceFilter filter = GetDataSourceFilter();

            if (filter != null)
            {
                filter.Remove(FFilterElement);
            }
            FFilterElement = null;
        }
Beispiel #4
0
        public override async Task InsertAsync()
        {
            var dataSource = DataSourceFilter.Elect(new RequestContext {
                DataSourceChoice = DataSourceChoice.Write
            });
            var dbSession = SessionStore.GetOrAddDbSession(dataSource);
            await dbSession.OpenConnectionAsync();

            var             conn       = dbSession.Connection as MySqlConnection;
            MySqlBulkLoader bulkLoader = GetBulkLoader(conn);
            await bulkLoader.LoadAsync();
        }
        public DataSource Map(DataSourceFilter filter, DataSource dataSource, CreateOrEditViewModel createOrEdit)
        {
            if (dataSource.Id == 0)
            {
                dataSource.EndpointId = (int)filter.Endpoint.Id;
            }

            dataSource.Code = createOrEdit.Code;
            dataSource.DataProviderCSharpClassName = createOrEdit.DataProviderCSharpClassName;
            dataSource.DataProviderParameters      = createOrEdit.DataProviderParameters;
            return(dataSource);
        }
        public DataSourceFilterViewModel(DataSourceInfo dataSourceInfo, DataSourceFilter dataSourceFilter)
        {
            if (dataSourceFilter == null)
            {
                throw new ArgumentNullException("dataSourceFilter");
            }

            this._eventAggregator = ServiceLocator.Current.GetInstance<IEventAggregator>();

            this.DataSourceInfo = dataSourceInfo;
            this.DataSourceFilter = dataSourceFilter;
        }
        /// <summary>
        /// Applies the filter to a datasource.
        /// </summary>
        /// <remarks>
        /// Call this method if you set the <see cref="AutoFilter"/> property to <b>false</b>.
        /// </remarks>
        public void FilterData()
        {
            DataSourceFilter filter = GetDataSourceFilter();

            if (filter != null)
            {
                ResetFilter();
                if (Enabled)
                {
                    FilterData(filter);
                }
            }
        }
        private void FilterData(DataSourceFilter filter)
        {
            object value = GetValue();

            // convert string value to appropriate data format
            if (value is string)
            {
                Column dataColumn = DataHelper.GetColumn(Report.Dictionary, DataColumn);
                if (dataColumn != null)
                {
                    value = Convert.ChangeType((string)value, dataColumn.DataType);
                }
            }

            FFilterElement = filter.Add(value, FilterOperation);
        }
Beispiel #9
0
        public override async Task InsertAsync()
        {
            var dataSource = DataSourceFilter.Elect(new RequestContext {
                DataSourceChoice = DataSourceChoice.Write
            });
            var dbSession = SessionStore.GetOrAddDbSession(dataSource);
            await dbSession.OpenConnectionAsync();

            var conn = dbSession.Connection as SqlConnection;

            using (SqlBulkCopy sqlBulkCopy = new SqlBulkCopy(conn))
            {
                sqlBulkCopy.DestinationTableName = Table.Name;
                InitColumnMappings();
                var dataTable = Table.ToDataTable(ColumnMappings);
                await sqlBulkCopy.WriteToServerAsync(dataTable);
            }
        }
        private DataSourceFilter GetDataSourceFilter()
        {
            if (!String.IsNullOrEmpty(DataColumn))
            {
                DataSourceBase ds = DataHelper.GetDataSource(Report.Dictionary, DataColumn);
                if (ds != null)
                {
                    DataSourceFilter filter = ds.AdditionalFilter[DataColumn] as DataSourceFilter;
                    if (filter == null)
                    {
                        filter = new DataSourceFilter();
                        ds.AdditionalFilter[DataColumn] = filter;
                    }

                    return(filter);
                }
            }

            return(null);
        }
        public IndexViewModel Create(HttpContext httpContext, DataSourceFilter filter, IEnumerable <DataSource> dataSources, string orderBy, int skip, int take, int total)
        {
            IStringLocalizer <IndexViewModelFactory> localizer = httpContext.GetStringLocalizer <IndexViewModelFactory>();

            return(new IndexViewModel()
            {
                Filter = filter,
                Grid = new GridViewModelFactory().Create(
                    httpContext,
                    new FilterViewModelFactory().Create(httpContext, "Code.Contains", localizer["Code"]),
                    orderBy, skip, take, total,
                    new[] {
                    new GridColumnViewModelFactory().Create(localizer["Code"], "Code"),
                    new GridColumnViewModelFactory().Create(localizer["Data provider C# class name"], "DataProviderCSharpClassName"),
                    new GridColumnViewModelFactory().CreateEmpty()
                },
                    dataSources.Select(ds => new DataSourceViewModelFactory().Create(ds)),
                    "_DataSource"
                    )
            });
        }
Beispiel #12
0
        private static bool IsAnyLeftExpressionNullOrEmpty(DataSourceFilter filter)
        {
            bool result = false;

            if (filter == null)
            {
                return(result);
            }

            if (filter.ComparisonType == FilterComparisonType.IsNull ||
                filter.ComparisonType == FilterComparisonType.IsNotNull)
            {
                return(result);
            }
            if (filter.LeftExpression == null)
            {
                return(true);
            }
            if (filter.RightExpression == null)
            {
                result = true;
            }
            else
            {
                if (filter.RightExpression.Type == DataSourceFilterExpressionType.SchemaColumn ||
                    filter.RightExpression.Type == DataSourceFilterExpressionType.Aggregation)
                {
                    result = String.IsNullOrEmpty(filter.RightExpression.TargetColumnPath);
                }

                if (filter.RightExpression.Type == DataSourceFilterExpressionType.Parameter)
                {
                    result = !(filter.RightExpression.Parameters != null &&
                               filter.RightExpression.Parameters.Count != 0);
                }
            }

            return(result);
        }