/// <summary> /// Contents Predictive /// </summary> /// <param name="userProfile"></param> /// <returns></returns> protected async Task <IEnumerable <ArticleContent> > GetContentsPredictive(UserProfile userProfile, BusinessRule businessRule) { var filterDefinition = new FilterDefinitionBuilder <ArticleContent>(); FilterDefinition <ArticleContent> filter = null; if (!userProfile.FavoriteSection.IsNullOrEmpty()) { var categories = userProfile.FavoriteSection.Split("|").Select(x => x.ToLower()); filter = filterDefinition.In(x => x.Category.Parent, categories); filter = filter | filterDefinition.In(x => x.Category.SubCategory, categories); } if (businessRule != null) { filter = filter & filterDefinition.Eq(x => x.ContentType, businessRule.ContentType); } if (!userProfile.TriedBrand.IsNullOrEmpty()) { var brands = userProfile.TriedBrand.Split("|").Select(x => x.ToLower()); if (filter != null) { filter = filter | filterDefinition.In(x => x.Brand, brands); } else { filter = filterDefinition.In(x => x.Brand, brands); } } return(await _repository.FindAsync(filter, orderBy : x => x.GetOrderFor(businessRule.Default), skip : 0, take : businessRule.NumberOfContents)); }
async Task ICatalogDb <string, TFilterQuery, TData> .DeleteAsync(IEnumerable <string> ids) { foreach (var batch in ids.Batch(10000)) { await _mols.DeleteManyAsync(_filterBuilder.In(_idPropName, ids)); } }
public async Task <IAsyncCursor <BsonDocument> > GetCursor(ResumeToken resumeToken, IEnumerable <string> collections, CancellationToken cancellationToken) { BsonValue ts; if (resumeToken.Token != null) { ts = resumeToken.Token["ts"]; } else { var operation = await operations .Find(new BsonDocument()) .Sort(Builders <BsonDocument> .Sort.Descending("$natural")) .FirstAsync(cancellationToken); ts = operation["ts"]; } var filter = builder.And( builder.In("op", new[] { "i", "u", "d" }), builder.Gt("ts", ts), builder.In("ns", collections.Select(collectionName => $"{databaseName}.{collectionName}")), builder.Exists("fromMigrate", false) ); var options = new FindOptions <BsonDocument> { CursorType = CursorType.TailableAwait, NoCursorTimeout = true, OplogReplay = true }; return(await operations.FindAsync(filter, options, cancellationToken)); }
private async Task UpdateDocumentsAsync(IList <T> updatedObservations) { Dictionary <string, T> updatedObservationsByCompositeId = updatedObservations.ToDictionary(x => $"{x.DataProviderId}_{x.CatalogNumber}", x => x); var filterDef = new FilterDefinitionBuilder <VersionedDocumentObservation <T> >(); var filter = filterDef.In(x => x.CompositeId, updatedObservations.Select(x => $"{x.DataProviderId}_{x.CatalogNumber}")); var foundObservations = await(await Collection.FindAsync(filter)).ToListAsync(); var changedObservations = new ConcurrentBag <VersionedDocumentObservation <T> >(); Parallel.For(0, foundObservations.Count - 1, i => { VersionedDocumentObservation <T> versionedObservation = foundObservations[i]; var updatedObservation = updatedObservationsByCompositeId[versionedObservation.CompositeId]; if (UpdateVersionedObservationObject(versionedObservation, updatedObservation)) { changedObservations.Add(versionedObservation); } }); if (changedObservations.Count > 0) { // todo - create transaction? var deleteFilter = filterDef.In(x => x.CompositeId, changedObservations.Select(x => $"{x.DataProviderId}_{x.CatalogNumber}")); await Collection.DeleteManyAsync(deleteFilter); await Collection.InsertManyAsync(changedObservations); } }
private FilterDefinition <MessageJournalEntryDocument> BuildFilter(MessageJournalFilter filter, FilterDefinition <MessageJournalEntryDocument> filterDef, FilterDefinitionBuilder <MessageJournalEntryDocument> fb) { if (filter == null) { return(filterDef); } if (filter.Topics.Any()) { var topics = filter.Topics.Select(Normalize); filterDef = filterDef & fb.In(e => e.Topic, topics); } if (filter.Categories.Any()) { var categories = filter.Categories.Select(Normalize); filterDef = filterDef & fb.In(e => e.Category, categories); } if (filter.From != null) { filterDef = filterDef & fb.Gte(e => e.Timestamp, filter.From); } if (filter.To != null) { filterDef = filterDef & fb.Lte(e => e.Timestamp, filter.To); } if (filter.Origination != null) { var origination = Normalize(filter.Origination); filterDef = filterDef & fb.Eq(e => e.Origination, origination); } if (filter.Destination != null) { var destination = Normalize(filter.Destination); filterDef = filterDef & fb.Eq(e => e.Destination, destination); } if (!string.IsNullOrWhiteSpace(filter.MessageName)) { var partial = Normalize(filter.MessageName); var pattern = ".*" + Regex.Escape(partial) + ".*"; var regex = new BsonRegularExpression(pattern, "i"); filterDef = filterDef & fb.Regex(e => e.MessageName, regex); } if (filter.RelatedTo != null) { var relatedTo = Normalize(filter.RelatedTo); filterDef = filterDef & fb.Eq(e => e.RelatedTo, relatedTo); } return(filterDef); }
public virtual async Task <IEnumerable <WorkspaceDbModel> > GetManyByIdAsync(IDbContext dbContext, IEnumerable <string> ids) { var filterDef = new FilterDefinitionBuilder <WorkspaceDbModel>(); var filter = filterDef.In(x => x.Id, ids); return(await dbContext.GetManyAsync <WorkspaceDbModel>(DbSchema.WorkspaceContainer, filter)); }
public async Task <List <T> > FindIn(Expression <Func <T, string> > field, IEnumerable <string> items) { IMongoCollection <T> collection = GetAnchorSetMongoCollection(); FilterDefinitionBuilder <T> f = new FilterDefinitionBuilder <T>(); return(await collection.Find(f.In(field, items)).ToListAsync()); }
public static FilterDefinition <MongoContentEntity> ToFilter(this Query query, Guid schemaId, Status[] status) { var filters = new List <FilterDefinition <MongoContentEntity> > { Filter.Eq(x => x.IndexedSchemaId, schemaId), Filter.Ne(x => x.IsDeleted, true) }; if (status != null) { filters.Add(Filter.In(x => x.Status, status)); } var filter = query.BuildFilter <MongoContentEntity>(); if (filter.Filter != null) { if (filter.Last) { filters.Add(filter.Filter); } else { filters.Insert(0, filter.Filter); } } return(Filter.And(filters)); }
public IEnumerable <IGroup> GetGroups(IEnumerable <string> groupIds) { var query = _filter.In("GroupId", groupIds); var groups = collection.Find(query); return(groups.ToList()); }
public async Task <IList <ImageModel> > GetAllByIds(IList <string> ids) { var filterDef = new FilterDefinitionBuilder <ImageModel>(); var filter = filterDef.In(x => x.Id, ids.ToArray()); return(await Images.Find(filter).ToListAsync()); }
private FilterDefinition <ToDoListEntity> ApplyWhereStatement(FilterDefinitionBuilder <ToDoListEntity> builder, ListQueryDataStructure queryDataStructure) { FilterDefinition <ToDoListEntity> filter = builder.Ne(x => x.Status, (int)ToDoListStatus.Archived); if (queryDataStructure.Id.HasValue) { filter = filter & (builder.Eq(x => x.Id, queryDataStructure.Id.Value)); } if (queryDataStructure.UserId.HasValue) { filter = filter & (builder.Eq(x => x.UserId, queryDataStructure.UserId.Value)); } if (!string.IsNullOrWhiteSpace(queryDataStructure.Name)) { filter = filter & (builder.Regex(x => x.Name, queryDataStructure.Name)); } if (queryDataStructure.Statuses != null && queryDataStructure.Statuses.Any()) { filter = filter & (builder.In(x => x.Status, queryDataStructure.Statuses)); } return(filter); }
public void TestCreateFlowWithAssociatedSecurityAccounts() { var collection = _database.GetCollection <ProcessDefinitionPersistence>(MongoProcessDefinitionPersistenceService.CollectionName); IProcessDefinitionPersisnenceService service = InstService(); AccountData[] accounts = new[] { new AccountData { AccountType = 1, Id = Guid.NewGuid(), Name = "Underwriters", SourceSystem = "ActiveDirectory" }, new AccountData { AccountType = 1, Id = Guid.NewGuid(), Name = "Modeler", SourceSystem = "ActiveDirectory" }, }; OnCreateFlowWithAssociatedSecutityAccounts(service, accounts); Assert.AreEqual(1, collection.Count(pd => true)); FilterDefinitionBuilder <ProcessDefinitionPersistence> fb = Builders <ProcessDefinitionPersistence> .Filter; var fd = fb.In("Accounts.Name", new string[] { "Underwriters" }); List <ProcessDefinitionPersistence> pds = collection.Find(fd).ToList(); Assert.IsNotNull(pds); Assert.AreEqual(1, pds.Count); Assert.IsNotNull(pds[0].Accounts); Assert.AreEqual(2, pds[0].Accounts.Count); }
/// <summary> /// Consulte uma lista de conceitos que correspondem a um id. /// </summary> /// <param name="campo">O campo a ser pesquisado.</param> /// <param name="ids">Os ids de a serem pesquisados.</param> /// <returns></returns> public List <T> ConsulteListaDeIds(Expression <Func <T, Guid> > campo, Guid[] ids) { var definicaoDeFiltro = new FilterDefinitionBuilder <T>(); var filtro = definicaoDeFiltro.In(campo, ids); return(Collection().Find(filtro).ToList()); }
public static FilterDefinition <MongoContentEntity> BuildQuery(ODataUriParser query, Guid schemaId, Schema schema, Status[] status) { var filters = new List <FilterDefinition <MongoContentEntity> > { Filter.Eq(x => x.SchemaId, schemaId), Filter.In(x => x.Status, status) }; var filter = FilterBuilder.Build(query, schema); if (filter != null) { filters.Add(filter); } if (filters.Count > 1) { return(Filter.And(filters)); } else if (filters.Count == 1) { return(filters[0]); } else { return(new BsonDocument()); } }
IDictionary <string, MongoMtgDeck> FindDecksByName(IEnumerable <string> names) { var decksByNameFilter = _filter.In("Name", names); var result = collection.Find(decksByNameFilter); return(result.ToEnumerable().ToDictionary(deck => deck.Name)); }
Dictionary <string, MongoMtgCard> FindCardsByNames(IEnumerable <string> cardNames) { var findCardsFilter = _filter.In("Name", cardNames); var result = collection.Find(findCardsFilter); return(result.ToEnumerable().ToDictionary(card => card.Name)); }
/// <summary> /// Get Contents By Segment /// </summary> /// <param name="segmentedCode"></param> /// <returns></returns> public async Task <IEnumerable <ArticleContent> > GetContentsBySegment(IEnumerable <Segmentation> segments, BusinessRule businessRule, IEnumerable <string> exclude = null) { //Todo get all segmentCodes var segmentedCodes = segments.Select(x => x.SegmentedCode).ToList(); var contentSegments = await _repository.GetAllAsync <SegmentedContent>(x => x.SegmentedCode.Equals(segmentedCodes[0])); var contentIds = contentSegments.Select(x => x.ContentId); var filterDefinition = new FilterDefinitionBuilder <ArticleContent>(); var filter = filterDefinition.In(x => x.ContentId, contentIds); if (businessRule != null) { filter = filter & filterDefinition.Eq(x => x.ContentType, businessRule.ContentType); } if (exclude != null) { filter = filter & filterDefinition.Nin(x => x.ContentId, exclude); } return(await _repository.FindAsync <ArticleContent>(filter, orderBy : x => x.OrderByDescending(d => d.Title))); }
public static FilterDefinition <MongoContentEntity> BuildQuery(ODataUriParser query, Guid schemaId, Status[] status, PropertyCalculator propertyCalculator) { var filters = new List <FilterDefinition <MongoContentEntity> > { Filter.Eq(x => x.SchemaId, schemaId), Filter.In(x => x.Status, status), Filter.Eq(x => x.IsDeleted, false) }; var filter = query.BuildFilter <MongoContentEntity>(propertyCalculator); if (filter.Filter != null) { if (filter.Last) { filters.Add(filter.Filter); } else { filters.Insert(0, filter.Filter); } } if (filters.Count == 1) { return(filters[0]); } else { return(Filter.And(filters)); } }
public async Task <List <Permission> > GetByNames(string[] names) { var filterDef = new FilterDefinitionBuilder <Permission>(); var filter = filterDef.In(x => x.Name, names); var permissions = await _context.Permissions.Find(filter).ToListAsync(); return(permissions); }
public virtual async Task <IList <E> > GetAsync(IEnumerable <string> ids) { var definition = new FilterDefinitionBuilder <E>(); var filter = definition.In(x => x.Id, ids); using (var cursor = await collection.FindAsync(filter)) { return(cursor.ToList()); } }
private List <string> GetRolePermissions(string[] roleNames) { var filterDef = new FilterDefinitionBuilder <IdentityRole>(); var filter = filterDef.In(x => x.NormalizedName, roleNames); var roles = _dbContext.Roles.Find(filter).ToList() ?? new List <IdentityRole>(); var permissions = roles.ToList().SelectMany(r => r.Permissions ?? new List <string>()).Distinct().ToList(); return(permissions); }
public DbQuery <TEntity> Contains <TField>(Expression <Func <TEntity, TField> > expression, IEnumerable <TField> values) { if (values != null && values.Any()) { FilterDefinition = _builder.And(FilterDefinition, _builder.In(expression, values)); } return(this); }
private List <OutputTable> FetchOutputs(List <Outpoint> outputs) { FilterDefinitionBuilder <OutputTable> builder = Builders <OutputTable> .Filter; FilterDefinition <OutputTable> filter = builder.In(output => output.Outpoint, outputs); var res = db.OutputTable.Find(filter).ToList(); return(res); }
public override FilterDefinition <T> Visit(CompareFilter <ClrValue> nodeIn, None args) { var propertyName = nodeIn.Path.ToString(); var value = nodeIn.Value.Value; switch (nodeIn.Operator) { case CompareOperator.Empty: return(Filter.Or( Filter.Exists(propertyName, false), Filter.Eq <object?>(propertyName, null), Filter.Eq <object?>(propertyName, string.Empty), Filter.Size(propertyName, 0))); case CompareOperator.Exists: return(Filter.And( Filter.Exists(propertyName, true), Filter.Ne <object?>(propertyName, null))); case CompareOperator.Matchs: return(Filter.Regex(propertyName, BuildMatchRegex(nodeIn))); case CompareOperator.StartsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s))); case CompareOperator.Contains: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s))); case CompareOperator.EndsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$"))); case CompareOperator.Equals: return(Filter.Eq(propertyName, value)); case CompareOperator.GreaterThan: return(Filter.Gt(propertyName, value)); case CompareOperator.GreaterThanOrEqual: return(Filter.Gte(propertyName, value)); case CompareOperator.LessThan: return(Filter.Lt(propertyName, value)); case CompareOperator.LessThanOrEqual: return(Filter.Lte(propertyName, value)); case CompareOperator.NotEquals: return(Filter.Ne(propertyName, value)); case CompareOperator.In: return(Filter.In(propertyName, ((IList)value !).OfType <object>())); } throw new NotSupportedException(); }
private static void CreateOrderStatusFilter(HeatDataResultRequestDto input, FilterDefinitionBuilder <BsonDocument> builderFilter, List <FilterDefinition <BsonDocument> > filterDefinitions) { List <FilterDefinition <BsonDocument> > orderStatusFilterDefinitions = new List <FilterDefinition <BsonDocument> >(); input.OrderStatus.ForEach(x => { switch (x) { case InputOrderStatus.TotalStatus: default: break; case InputOrderStatus.CancelPlaceOrder: orderStatusFilterDefinitions.Add(builderFilter.And(builderFilter.In("orderStatus", new List <int>() { 30, 40, 45 }), builderFilter.Exists("updateTimeList.status5", false))); break; case InputOrderStatus.CancelAcceptOrder: orderStatusFilterDefinitions.Add(builderFilter.And(builderFilter.In("orderStatus", new List <int>() { 30, 40, 45 }), builderFilter.Exists("updateTimeList.status5", true))); break; case InputOrderStatus.CompletedOrder: orderStatusFilterDefinitions.Add(builderFilter.Exists("updateTimeList.status20", true)); break; case InputOrderStatus.ToBeCompletedOrder: orderStatusFilterDefinitions.Add(builderFilter.And(builderFilter.Exists("updateTimeList.status20", false), builderFilter.Not(builderFilter.In("orderStatus", new List <int>() { 30, 40, 45 })))); break; } }); if (orderStatusFilterDefinitions.Count > 0) { filterDefinitions.Add(builderFilter.Or(orderStatusFilterDefinitions)); } }
public static FilterDefinition <BsonDocument> GetCustomerFilter() { var filterBuilder = new FilterDefinitionBuilder <BsonDocument>(); var managerFilter = filterBuilder.Eq("ManagerNr", "100670"); var monthFilter = filterBuilder.In("Month", new[] { 10, 12 }); var minDateFilter = filterBuilder.Ne("DateOfBirth", DateTime.MinValue); var filter = managerFilter & monthFilter & minDateFilter; return(filter); }
/// <summary> Removes <see cref="Word"/>s from the Frontier with specified wordIds and projectId </summary> /// <returns> Number of words deleted </returns> public async Task <long> DeleteFrontier(string projectId, List <string> wordIds) { var filterDef = new FilterDefinitionBuilder <Word>(); var filter = filterDef.And( filterDef.Eq(x => x.ProjectId, projectId), filterDef.In(x => x.Id, wordIds)); var deleted = await _wordDatabase.Frontier.DeleteManyAsync(filter); return(deleted.DeletedCount); }
private Dictionary <string, UnspentOutputTable> FetchUtxos(IEnumerable <Outpoint> outputs) { FilterDefinitionBuilder <UnspentOutputTable> builder = Builders <UnspentOutputTable> .Filter; FilterDefinition <UnspentOutputTable> filter = builder.In(utxo => utxo.Outpoint, outputs); var res = db.UnspentOutputTable.FindSync(filter) .ToList() .ToDictionary(_ => _.Outpoint.ToString()); return(res); }
private static FilterDefinition <MongoContentEntity> CreateFilter(Guid?appId, Guid?schemaId, ICollection <Guid> ids, Status[] status, ClrQuery query) { var filters = new List <FilterDefinition <MongoContentEntity> >(); if (appId.HasValue) { filters.Add(Filter.Eq(x => x.IndexedAppId, appId.Value)); } if (schemaId.HasValue) { filters.Add(Filter.Eq(x => x.IndexedSchemaId, schemaId.Value)); } filters.Add(Filter.Ne(x => x.IsDeleted, true)); if (status != null) { filters.Add(Filter.In(x => x.Status, status)); } if (ids != null && ids.Count > 0) { if (ids.Count > 1) { filters.Add(Filter.In(x => x.Id, ids)); } else { filters.Add(Filter.Eq(x => x.Id, ids.First())); } } if (query?.Filter != null) { filters.Add(query.Filter.BuildFilter <MongoContentEntity>()); } return(Filter.And(filters)); }
public static void Main() { //setup var widgetCollection = new MongoClient("mongodb://localhost:27017") .GetDatabase("WidgetDatabase") .GetCollection <Widget>("Widget"); widgetCollection.DeleteManyAsync(x => true).Wait(); //remove all existing rows //create widgets and add to DB; 2 SKUs, each with multiple revisions var widgetA1 = new Widget() { SKU = "aaaa", Revision = 1M, Cost = 10 }; var widgetA2 = new Widget() { SKU = "aaaa", Revision = 2.1M, Cost = 20 }; var widgetA3 = new Widget() { SKU = "aaaa", Revision = 2.2M, Cost = 30 }; var widgetB1 = new Widget() { SKU = "bbbb", Revision = 1M, Cost = 40 }; var widgetB2 = new Widget() { SKU = "bbbb", Revision = 1.1M, Cost = 50 }; widgetCollection.InsertManyAsync(new[] { widgetA1, widgetA2, widgetA3, widgetB1, widgetB2 }).Wait(); //get the ObjectId of the most Recent revision of each SKU var r = widgetCollection .Aggregate() .SortByDescending(x => x.Revision) .Group(x => x.SKU, g => new { Id = g.First().Id }) .ToListAsync() .Result; //get the Widget objects for the list of ids just collected var builder = new FilterDefinitionBuilder <Widget>(); var w = widgetCollection .Find(builder.In(x => x.Id, r.Select(x => x.Id))) .ToListAsync() .Result; //check results Debug.Assert(w.Count() == 2); Debug.Assert(w.Single(x => x.SKU == "aaaa").Revision == 2.2M); Debug.Assert(w.Single(x => x.SKU == "bbbb").Revision == 1.1M); }