示例#1
0
        // GET: api/Incumbent
        public IEnumerable<BsonDocument> Get()
        {
            var svc = new Akron.Data.DataService();
               var queryDoc = new QueryDocument();
               var queryGroup = new GroupDefinition();

               var qb = new QueryBuilder();

               qb.SelectedSlicers.Add(new DimensionDefinition
               {
               Column = new DataColumnMetadata { ColumnName = "Year" },
               IsDefault = true
               });
               qb.SelectedSlicers.Add(new DimensionDefinition
               {
               Column = new DataColumnMetadata { ColumnName = "org_type" }

               });
               qb.SelectedMeasures = new List<MeasureDefinition>
            {
                new MeasureDefinition
                {
                    Column = new DataColumnMetadata {ColumnName = "Base_Pay"},
                    IsDefault = true,
                    Operation = AggregateOperations.Average
                }
            };
               var qd = qb.ToQueryDocument();
               qd.CollectionName = "incumbent";
               qd.DataSource = "hra";
               qd.DataSourceLocation = "mongodb://localhost:27017";
               var result = svc.GetData(qd);
               return result;
        }
示例#2
0
        private QueryBuilder GetQueryBuilder()
        {
            var queryBuilder = new QueryBuilder();

            BsonClassMap.RegisterClassMap<DataCollectionMetadata>(cm =>
            {
                cm.AutoMap();
                cm.MapIdMember(c => c.CollectionName);

            });
            var client = new MongoClient("mongodb://localhost:27017");
            var db = client.GetDatabase("hra");
            var items = db.GetCollection<DataCollectionMetadata>("collectionMetadata");
            var collectionItems = db.GetCollection<BsonDocument>("incumbent");

            FilterDefinition<DataCollectionMetadata> filter = new BsonDocument("_id", "incumbent");
            var md = items.Find<DataCollectionMetadata>(filter);
            //var ct = md.CountAsync().Result;

            var metaData = md.SingleAsync().Result;
            var fValues = new List<String>();
            var tasks = new List<Task<IAsyncCursor<string>>>();
            metaData.Filters.ForEach(f =>
            {
                var filterDefinition = new FilterDefinition();

                filterDefinition.Column = f;

                FieldDefinition<BsonDocument, string> field = f.ColumnName;
                var dd = Task<IAsyncCursor<string>>.Factory.StartNew(() =>
                {
                    var t = collectionItems.DistinctAsync<string>(field, new BsonDocument());
                    t.GetAwaiter().OnCompleted(() =>
                    {
                        t.Result.ForEachAsync((z) =>
                        {
                            filterDefinition.AvailableFilterValues.Add(new FilterValue {Key = z, Value = z});
                        });
                    });
                    return t.Result;
                });

                tasks.Add(dd);
                queryBuilder.AvailableFilters.Add(filterDefinition);
            });

            Task.WaitAll(tasks.ToArray());
            Assert.IsFalse(queryBuilder.SelectedFilters.Any());

            var gd = new GroupDefinition();

            gd.Dimensions.Add(new DimensionDefinition
            {
                Column = new DataColumnMetadata { ColumnName = "Year", DataType = ColumnDataTypes.Int32 },
                IsDefault=true
            });

            var fd = new MeasureDefinition();
            fd.Column = new DataColumnMetadata {ColumnName = "Base_Pay", DataType = ColumnDataTypes.Double};
            fd.IsDefault = true;

            gd.Measures.Add(fd);
            return queryBuilder;
        }
示例#3
0
        public static QueryDocument ToQueryDocument(this QueryBuilder source)
        {
            var result = new QueryDocument();
            var match = new MatchDefinition();

                match.Filters = source.AvailableFilters;

            var group = new GroupDefinition();
            group.Measures = source.SelectedMeasures;

            group.Dimensions = source.SelectedSlicers;
            var project = group.ToProjectionDocument();
            if (source.AvailableFilters.Any(x => x.AvailableFilterValues.Any(y => y.Active)))
                result.Pipeline.Add(match.ToMatchDocument());
            result.Pipeline.Add(group.ToGroupDocument());

            result.Pipeline.Add(project);
            return result;
        }
示例#4
0
        GroupDefinition GetGroupDefinition()
        {
            var result = new GroupDefinition();
            //possible slicers
            var jobFamily = new DataColumnMetadata {ColumnName = "Job_Family"};
            var jobFamilyValue = new FilterValue {Key = "Health Care", Value="Health Care"};
            var jobTrack = new DataColumnMetadata {ColumnName = "Job_Track" };
            //slicer remains constant when selected
            var yearColumn = new DataColumnMetadata {ColumnName = "Year"};

            //measure

            var basePayColumn = new DataColumnMetadata {ColumnName = "Base_Pay"};
            var basePayMeasure = new MeasureDefinition
            {
                Operation = AggregateOperations.Average,
                Column = basePayColumn,
                IsDefault=true
            };
            //TODO no Selected Value thats a filter
            result.Dimensions.Add(new DimensionDefinition { Column = yearColumn, IsDefault=true });
            result.Dimensions.Add(new DimensionDefinition
            {
                Column = jobFamily
            });

            result.Measures.Add(basePayMeasure);

            return result;
        }