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 void UpsertEntry(UpsertIndexEntry upsert, List <WriteModel <MongoTextIndexEntity <T> > > writes)
{
writes.Add(
new UpdateOneModel <MongoTextIndexEntity <T> >(
Filter.And(
Filter.Eq(x => x.DocId, upsert.DocId),
Filter.Exists(x => x.GeoField, false),
Filter.Exists(x => x.GeoObject, false)),
Update
.Set(x => x.ServeAll, upsert.ServeAll)
.Set(x => x.ServePublished, upsert.ServePublished)
.Set(x => x.Texts, BuildTexts(upsert))
.SetOnInsert(x => x.Id, Guid.NewGuid().ToString())
.SetOnInsert(x => x.DocId, upsert.DocId)
.SetOnInsert(x => x.AppId, upsert.AppId.Id)
.SetOnInsert(x => x.ContentId, upsert.ContentId)
.SetOnInsert(x => x.SchemaId, upsert.SchemaId.Id))
{
IsUpsert = true
});
if (upsert.GeoObjects?.Any() == true)
{
if (!upsert.IsNew)
{
writes.Add(
new DeleteOneModel <MongoTextIndexEntity <T> >(
Filter.And(
Filter.Eq(x => x.DocId, upsert.DocId),
Filter.Exists(x => x.GeoField),
Filter.Exists(x => x.GeoObject))));
}
foreach (var(field, geoObject) in upsert.GeoObjects)
{
writes.Add(
new InsertOneModel <MongoTextIndexEntity <T> >(
new MongoTextIndexEntity <T>
{
Id = Guid.NewGuid().ToString(),
AppId = upsert.AppId.Id,
DocId = upsert.DocId,
ContentId = upsert.ContentId,
GeoField = field,
GeoObject = geoObject,
SchemaId = upsert.SchemaId.Id,
ServeAll = upsert.ServeAll,
ServePublished = upsert.ServePublished
}));
}
}
}
/// <summary>TODO The main 2.</summary>
public static async void Main2()
{
var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("test");
var collection = database.GetCollection <MongoDbRepositoryItem>("Lapsus");
var builder = Builders <MongoDbRepositoryItem> .Filter;
var b2 = new FilterDefinitionBuilder <MongoDbRepositoryItem>();
var f2 = b2.Exists(x => x.ProcessingStatus, false);
var result2 = await collection.FindAsync <MongoDbRepositoryItem>(f2);
// I didn't read about sorting yet. I also need the "oldest" document.
var filter = builder.Exists(item => item.ProcessingStatus, false);
try
{
var result = collection.FindAsync <MongoDbRepositoryItem>(filter).Result;
var data = result.ToList();
}
catch (Exception)
{
throw;
}
Console.ReadLine();
// problemSolved: and new in mongo query
}
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));
}
public static FilterDefinition <TDocument> NotDeactivated <TDocument, TItem>(FilterDefinitionBuilder <TDocument> builder, Expression <Func <TDocument, IEnumerable <TItem> > > acessor, DateTime?dateTime = null) where TItem : IActivationAware
{
var twoBuilder = new FilterDefinitionBuilder <TItem>();
if (!dateTime.HasValue)
{
dateTime = DateTime.UtcNow;
}
return(builder.Or
(
builder.Not
(
builder.ElemMatch
(
acessor,
twoBuilder.Exists
(
t => t.DeactivationDate
)
)
),
builder.ElemMatch
(
acessor,
twoBuilder.Gt
(
t => t.DeactivationDate,
dateTime.Value
)
)
));
}
public static int GetNumberOfWorkers(IMongoCollection <BsonDocument> collection)
{
var filter = Query.Exists("worker");
var workers = collection.Distinct <int>("worker", filter).ToList();
workers.Sort();
return(workers.Last());
}
public static FilterDefinition <MongoAssetEntity> BuildFilter(this ClrQuery query, DomainId appId, DomainId?parentId)
{
var filters = new List <FilterDefinition <MongoAssetEntity> >
{
Filter.Exists(x => x.LastModified),
Filter.Exists(x => x.Id),
Filter.Eq(x => x.IndexedAppId, appId)
};
if (!query.HasFilterField("IsDeleted"))
{
filters.Add(Filter.Eq(x => x.IsDeleted, false));
}
if (parentId != null)
{
if (parentId == DomainId.Empty)
{
filters.Add(
Filter.Or(
Filter.Exists(x => x.ParentId, false),
Filter.Eq(x => x.ParentId, DomainId.Empty)));
}
else
{
filters.Add(Filter.Eq(x => x.ParentId, parentId.Value));
}
}
var(filter, last) = query.BuildFilter <MongoAssetEntity>(false);
if (filter != null)
{
if (last)
{
filters.Add(filter);
}
else
{
filters.Insert(0, filter);
}
}
return(Filter.And(filters));
}
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 <TDocument> NotDeactivated <TDocument>(FilterDefinitionBuilder <TDocument> builder, DateTime?dateTime = null) where TDocument : IActivationAware
{
if (!dateTime.HasValue)
{
dateTime = DateTime.UtcNow;
}
return(builder.Or(
builder.Not(
builder.Exists(doc => doc.DeactivationDate)
),
builder.Gt(doc => doc.DeactivationDate, dateTime.Value)
));
}
public static FilterDefinition <MongoAssetEntity> BuildFilter(this ClrQuery query, Guid appId, Guid?parentId)
{
var filters = new List <FilterDefinition <MongoAssetEntity> >
{
Filter.Eq(x => x.IndexedAppId, appId),
Filter.Eq(x => x.IsDeleted, false)
};
if (parentId.HasValue)
{
if (parentId == Guid.Empty)
{
filters.Add(
Filter.Or(
Filter.Exists(x => x.ParentId, false),
Filter.Eq(x => x.ParentId, Guid.Empty)));
}
else
{
filters.Add(Filter.Eq(x => x.ParentId, parentId.Value));
}
}
var(filter, last) = query.BuildFilter <MongoAssetEntity>(false);
if (filter != null)
{
if (last)
{
filters.Add(filter);
}
else
{
filters.Insert(0, filter);
}
}
if (filters.Count > 1)
{
return(Filter.And(filters));
}
else if (filters.Count == 1)
{
return(filters[0]);
}
else
{
return(new BsonDocument());
}
}
public static FilterDefinition <TDocument> NotDeactivated <TDocument, TItem>(FilterDefinitionBuilder <TDocument> builder, Expression <Func <TDocument, TItem> > acessor, DateTime?dateTime = null) where TItem : IActivationAware
{
if (!dateTime.HasValue)
{
dateTime = DateTime.UtcNow;
}
return(builder.Or
(
builder.Not
(
builder.Exists
(
Expression.Lambda <Func <TDocument, object> >
(
Expression.Convert
(
Expression.Property
(
acessor.Body,
nameof(IActivationAware.DeactivationDate)
),
typeof(object)
),
acessor.Parameters
)
)
),
builder.Gt
(
Expression.Lambda <Func <TDocument, DateTime> >
(
Expression.Convert
(
Expression.Property
(
acessor.Body,
nameof(IActivationAware.DeactivationDate)
),
typeof(DateTime)
),
acessor.Parameters
),
dateTime.Value
)
));
}
public override FilterDefinition <T> Visit(FilterComparison nodeIn)
{
var propertyName = string.Join(".", nodeIn.Lhs);
switch (nodeIn.Operator)
{
case FilterOperator.Empty:
return(Filter.Or(Filter.Exists(propertyName, false), Filter.Eq(propertyName, default(T)), Filter.Eq(propertyName, string.Empty), Filter.Eq(propertyName, new T[0])));
case FilterOperator.StartsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s)));
case FilterOperator.Contains:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s)));
case FilterOperator.EndsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$")));
case FilterOperator.Equals:
return(Filter.Eq(propertyName, nodeIn.Rhs.Value));
case FilterOperator.GreaterThan:
return(Filter.Gt(propertyName, nodeIn.Rhs.Value));
case FilterOperator.GreaterThanOrEqual:
return(Filter.Gte(propertyName, nodeIn.Rhs.Value));
case FilterOperator.LessThan:
return(Filter.Lt(propertyName, nodeIn.Rhs.Value));
case FilterOperator.LessThanOrEqual:
return(Filter.Lte(propertyName, nodeIn.Rhs.Value));
case FilterOperator.NotEquals:
return(Filter.Ne(propertyName, nodeIn.Rhs.Value));
case FilterOperator.In:
return(Filter.In(propertyName, ((IList)nodeIn.Rhs.Value).OfType <object>()));
}
throw new NotSupportedException();
}
//test
public List <InfoBO> FindTargetByTag(Dictionary <string, List <string> > tagGroups)
{
if (tagGroups.Count() == 0)
{
return(GetInfos());
}
IMongoCollection <InfoBO> collection = _client.
GetDatabase(Configuration["MongoSetting:InfoSetting:Database"])
.GetCollection <InfoBO>(Configuration["MongoSetting:InfoSetting:Collection"]);
List <InfoBO> ret = new List <InfoBO>();
FilterDefinitionBuilder <InfoBO> builder = new FilterDefinitionBuilder <InfoBO>();
List <FilterDefinition <InfoBO> > filters = new List <FilterDefinition <InfoBO> >();
foreach (var it in tagGroups)
{
string tagGroupName = it.Key;
List <string> tagsInGroup = it.Value;
Builders <InfoBO> .Filter.Exists(x => x.tags, true);
var filter1 = builder.Exists(x => x.tags[tagGroupName], false);
var filter2 = builder.AnyIn(r => r.tags[tagGroupName], it.Value);
var filter = filter1 | filter2;
filters.Add(filter);
}
MongoDB.Driver.FilterDefinition <InfoBO> finalFiter = filters.Count == 1 ? filters[0] : builder.And(filters);
ret = collection.Find(finalFiter).ToList();
return(ret);
}
public static FilterDefinition <TEntity> Deleted <TEntity>(this FilterDefinitionBuilder <TEntity> filter)
where TEntity : SoftDeletableMongoEntity
=> filter.Exists(x => x.DateDeleted);
public object Exists(string property, bool exists = true)
{
return(InternalBuilder.Exists(property, exists));
}
//
// 摘要:
// Tests that an element of that name does or does not exist (see $exists).
//
// 参数:
// name:
// The name of the element to test.
//
// exists:
// Whether to test for the existence or absence of an element.
//
// 返回结果:
// The builder (so method calls can be chained).
public static FilterDefinition <BsonDocument> Exists(string name, bool exists)
{
return(filter.Exists(name, exists));
}
public override FilterDefinition <MongoContentEntity> Visit(BinaryOperatorNode nodeIn)
{
if (nodeIn.OperatorKind == BinaryOperatorKind.And)
{
return(Filter.And(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.Or)
{
return(Filter.Or(nodeIn.Left.Accept(this), nodeIn.Right.Accept(this)));
}
if (nodeIn.Left is SingleValueFunctionCallNode functionNode)
{
var regexFilter = Visit(functionNode);
var value = BuildValue(nodeIn.Right);
if (value is bool booleanRight)
{
if ((nodeIn.OperatorKind == BinaryOperatorKind.Equal && !booleanRight) ||
(nodeIn.OperatorKind == BinaryOperatorKind.NotEqual && booleanRight))
{
regexFilter = Filter.Not(regexFilter);
}
return(regexFilter);
}
}
else
{
if (nodeIn.OperatorKind == BinaryOperatorKind.NotEqual)
{
var field = BuildFieldDefinition(nodeIn.Left);
return(Filter.Or(
Filter.Not(Filter.Exists(field)),
Filter.Ne(field, BuildValue(nodeIn.Right))));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.Equal)
{
return(Filter.Eq(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.LessThan)
{
return(Filter.Lt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.LessThanOrEqual)
{
return(Filter.Lte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThan)
{
return(Filter.Gt(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
if (nodeIn.OperatorKind == BinaryOperatorKind.GreaterThanOrEqual)
{
return(Filter.Gte(BuildFieldDefinition(nodeIn.Left), BuildValue(nodeIn.Right)));
}
}
throw new NotSupportedException();
}
public static IEnumerable <int> GetDistinctWorkerIndexes(IMongoCollection <BsonDocument> collection)
{
var filter = Query.Exists("worker");
return(collection.Distinct <int>("worker", filter).ToList());
}
public IReadOnlyCollection <XElement> GetAllElements()
{
var keyElements = Collection.Find(Filters.Exists(x => x.Xml)).ToList();
return(keyElements.Select(ConvertToXml).ToList().AsReadOnly());
}
public static ISet <string> GetDistinctWorkers(IMongoCollection <BsonDocument> collection)
{
var filter = Query.Exists("worker");
return(new HashSet <string>(collection.Distinct <string>("worker", filter).ToEnumerable()));
}
private async Task <IEnumerable <T> > FetchEntities <T>
(
string metaPhrase,
ProjectionDefinition <T> projection,
IMongoCollection <T> collection,
double daysTolerance,
int limit,
GeoJsonPoint <GeoJson3DGeographicCoordinates> targetPosition = null
) where T : IIdentifiable <ObjectId>, ILocatable, IMetaScored
{
var referenceDate = DateTime.UtcNow;
var filterBuilder = new FilterDefinitionBuilder <T>();
var filter = filterBuilder.And
(
filterBuilder.Gt
(
post => post._id,
new ObjectId(referenceDate.Subtract(TimeSpan.FromDays(daysTolerance)), 0, 0, 0)
),
filterBuilder.Or
(
filterBuilder.Text(metaPhrase, new TextSearchOptions
{
CaseSensitive = false,
DiacriticSensitive = false,
})
,
filterBuilder.Exists(p => p._id)
)
);
var sortBuilder = new SortDefinitionBuilder <T>();
var sort = sortBuilder.Combine
(
sortBuilder.MetaTextScore("metaScore"),
sortBuilder.Descending(p => p._id)
);
var cursor = await collection.FindAsync(filter, new FindOptions <T>
{
AllowPartialResults = true,
Limit = limit,
Sort = sort,
Projection = projection
});
var enumerable = cursor.ToEnumerable();
if (targetPosition != null)
{
enumerable = enumerable.OrderBy
(
item =>
item.Position.Coordinates.ToGeoCoordinate().GetDistanceTo(targetPosition.Coordinates.ToGeoCoordinate())
-
Math.Pow(item.MetaScore, 2)
);
}
return(enumerable);
}
public static IEnumerable <string> GetDistinctWorkers(IMongoCollection <NetstatDocument> collection)
{
var filter = Query.Exists("worker");
return(collection.Distinct <string>("worker", filter).ToList());
}
