/// <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);
}
