Esempio n. 1
0
		public void Setup()
		{
			_repository = new MemoryRepository<TestItem>();
			PopulateRepositoryWithItemsForQuerying(_repository);
			_queryToCache = new QueryAdapter<TestItem>();
			_queryToCache.Show("StoredString");
			_results = _repository.GetItemsMatching(_queryToCache);
			_sortDefinitions = new SortDefinition[1];
			_sortDefinitions[0] = new SortDefinition("StoredString", Comparer<string>.Default);
		}
		public void Compare_KhmerWordsUsingDefaultCollation_ComparesNotEqual()
		{
			using (var e = new TestEnvironment())
			{
				var ws = new WritingSystemDefinition("en") {DefaultCollation = new IcuRulesCollationDefinition("standard")};
				var sd1 = new SortDefinition("Form", ws.DefaultCollation.Collator);
				var results1 = new Dictionary<string, object> {{"Form", "សង្ឃនៃអំបូរអឺរ៉ុន"}};
				var results2 = new Dictionary<string, object> {{"Form", "បូជាចារ្យនៃអំបូរអឺរ៉ុន"}};
				var rt1 = new RecordToken<PalasoTestItem>(e.DataMapper, results1, new TestRepositoryId(8));
				var rt2 = new RecordToken<PalasoTestItem>(e.DataMapper, results2, new TestRepositoryId(8));

				var rtc = new RecordTokenComparer<PalasoTestItem>(new[] { sd1 });

				int order = rtc.Compare(rt1, rt2);
				Assert.That(order, Is.Not.EqualTo(0));
			}
		}
		public void Compare_EnglishWordsUsingInvariantCulture_ComparesNotEqual()
		{
			using (var e = new TestEnvironment())
			{
				var sd1 = new SortDefinition("Form", StringComparer.InvariantCulture);
				var results1 = new Dictionary<string, object>();
				results1.Add("Form", "form1");
				var results2 = new Dictionary<string, object>();
				results2.Add("Form", "form2");
				var rt1 = new RecordToken<PalasoTestItem>(e.DataMapper, results1, new TestRepositoryId(8));
				var rt2 = new RecordToken<PalasoTestItem>(e.DataMapper, results2, new TestRepositoryId(8));

				var rtc = new RecordTokenComparer<PalasoTestItem>(new[] {sd1});

				int order = rtc.Compare(rt1, rt2);
				Assert.That(order, Is.Not.EqualTo(0));
			}
		}
		public void Compare_KhmerWordsUsingOrdinal_ComparesNotEqual()
		{
			using (var e = new TestEnvironment())
			{
				var sd1 = new SortDefinition("Form", StringComparer.Ordinal);
				var results1 = new Dictionary<string, object>();
				results1.Add("Form", "សង្ឃនៃអំបូរអឺរ៉ុន");
				var results2 = new Dictionary<string, object>();
				results2.Add("Form", "បូជាចារ្យនៃអំបូរអឺរ៉ុន");
				var rt1 = new RecordToken<PalasoTestItem>(e.DataMapper, results1, new TestRepositoryId(8));
				var rt2 = new RecordToken<PalasoTestItem>(e.DataMapper, results2, new TestRepositoryId(8));

				var rtc = new RecordTokenComparer<PalasoTestItem>(new[] { sd1 });

				int order = rtc.Compare(rt1, rt2);
				Assert.That(order, Is.Not.EqualTo(0));
			}
		}
Esempio n. 5
0
        private dynamic GetManifests(BsonDocument filter, SortDefinition<Manifest> sort, int numOfRecords, int skip)
        {
            var manifestCollection = GetManifestCollection();

            var task = manifestCollection.Find(filter).Sort(sort).Skip(skip).Limit(numOfRecords).ToListAsync();
            var result = task.Result;

            var manifests = result.Select(x => new
            {
                Id = x.Id.ToString(),
                Timestamp = TimeServices.UnixTimeStampToDateTime(x.Timestamp).ToString(),
                Author = x.Author,
                Text = x.Text,
                Rank = x.Rank
            });

            return manifests;
        }
		public void Compare_KhmerWordsUsingWritingSystemSameAsOtherLanguage_ComparesNotEqual()
		{
			using (var e = new TestEnvironment())
			{
				var ws = new WritingSystemDefinition("en");
				ws.SortUsing = WritingSystemDefinition.SortRulesType.OtherLanguage;
				ws.SortRules = "km-KH";
				var sd1 = new SortDefinition("Form", ws.Collator);
				var results1 = new Dictionary<string, object>();
				results1.Add("Form", "សង្ឃនៃអំបូរអឺរ៉ុន");
				var results2 = new Dictionary<string, object>();
				results2.Add("Form", "បូជាចារ្យនៃអំបូរអឺរ៉ុន");
				var rt1 = new RecordToken<PalasoTestItem>(e.DataMapper, results1, new TestRepositoryId(8));
				var rt2 = new RecordToken<PalasoTestItem>(e.DataMapper, results2, new TestRepositoryId(8));

				var rtc = new RecordTokenComparer<PalasoTestItem>(new[] { sd1 });

				int order = rtc.Compare(rt1, rt2);
				Assert.That(order, Is.Not.EqualTo(0));
			}
		}
Esempio n. 7
0
        public List <T> FindAllList <T>(string collectionName, SortDefinition <T> sort = null, ProjectionDefinition <T> projection = null)
        {
            MongoClient client     = GetClient(m_connectionStr);
            var         db         = client.GetDatabase(DatabaseName);
            var         collection = db.GetCollection <T>(collectionName);

            if (projection == null)
            {
                var list = sort == null?
                           collection.Find <T>(x => true).ToList() :
                               collection.Find <T>(x => true).Sort(sort).ToList();

                return(list);
            }
            else
            {
                var list = sort == null?
                           collection.Find <T>(x => true).Project <T>(projection).ToList() :
                               collection.Find <T>(x => true).Sort(sort).Project <T>(projection).ToList();

                return(list);
            }
        }
        /// <summary>
        /// get data from mongodb, you can filter and sort data from object desired
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="databaseName"></param>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <returns>
        /// list of data type List<Covid19>
        /// </returns>
        public List <Covid19> GetDataFromMongoDB(object obj, string databaseName,
                                                 FilterDefinition <Covid19> filter, SortDefinition <Covid19> sort)
        {
            var configMongoDb = configuration.GetSection("MongoDB").Value;

            if (string.IsNullOrEmpty(configMongoDb))
            {
                configMongoDb = Environment.GetEnvironmentVariable("MongoDB");
            }

            var dbCollection = obj.GetType().Name;

            MongoClient client     = new MongoClient(configMongoDb);
            var         db         = client.GetDatabase(databaseName);
            var         collection = db.GetCollection <Covid19>(dbCollection);

            List <Covid19> CoronaDatas = collection
                                         .Find(filter)
                                         .Sort(sort)
                                         .ToList();

            return(CoronaDatas);
        }
Esempio n. 9
0
        /// <summary>
        /// 查询记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expression">查询表达式</param>
        /// <param name="sort"></param>
        /// <param name="dbName"></param>
        /// <returns></returns>
        public static List <T> GetDoc <T>(Expression <Func <T, bool> > expression, SortDefinition <T> sort = null, string dbName = "SystemLog")
        {
            try
            {
                //获取数据库
                var db   = Client.GetDatabase(dbName);
                var name = typeof(T).Name;
                //获取集合
                var collection = db.GetCollection <T>(name);
                if (collection == null)
                {
                    db.CreateCollection(name);
                    collection = db.GetCollection <T>(name);
                }

                return(collection.Find(expression).Sort(sort).ToList());
            }
            catch (Exception ex)
            {
                //异常不处理
                return(null);
            }
        }
Esempio n. 10
0
        public static List <T> Populate <T>(string memoryId,
                                            FilterDefinition <BsonDocument> _q = null, int take = 0, int skip = 0,
                                            string[] fields = null,
                                            SortDefinition <BsonDocument> sort = null,
                                            string collectionName = "", bool memoryObject = false, bool forceReadDb = false)
        {
            var docs = DataHelper.Populate(memoryId, q: _q, take: take, skip: skip, fields: fields, sort: sort, collectionName: collectionName,
                                           memoryObject: memoryObject, forceReadDb: forceReadDb);
            List <T> ret = new List <T>();

            foreach (var doc in docs)
            {
                try
                {
                    ret.Add(BsonSerializer.Deserialize <T>(doc));
                }
                catch (Exception exc)
                {
                    throw new Exception("Unable to deserialize BsonDocument => " + JsonConvert.SerializeObject(doc.ToDictionary()));
                }
            }
            return(ret);
        }
Esempio n. 11
0
        public static IFindFluent <BsonDocument, BsonDocument> ApplyTransform <T>(this IMongoCollection <BsonDocument> source, QueryTransform transform) where T : Data <T>
        {
            var queryDocument = transform?.ToBsonQuery() ?? new BsonDocument();
            var sortDocument  = transform?.ToBsonFilter() ?? new BsonDocument();

            SortDefinition <BsonDocument> sortFilter = sortDocument;

            if (Info <T> .Configuration?.AutoGenerateMissingSchema == true)
            {
                source.TryCreateIndex <T>(sortDocument);
            }

            var fluentCollection = source.Find(queryDocument);

            if (sortFilter != null)
            {
                fluentCollection.Sort(sortFilter);
            }

            fluentCollection.Paginate(transform);

            return(fluentCollection);
        }
Esempio n. 12
0
 /// <summary>
 /// Get Records for a page
 /// </summary>
 /// <returns></returns>
 public List <T> GetPagedRecords(PageRecordModel pageRecordModel, SortDefinition <T> sortDefinition = null, FilterDefinition <T> filterDefinition = null, ProjectionDefinition <T> projection = null)
 {
     if (sortDefinition == null && filterDefinition == null)
     {
         return(_collection.Find(x => true).Skip(pageRecordModel.PageSize * (pageRecordModel.PageNumber - 1)).Limit(pageRecordModel.PageSize).ToList());
     }
     else if (sortDefinition != null && filterDefinition != null)
     {
         return(_collection.Find(filterDefinition).Skip(pageRecordModel.PageSize * (pageRecordModel.PageNumber - 1)).Limit(pageRecordModel.PageSize).Sort(sortDefinition).ToList());
     }
     else if (sortDefinition == null && filterDefinition != null)
     {
         return(_collection.Find(filterDefinition).Skip(pageRecordModel.PageSize * (pageRecordModel.PageNumber - 1)).Limit(pageRecordModel.PageSize).ToList());
     }
     else if (sortDefinition != null && filterDefinition == null)
     {
         return(_collection.Find(x => true).Skip(pageRecordModel.PageSize * (pageRecordModel.PageNumber - 1)).Limit(pageRecordModel.PageSize).Sort(sortDefinition).ToList());
     }
     else
     {
         return(_collection.Find(filterDefinition).Skip(pageRecordModel.PageSize * (pageRecordModel.PageNumber - 1)).Limit(pageRecordModel.PageSize).Sort(sortDefinition).ToList());
     }
 }
Esempio n. 13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="source"></param>
        /// <returns></returns>
        public static Task <ObjectId> UploadFromBytes(string fileName, byte[] source)
        {
            //构建查询,用于检查是否已存在
            FilterDefinition <GridFSFileInfo> filter = Builders <GridFSFileInfo> .Filter.And(
                Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, fileName)
                //Builders<GridFSFileInfo>.Filter.Gte(x => x.UploadDateTime, new DateTime(2015, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
                );

            //排序规则
            SortDefinition <GridFSFileInfo> sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);

            //查找限制,提高处理速度
            GridFSFindOptions options = new GridFSFindOptions {
                Limit = 1,
                Sort  = sort
            };

            using (var cursor = bucket.Find(filter, options))
            {
                GridFSFileInfo fileInfo = cursor.ToList().FirstOrDefault();
                return(fileInfo == null?Task.FromResult(bucket.UploadFromBytesAsync(fileName, source).Result) : Task.FromResult(fileInfo.Id));
            }
        }
Esempio n. 14
0
        /// <summary>
        /// 获取排序信息。
        /// </summary>
        /// <returns></returns>
        public static SortDefinition GetSorting(this HttpContext context)
        {
            var def = new SortDefinition();
            var request = context.Request;
#if NETSTANDARD2_0
            if (!request.HasFormContentType)
            {
                return def;
            }
#endif

            def.Member = request.Form["sort"];
            if (string.IsNullOrEmpty(request.Form["order"]))
            {
                def.Order = SortOrder.None;
            }
            else
            {
                def.Order = request.Form["order"] == "desc" ? SortOrder.Descending : SortOrder.Ascending;
            }

            return def;
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="projection"></param>
        /// <param name="sortExp"></param>
        /// <param name="sortType"></param>
        /// <param name="limit"></param>
        /// <param name="skip"></param>
        /// <param name="hint"></param>
        /// <returns></returns>
        public FindOptions <T, T> CreateFindOptions <T>(ProjectionDefinition <T, T> projection   = null
                                                        , Expression <Func <T, object> > sortExp = null, SortType sortType = SortType.Ascending
                                                        , int limit = 0, int skip = 0, BsonValue hint = null)
        {
            var option = new FindOptions <T, T>();

            if (limit > 0)
            {
                option.Limit = limit;
            }
            if (skip > 0)
            {
                option.Skip = skip;
            }

            if (projection != null)
            {
                option.Projection = projection;
            }

            SortDefinition <T> sort = CreateSortDefinition(sortExp, sortType);

            if (sort != null)
            {
                option.Sort = sort;
            }

            if (hint != null)
            {
                option.Modifiers = new BsonDocument
                {
                    { "$hint", hint }
                };
            }

            return(option);
        }
Esempio n. 16
0
        public IEnumerable <LinkingBank> Get(LinkingBankFilter employeeFilter)
        {
            FilterDefinition <LinkingBank>         filter = Builders <LinkingBank> .Filter.Empty;
            List <FilterDefinition <LinkingBank> > ops    = new List <FilterDefinition <LinkingBank> >(10);

            if (!employeeFilter.Id.Equals(Guid.Empty))
            {
                ops.Add(Builders <LinkingBank> .Filter.Eq(x => x.Id, employeeFilter.Id));
            }

            if (!string.IsNullOrEmpty(employeeFilter.Name))
            {
                ops.Add(Builders <LinkingBank> .Filter.Eq(x => x.Name, employeeFilter.Name));
            }

            if (!string.IsNullOrEmpty(employeeFilter.Code))
            {
                ops.Add(Builders <LinkingBank> .Filter.Eq(x => x.Code, employeeFilter.Code));
            }

            if (ops.Count > 0)
            {
                filter = Builders <LinkingBank> .Filter.And(ops);
            }

            SortDefinition <LinkingBank>           sort    = null;
            FindOptions <LinkingBank, LinkingBank> options = null;

            options = new FindOptions <LinkingBank, LinkingBank>()
            {
                Sort = sort
            };

            var task = _Collection.Find(filter);

            return(task.ToEnumerable());
        }
Esempio n. 17
0
        public List <BsonDocument> FindByKVPair(string set_name, FilterDefinition <BsonDocument> filterDef, object sort_list = null, int limit = 0, int skip = 0)
        {
            SortDefinition <BsonDocument> sorts = null;

            if (sort_list != null)
            {
                SortDefinitionBuilder <BsonDocument>  builderSort = Builders <BsonDocument> .Sort;
                List <SortDefinition <BsonDocument> > sort        = new List <SortDefinition <BsonDocument> >();
                foreach (KeyValuePair <string, string> kvp in sort_list as Dictionary <string, string> )
                {
                    if (kvp.Value == "ASC")
                    {
                        sort.Add(builderSort.Ascending(kvp.Key));
                    }
                    else
                    {
                        sort.Add(builderSort.Descending(kvp.Key));
                    }
                }
                sorts = builderSort.Combine(sort.ToList());
            }
            IFindFluent <BsonDocument, BsonDocument> find_op = mdb.GetCollection <BsonDocument>(set_name).Find(filterDef);

            if (sorts != null)
            {
                find_op = find_op.Sort(sorts);
            }
            if (skip > 0)
            {
                find_op = find_op.Skip(skip);
            }
            if (limit > 0)
            {
                find_op = find_op.Limit(limit);
            }
            return(find_op.ToList());
        }
Esempio n. 18
0
        protected void UpdateGrid(NameValueCollection values, List <FilterDefinition <T> > filter, JArray fieldsJArray = null,
                                  string gridName = "Grid1")
        {
            var fieldsStr     = values[gridName + "_fields"];
            var fields        = fieldsJArray ?? JArray.Parse(fieldsStr);
            var pageIndex     = Convert.ToInt32(values[gridName + "_pageIndex"] ?? "0");
            var sortField     = values[gridName + "_sortField"];
            var sortDirection = values[gridName + "_sortDirection"];

            var where = filter != null && filter.Any() ? Builders <T> .Filter.And(filter) : null;

            SortDefinition <T> sort = null;

            if (!string.IsNullOrEmpty(sortField))
            {
                if (!string.IsNullOrEmpty(sortDirection))
                {
                    var exp = sortField.ToLambda <T>();
                    if (sortDirection.Equals("ASC", StringComparison.CurrentCultureIgnoreCase))
                    {
                        sort = Builders <T> .Sort.Ascending(exp);
                    }
                    else if (sortDirection.Equals("DESC", StringComparison.CurrentCultureIgnoreCase))
                    {
                        sort = Builders <T> .Sort.Descending(exp);
                    }
                }
            }
            var list = Rep.QueryByPage(pageIndex, PageSize, out var count, where, sort);

            // 导出用
            Session["list"] = list;
            var grid = UIHelper.Grid(gridName);

            grid.RecordCount(count);
            grid.DataSource(list, fields);
        }
Esempio n. 19
0
        /// <summary>
        /// 查询集合
        /// <param name="filter">查询条件</param>
        /// <param name="field">要查询的字段,不写时查询全部</param>
        /// <param name="sort">要排序的字段</param>
        /// <returns></returns>
        public List <T> GetList(FilterDefinition <T> filter, string[] field = null, SortDefinition <T> sort = null)
        {
            try
            {
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                    {
                        return(mongoDb.Find(filter).ToList());
                    }
                    //进行排序
                    return(mongoDb.Find(filter).Sort(sort).ToList());
                }

                //制定查询字段
                var fieldList = new List <ProjectionDefinition <T> >();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders <T> .Projection.Include(field[i].ToString()));
                }
                var projection = Builders <T> .Projection.Combine(fieldList);

                fieldList?.Clear();
                if (sort == null)
                {
                    return(mongoDb.Find(filter).Project <T>(projection).ToList());
                }
                //排序查询
                return(mongoDb.Find(filter).Sort(sort).Project <T>(projection).ToList());
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 根据条件获取获取列表
        /// </summary>
        /// <param name="filterExp">查询条件表达式</param>
        /// <param name="includeFieldExp">查询字段表达式</param>
        /// <param name="sortExp">排序表达式</param>
        /// <param name="sortType">排序方式</param>
        /// <param name="limit"></param>
        /// <param name="skip"></param>
        /// <param name="hint">hint索引</param>
        /// <param name="readPreference">访问设置</param>
        /// <returns></returns>
        public async Task <List <TEntity> > GetListAsync(Expression <Func <TEntity, bool> > filterExp = null, Expression <Func <TEntity, object> > includeFieldExp = null, Expression <Func <TEntity, object> > sortExp = null, SortType sortType = SortType.Ascending, int limit = 0, int skip = 0, BsonValue hint = null, ReadPreference readPreference = null)
        {
            FilterDefinition <TEntity> filter = null;
            ProjectionDefinition <TEntity, TEntity> projection = null;
            SortDefinition <TEntity> sort = null;

            if (filterExp != null)
            {
                filter = Builders <TEntity> .Filter.Where(filterExp);
            }
            else
            {
                filter = Builders <TEntity> .Filter.Empty;
            }
            sort = base.CreateSortDefinition <TEntity>(sortExp, sortType);
            if (includeFieldExp != null)
            {
                projection = base.IncludeFields <TEntity>(includeFieldExp);
            }
            FindOptions <TEntity, TEntity> options = base.CreateFindOptions <TEntity>(projection, sort, limit, skip, hint);
            IAsyncCursor <TEntity>         source  = await base.GetCollection(readPreference).FindAsync <TEntity>(filter, options, default(CancellationToken)).ConfigureAwait(false);

            return(await source.ToListAsync(default(CancellationToken)).ConfigureAwait(false));
        }
Esempio n. 21
0
        private ResultSet <LexEntry> GetAllEntriesSortedById()
        {
            string cacheName = String.Format("sortedById");

            if (_caches[cacheName] == null)
            {
                var IdQuery = new DelegateQuery <LexEntry>(
                    delegate(LexEntry entryToQuery)
                {
                    IDictionary <string, object> tokenFieldsAndValues = new Dictionary <string, object>();
                    tokenFieldsAndValues.Add("Id", entryToQuery.Id);
                    return(new[] { tokenFieldsAndValues });
                });
                ResultSet <LexEntry> itemsMatching = _decoratedDataMapper.GetItemsMatching(IdQuery);

                var sortOrder = new SortDefinition[1];
                sortOrder[0] = new SortDefinition("Id", Comparer <string> .Default);

                _caches.Add(cacheName, new ResultSetCache <LexEntry>(this, sortOrder, itemsMatching, IdQuery));
            }
            ResultSet <LexEntry> resultsFromCache = _caches[cacheName].GetResultSet();

            return(resultsFromCache);
        }
        public void Compare_KhmerWordsUsingDefaultCollation_ComparesNotEqual()
        {
            using (var e = new TestEnvironment())
            {
                var ws = new WritingSystemDefinition("en")
                {
                    DefaultCollation = new IcuRulesCollationDefinition("standard")
                };
                var sd1      = new SortDefinition("Form", ws.DefaultCollation.Collator);
                var results1 = new Dictionary <string, object> {
                    { "Form", "សង្ឃនៃអំបូរអឺរ៉ុន" }
                };
                var results2 = new Dictionary <string, object> {
                    { "Form", "បូជាចារ្យនៃអំបូរអឺរ៉ុន" }
                };
                var rt1 = new RecordToken <PalasoTestItem>(e.DataMapper, results1, new TestRepositoryId(8));
                var rt2 = new RecordToken <PalasoTestItem>(e.DataMapper, results2, new TestRepositoryId(8));

                var rtc = new RecordTokenComparer <PalasoTestItem>(new[] { sd1 });

                int order = rtc.Compare(rt1, rt2);
                Assert.That(order, Is.Not.EqualTo(0));
            }
        }
        //刷新周排行榜 1,周财富榜,2,周战绩榜
        public static async Task <List <Log_Rank> > QueryJsonRank(this DBProxyComponent self, int type)
        {
            DBComponent dbComponent = Game.Scene.GetComponent <DBComponent>();
            FilterDefinition <Log_Rank> filterDefinition = new JsonFilterDefinition <Log_Rank>($"{{}}");

            FilterDefinition <Log_Rank> filterEmpty    = Builders <Log_Rank> .Filter.Empty;
            SortDefinition <Log_Rank>   sortDefinition = Builders <Log_Rank> .Sort.Descending("");

            IAsyncCursor <Log_Rank> asyncCursor = await dbComponent.GetDBDataCollection <Log_Rank>(typeof(Log_Rank).Name).FindAsync(filterDefinition);



            List <Log_Rank> components = new List <Log_Rank>();

            if (type == 1)
            {
                components = await dbComponent.GetDBDataCollection <Log_Rank>(typeof(Log_Rank).Name).Find(filterDefinition).SortByDescending(a => a.Wealth).Limit(50).ToListAsync();
            }
            else if (type == 2)
            {
                components = await dbComponent.GetDBDataCollection <Log_Rank>(typeof(Log_Rank).Name).Find(filterDefinition).SortByDescending(a => a.WinGameCount).Limit(50).ToListAsync();
            }
            return(components);
        }
Esempio n. 24
0
        /// <summary>
        /// Fetch list of entities matching criteria on repository
        /// </summary>
        /// <param name="filterExpression">Filter expression</param>
        /// <param name="startRowIndex">Start row index</param>
        /// <param name="maximumRows">Maximum rows</param>
        /// <param name="sortExpression">Filter expression</param>
        /// <param name="isDescending">Is descending sorting</param>
        /// <returns>Returns list of all available entities</returns>
        public IList <TEntity> Fetch(Expression <Func <TEntity, bool> > filterExpression = null, int?startRowIndex = null, int?maximumRows = null,
                                     Expression <Func <TEntity, object> > sortExpression = null, bool isDescending = false)
        {
            //Applico il filtro sulla collezione; se il filtro non è impostato
            //definisco un builder vuoto che ritorna sempre tutti gli elementi
            IFindFluent <TEntity, TEntity> query = filterExpression != null
                ? Collection.Find(filterExpression)
                : Collection.Find(Builders <TEntity> .Filter.Empty);

            //Se ho un ordinamento
            if (sortExpression != null)
            {
                //Applico ascendente o discendente
                SortDefinition <TEntity> sortDefinition = isDescending
                    ? Builders <TEntity> .Sort.Descending(sortExpression)
                    : Builders <TEntity> .Sort.Ascending(sortExpression);

                //Applico l'ordinamento
                query = query.Sort(sortDefinition);
            }

            //Se ho impostato la riga di inizio
            if (startRowIndex != null)
            {
                query = query.Skip(startRowIndex.Value);
            }

            //Se ho impostato la riga di fine
            if (maximumRows != null)
            {
                query = query.Limit(maximumRows.Value);
            }

            //Ritorno il valore
            return(query.ToList());
        }
Esempio n. 25
0
        /// <summary>根据键值对生成Mongo排序</summary>
        public static SortDefinition <TDocument> BuildSort <TDocument>(this IMongoCollection <TDocument> accessor, IList <PKSKeyValuePair <string, int> > sortRules)
        {
            SortDefinition <TDocument> result = null;

            if (!sortRules.IsNullOrEmpty())
            {
                var builder = Builders <TDocument> .Sort;
                var sorts   = new List <SortDefinition <TDocument> >(sortRules.Count);
                foreach (var pair in sortRules)
                {
                    FieldDefinition <TDocument> field = pair.Key;
                    if (pair.Value == 0)
                    {
                        sorts.Add(builder.Ascending(field));
                    }
                    else
                    {
                        sorts.Add(builder.Descending(field));
                    }
                }
                result = builder.Combine(sorts);
            }
            return(result);
        }
Esempio n. 26
0
        /// <summary>
        /// 查询分页数据
        /// </summary>
        public async Task <List <T> > GetByPageAsync <T>(FilterDefinition <T> filter, int pageIndex, int pageSize, SortDefinition <T> sort = null)
        {
            var skip   = pageSize * (pageIndex - 1);
            var finder = GetCollection <T>().Find(filter).Sort(sort);

            return(await finder.Skip(skip).Limit(pageSize).ToListAsync());
        }
Esempio n. 27
0
 public List <user> FindListByPage(FilterDefinition <user> filter, int pageIndex, int pageSize, string[] field = null, SortDefinition <user> sort = null)
 {
     return(mongoDBHelper.FindListByPageAsync(filter, pageIndex, pageSize, field, sort).Result);
 }
Esempio n. 28
0
 public List <user> FindListAsync(FilterDefinition <user> filter, SortDefinition <user> sort = null)
 {
     return(mongoDBHelper.FindListAsync(filter, sort).Result);
 }
Esempio n. 29
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="whereStr">以where 开始</param>
 /// <returns></returns>
 public static IList <Mongo_Users> Select(Expression <Func <Mongo_Users, bool> > filter, SortDefinition <Mongo_Users> order)
 {
     try
     {
         using (var access = new Mongo_UsersAccess())
         {
             return(access.Select(filter, order));
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Esempio n. 30
0
        public async Task <HttpResponseMessage> GetActivityByCountries(ActivitySearchByCountry_RQ param)
        {
            ActivitySearchResult resultList = new ActivitySearchResult();

            if (param.PageSize > 100)
            {
                resultList.Message = "Page Size shouldn't be greater than 100.";
                return(Request.CreateResponse(HttpStatusCode.BadRequest, resultList));
            }

            _database = MongoDBHandler.mDatabase();

            string[] arrayOfStrings;

            if (!string.IsNullOrWhiteSpace(param.RequestingSupplierCode))
            {
                //Get System Country Codes from Supplier Codes
                var collection = _database.GetCollection <BsonDocument>("CountryMapping");
                FilterDefinition <BsonDocument> filterCountry;
                filterCountry = Builders <BsonDocument> .Filter.Empty;

                filterCountry = filterCountry & Builders <BsonDocument> .Filter.AnyIn("SupplierCountryCode", param.CountryCodes.Select(s => s.Trim().ToUpper()).Distinct());

                filterCountry = filterCountry & Builders <BsonDocument> .Filter.Eq("SupplierCode", param.RequestingSupplierCode.Trim().ToUpper());

                ProjectionDefinition <BsonDocument> projectCountry = Builders <BsonDocument> .Projection.Include("CountryCode").Exclude("_id");

                var searchCountryResult = await collection.Find(filterCountry).Project(projectCountry).ToListAsync();

                arrayOfStrings = searchCountryResult.Select(s => s["CountryCode"].AsString).ToArray();
            }
            else
            {
                arrayOfStrings = param.CountryCodes.Select(s => s.Trim().ToUpper()).Distinct().ToArray();
            }


            //get Activities
            IMongoCollection <BsonDocument> collectionActivity = _database.GetCollection <BsonDocument>("ActivityDefinitions");
            FilterDefinition <BsonDocument> filter;

            filter = Builders <BsonDocument> .Filter.Empty;
            filter = filter & Builders <BsonDocument> .Filter.AnyIn("CountryCode", arrayOfStrings);

            if (param.FilterBySuppliers != null)
            {
                if (param.FilterBySuppliers.Length > 0)
                {
                    filter = filter & Builders <BsonDocument> .Filter.AnyIn("SupplierCompanyCode", param.FilterBySuppliers.Select(s => s.Trim().ToLower()));
                }
            }

            var TotalRecords = await collectionActivity.Find(filter).CountDocumentsAsync();

            List <ActivityDefinition> searchedData = new List <ActivityDefinition>();

            if (TotalRecords != 0 && param.PageSize != 0)
            {
                SortDefinition <BsonDocument> sortByid = Builders <BsonDocument> .Sort.Ascending("_id");

                var searchResult = await collectionActivity.Find(filter).Skip(param.PageSize * param.PageNo).Limit(param.PageSize).Sort(sortByid).ToListAsync(); //.Sort(sortByPrices)

                searchedData = JsonConvert.DeserializeObject <List <ActivityDefinition> >(searchResult.ToJson());

                resultList.PageSize    = param.PageSize;
                resultList.CurrentPage = param.PageNo;

                int remainder = (int)TotalRecords % param.PageSize;
                int quotient  = (int)TotalRecords / param.PageSize;
                if (remainder > 0)
                {
                    remainder = 1;
                }
                resultList.TotalPage = quotient + remainder;
            }
            else
            {
                resultList.TotalPage = 0;
            }

            resultList.CurrentPage             = param.PageNo;
            resultList.TotalNumberOfActivities = TotalRecords;
            resultList.Activities = (from a in searchedData
                                     select new Activity
            {
                ActivityCode = a.SystemActivityCode,
                SupplierCompanyCode = a.SupplierCompanyCode,
                SupplierProductCode = a.SupplierProductCode,
                InterestType = a.InterestType,
                Category = a.Category,
                Type = a.Type,
                SubType = a.SubType,
                CategoryGroup = a.CategoryGroup,
                DisplayName = a.DisplayName ?? a.Name,
                Name = a.Name,
                Description = a.Description,
                DaysOfTheWeek = a.DaysOfTheWeek,
                PhysicalIntensity = a.PhysicalIntensity,
                Overview = a.Overview,
                Recommended = a.Recommended,
                CountryName = a.CountryName,
                CountryCode = a.CountryCode,
                CityName = a.CityName,
                CityCode = a.CityCode,
                StarRating = a.StarRating,
                NumberOfReviews = a.NumberOfReviews,
                NumberOfLikes = a.NumberOfLikes,
                NumberOfViews = a.NumberOfViews,
                ActivityMedia = a.ActivityMedia,
                DeparturePoint = a.DeparturePoint,
                ReturnDetails = a.ReturnDetails,
                ProductOptions = a.ProductOptions,
                NumberOfPassengers = a.NumberOfPassengers,
                Prices = a.Prices,
                SuitableFor = a.SuitableFor,
                Specials = a.Specials,
                SupplierCityDepartureCodes = a.SupplierCityDepartureCodes
            }).ToList();

            foreach (var activity in searchedData)
            {
                var loadedActivity = resultList.Activities.Where(w => w.ActivityCode == activity.SystemActivityCode).First();

                FilterDefinition <BsonDocument> filterForSimilarProducts;
                filterForSimilarProducts = Builders <BsonDocument> .Filter.Empty;

                filterForSimilarProducts = filterForSimilarProducts & Builders <BsonDocument> .Filter.Ne("_id", activity.SystemActivityCode);

                filterForSimilarProducts = filterForSimilarProducts & Builders <BsonDocument> .Filter.Eq("CityCode", activity.CityCode);

                filterForSimilarProducts = filterForSimilarProducts & Builders <BsonDocument> .Filter.AnyIn("ProductSubTypeId", activity.ProductSubTypeId);

                ProjectionDefinition <BsonDocument> project = Builders <BsonDocument> .Projection.Include("_id");

                project = project.Include("Name");
                project = project.Include("Categories");
                project = project.Include("Prices");
                project = project.Include("ProductOptions");

                var SimilarProdSearchResult = await collectionActivity.Find(filterForSimilarProducts).Project(project).ToListAsync();

                List <ActivityDefinition> SimilarProdSearchResultObj = JsonConvert.DeserializeObject <List <ActivityDefinition> >(SimilarProdSearchResult.ToJson());

                if (SimilarProdSearchResultObj != null)
                {
                    loadedActivity.SimliarProducts = SimilarProdSearchResultObj.Select(s => new SimliarProducts
                    {
                        SystemActivityCode = s.SystemActivityCode.ToString(),
                        SystemActivityName = s.Name,
                        CategoryGroup      = s.CategoryGroup,
                        Options            = s.ProductOptions,
                        Prices             = s.Prices
                    }).ToList();
                }
            }

            return(Request.CreateResponse(HttpStatusCode.OK, resultList));
        }
Esempio n. 31
0
        public MetricsData[] Get(int date)
        {
            List <MetricsData> list = new List <MetricsData>();

            if (VenvitoHelper.UseMongo)
            {
                IMongoCollection <MetricsDefinition> definitionCollection = VenvitoHelper.GetMongoDefinitionCollection();
                if (definitionCollection.Count(Builders <MetricsDefinition> .Filter.Empty) == 0)
                {
                    string contentRootPath          = m_HostingEnvironment.ContentRootPath;
                    string metricJson               = System.IO.File.ReadAllText(Path.Combine(contentRootPath, "App_Data/MetricsDefinitions.json"));
                    MetricsDefinition[] definitions = Newtonsoft.Json.JsonConvert.DeserializeObject <MetricsDefinition[]>(metricJson);
                    for (int i = 0; i < definitions.Length; i++)
                    {
                        definitions[i].sortOrder = i * 100;
                    }
                    definitionCollection.InsertMany(definitions);
                }

                List <MetricsData> result = new List <MetricsData>();

                IMongoCollection <MetricsData>     dataCollection = VenvitoHelper.GetMongoDataCollection();
                SortDefinition <MetricsDefinition> sortDefinition = Builders <MetricsDefinition> .Sort.Ascending(new StringFieldDefinition <MetricsDefinition>("sortOrder"));

                List <MetricsDefinition> metricsDefinitions = definitionCollection.Aggregate().Sort(sortDefinition).ToList <MetricsDefinition>();
                foreach (MetricsDefinition metricsDef in metricsDefinitions)
                {
                    FilterDefinition <MetricsData> filter = Builders <MetricsData> .Filter.And(
                        Builders <MetricsData> .Filter.Eq("code", metricsDef.code),
                        Builders <MetricsData> .Filter.Eq("date", date));

                    List <MetricsData> data        = dataCollection.FindSync <MetricsData>(filter).ToList <MetricsData>();
                    decimal            value       = (data.Count == 1 ? data[0].value : 0);
                    MetricsData        metricsData = new MetricsData()
                    {
                        code        = metricsDef.code,
                        description = metricsDef.description,
                        type        = metricsDef.type,
                        color       = metricsDef.color,
                        date        = date,
                        value       = value
                    };
                    result.Add(metricsData);
                }
                return(result.ToArray());
            }
            else
            {
                using (SqlConnection conn = VenvitoHelper.CreateDbConnection())
                {
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = "usp_MetricsData_Get";
                        cmd.CommandType = CommandType.StoredProcedure;
                        cmd.Parameters.Add(new SqlParameter("Date", VenvitoHelper.IntToDate(date)));
                        using (SqlDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                list.Add(new MetricsData
                                {
                                    date        = date,
                                    code        = Convert.ToString(dr["MetricsCode"]),
                                    description = Convert.ToString(dr["MetricsDescription"]),
                                    type        = Convert.ToString(dr["MetricsType"]),
                                    color       = Convert.ToString(dr["Color"]),
                                    value       = Convert.ToDecimal(dr["MetricsValue"])
                                });
                            }
                        }
                    }
                }
            }

            return(list.ToArray <MetricsData>());
        }
Esempio n. 32
0
        private async Task InitializeAsync(IMongoCollection <T> source, FilterDefinition <T> filterdefinition, SortDefinition <T> sortdefinition, int pageIndex, int pageSize)
        {
            TotalCount = (int)await source.CountDocumentsAsync(filterdefinition);

            AddRange(await source.Find(filterdefinition).Sort(sortdefinition).Skip(pageIndex * pageSize).Limit(pageSize).ToListAsync());
            if (pageSize > 0)
            {
                TotalPages = TotalCount / pageSize;
                if (TotalCount % pageSize > 0)
                {
                    TotalPages++;
                }
            }
            PageSize  = pageSize;
            PageIndex = pageIndex;
        }
Esempio n. 33
0
        public static async Task <PagedList <T> > Create(IMongoCollection <T> source, FilterDefinition <T> filterdefinition, SortDefinition <T> sortdefinition, int pageIndex, int pageSize)
        {
            var pagelist = new PagedList <T>();
            await pagelist.InitializeAsync(source, filterdefinition, sortdefinition, pageIndex, pageSize);

            return(pagelist);
        }
Esempio n. 34
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public override Page <DataAccess.Trace> RetrievePages(PaginationOption po, DateTime?startTime, DateTime?endTime, string ip)
        {
            // filter
            var filterBuilder = Builders <DataAccess.Trace> .Filter;
            var filter        = filterBuilder.Empty;

            if (startTime.HasValue)
            {
                filter = filterBuilder.Gt("LogTime", startTime.Value);
            }
            if (endTime.HasValue)
            {
                filter = filterBuilder.Lt("LogTime", endTime.Value.AddDays(1).AddSeconds(-1));
            }
            if (!string.IsNullOrEmpty(ip))
            {
                filter = filterBuilder.Eq("Ip", ip);
            }
            if (startTime == null && endTime == null)
            {
                filter = filterBuilder.Gt("LogTime", DateTime.Today.AddMonths(0 - DictHelper.RetrieveAccessLogPeriod()));
            }

            // sort
            var sortBuilder = Builders <DataAccess.Trace> .Sort;
            SortDefinition <DataAccess.Trace> sort = null;

            switch (po.Sort)
            {
            case "LogTime":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.LogTime) : sortBuilder.Descending(t => t.LogTime);
                break;

            case "IP":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.Ip) : sortBuilder.Descending(t => t.Ip);
                break;

            case "UserName":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.UserName) : sortBuilder.Descending(t => t.UserName);
                break;

            case "City":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.City) : sortBuilder.Descending(t => t.City);
                break;

            case "Browser":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.Browser) : sortBuilder.Descending(t => t.Browser);
                break;

            case "OS":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.OS) : sortBuilder.Descending(t => t.OS);
                break;

            case "RequestUrl":
                sort = po.Order == "asc" ? sortBuilder.Ascending(t => t.RequestUrl) : sortBuilder.Descending(t => t.RequestUrl);
                break;
            }

            var traces = DbManager.Traces.Find(filter).Sort(sort).ToList();

            return(new Page <DataAccess.Trace>()
            {
                Context = traces,
                CurrentPage = po.PageIndex,
                ItemsPerPage = po.Limit,
                TotalItems = traces.Count,
                TotalPages = (long)Math.Ceiling(traces.Count * 1.0 / po.Limit),
                Items = traces.Skip(po.Offset).Take(po.Limit).ToList()
            });
        }
Esempio n. 35
0
        public void SortDefinition_GetNextSortKey_Test1()
        {
            var data = this.TestData1(10);
            Article article = null;
            SortDefinition<Article> sort_def = new SortDefinition<Article>() {
                Fields = new[]{   //ソート列定義
                    article.DefineSort(a=>a.Title),
                    article.DefineSort(a=>a.Viewcount),
                    article.DefineSort(a=>a.Published)
                },
                SortKey = "Title"   //ソート対象
            };

            var keyforlink= sort_def.GetNextSortKey(a=>a.Title);
            Assert.AreEqual("Title desc", keyforlink);

            keyforlink = sort_def.GetNextSortKey(a => a.Viewcount);
            Assert.AreEqual("Viewcount", keyforlink);
        }
        /// <summary>
        /// 根据条件获取实体
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <param name="projection"></param>
        /// <param name="hint">hint索引</param>
        /// <param name="readPreference">访问设置</param>
        /// <returns></returns>
        public async Task <TEntity> GetAsync(FilterDefinition <TEntity> filter, ProjectionDefinition <TEntity, TEntity> projection = null, SortDefinition <TEntity> sort = null, BsonValue hint = null, ReadPreference readPreference = null)
        {
            if (filter == null)
            {
                filter = Builders <TEntity> .Filter.Empty;
            }
            FindOptions <TEntity, TEntity> options = base.CreateFindOptions <TEntity>(projection, sort, 1, 0, hint);
            IAsyncCursor <TEntity>         cursor  = await base.GetCollection(readPreference).FindAsync <TEntity>(filter, options, default(CancellationToken)).ConfigureAwait(false);

            return(await cursor.FirstOrDefaultAsync(default(CancellationToken)).ConfigureAwait(false));
        }
Esempio n. 37
0
        public void SortDefinition_Test1()
        {
            var data = this.TestData1(10);
            Article article = null;
            SortDefinition<Article> sort_def = new SortDefinition<Article>() {
                Fields=new[]{   //ソート列定義
                    article.DefineSort(a=>a.Title),
                    article.DefineSort(a=>a.Viewcount),
                    article.DefineSort(a=>a.Published)
                },
                SortKey = "Title"   //ソート対象
            };
            data= sort_def.AddOrderBy(data); //かつてループだったところ

            var result = data.ToArray();
            for (var i = 0; i < 10; i++) {
                Assert.AreEqual(i, result[i].Viewcount);
            }
        }
        /// <summary>
        /// 根据条件获取获取列表
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="projection"></param>
        /// <param name="sort"></param>
        /// <param name="limit"></param>
        /// <param name="skip"></param>
        /// <param name="hint">hint索引</param>
        /// <param name="readPreference">访问设置</param>
        /// <returns></returns>
        public async Task <List <TEntity> > GetListAsync(FilterDefinition <TEntity> filter, ProjectionDefinition <TEntity, TEntity> projection = null, SortDefinition <TEntity> sort = null, int limit = 0, int skip = 0, BsonValue hint = null, ReadPreference readPreference = null)
        {
            if (filter == null)
            {
                filter = Builders <TEntity> .Filter.Empty;
            }
            FindOptions <TEntity, TEntity> options = base.CreateFindOptions <TEntity>(projection, sort, limit, skip, hint);
            IAsyncCursor <TEntity>         source  = await base.GetCollection(readPreference).FindAsync <TEntity>(filter, options, default(CancellationToken)).ConfigureAwait(false);

            return(await source.ToListAsync(default(CancellationToken)).ConfigureAwait(false));
        }
        // GET: Articles
        public ActionResult Index(string sort,string filter)
        {
            var query = db.Articles.AsQueryable();  //データソース
            // filter
            if(!string.IsNullOrEmpty(filter)) {
                query = query.Where(a => a.Title.Contains(filter) || a.Description.Contains(filter));
            }

            Article article = null;
            SortDefinition<Article> sort_def = new SortDefinition<Article>() {
                Fields = new[] {   //ソート列定義
                    article.DefineSort(a=>a.Url),
                    article.DefineSort(a=>a.Title),
                    article.DefineSort(a=>a.Description),
                    article.DefineSort(a=>a.Viewcount),
                    article.DefineSort(a=>a.Published),
                    article.DefineSort(a=>a.Released),
                },
                SortKey=sort
            };

            query=sort_def.AddOrderBy(query);

            ViewBag.SortDef = sort_def;     //リンク作成用にソート定義を渡す
            ViewBag.InputedFilter = filter; //入力されたフィルター
            return View(query.ToList());    //ソート済み結果をViewに返す。
        }