public void BeforeGetList(IWebEasRepositoryBase repository, HierarchyNode node, ref string sql, ref Filter filter, ref string sqlFromAlias, string sqlOrderPart)
{
if (!repository.GetNastavenieB("cfe", "PohladavkyDAP"))
{
filter.And(new FilterElement()
{
Key = nameof(Tree.C_Modul_Id), Operator = FilterOperator.Ne.Value, Value = (int)ModulEnum.DAP
});
filter.And(new FilterElement()
{
Key = nameof(Tree.Kod), Operator = FilterOperator.NotLike.Value, Value = "%dap%"
});
}
;
}
public async Task <IResultList <IAssetEntity> > QueryAsync(Guid appId, HashSet <string> mimeTypes = null, HashSet <Guid> ids = null, string query = null, int take = 10, int skip = 0)
{
var filters = new List <FilterDefinition <MongoAssetEntity> >
{
Filter.Eq(x => x.State.AppId, appId),
Filter.Eq(x => x.State.IsDeleted, false)
};
if (ids != null && ids.Count > 0)
{
filters.Add(Filter.In(x => x.Id, ids));
}
if (mimeTypes != null && mimeTypes.Count > 0)
{
filters.Add(Filter.In(x => x.State.MimeType, mimeTypes));
}
if (!string.IsNullOrWhiteSpace(query))
{
filters.Add(Filter.Regex(x => x.State.FileName, new BsonRegularExpression(query, "i")));
}
var filter = Filter.And(filters);
var find = Collection.Find(filter);
var assetItems = find.Skip(skip).Limit(take).SortByDescending(x => x.State.LastModified).ToListAsync();
var assetCount = find.CountAsync();
await Task.WhenAll(assetItems, assetCount);
return(ResultList.Create <IAssetEntity>(assetItems.Result.Select(x => x.State), assetCount.Result));
}
public void CompositeFilterQuery()
{
string projectId = _fixture.ProjectId;
PartitionId partitionId = _fixture.PartitionId;
// Sample: CompositeFilter
Query query = new Query("Task")
{
Filter = Filter.And(
Filter.Equal("done", false),
Filter.GreaterThanOrEqual("priority", 4)
),
Order = { { "priority", Direction.Descending } }
};
DatastoreClient client = DatastoreClient.Create();
RunQueryRequest request = new RunQueryRequest
{
ProjectId = projectId,
PartitionId = partitionId,
ReadOptions = new ReadOptions {
ReadConsistency = ReadConsistency.Eventual
},
Query = query
};
RunQueryResponse response = client.RunQuery(request);
foreach (EntityResult result in response.Batch.EntityResults)
{
Entity entity = result.Entity;
Console.WriteLine((string)entity["description"]);
}
// TODO: Results beyond this batch?
// End sample
}
private static FilterDefinition <MongoAssetEntity> CreateFilter(Guid appId, ICollection <string> mimeTypes, ICollection <Guid> ids, string query)
{
var filters = new List <FilterDefinition <MongoAssetEntity> >
{
Filter.Eq(x => x.AppId, appId)
};
if (ids != null && ids.Count > 0)
{
filters.Add(Filter.In(x => x.Id, ids));
}
if (mimeTypes != null && mimeTypes.Count > 0)
{
filters.Add(Filter.In(x => x.MimeType, mimeTypes));
}
if (!string.IsNullOrWhiteSpace(query))
{
filters.Add(Filter.Regex(x => x.FileName, new BsonRegularExpression(query, "i")));
}
var filter = Filter.And(filters);
return(filter);
}
public async Task <IReadOnlyList <StoredEvent> > QueryAsync(string streamName, long streamPosition = 0)
{
var commits =
await Collection.Find(
Filter.And(
Filter.Eq(EventStreamField, streamName),
Filter.Gte(EventStreamOffsetField, streamPosition - 1)))
.Sort(Sort.Ascending(TimestampField)).ToListAsync();
var result = new List <StoredEvent>();
foreach (var commit in commits)
{
var eventStreamOffset = (int)commit.EventStreamOffset;
var commitTimestamp = commit.Timestamp;
var commitOffset = 0;
foreach (var e in commit.Events)
{
eventStreamOffset++;
if (eventStreamOffset >= streamPosition)
{
var eventData = e.ToEventData();
var eventToken = new StreamPosition(commitTimestamp, commitOffset, commit.Events.Length);
result.Add(new StoredEvent(eventToken, eventStreamOffset, eventData));
}
}
}
return(result);
}
private static FilterDefinition <MongoAssetFolderEntity> BuildFilter(DomainId appId, DomainId?parentId)
{
var filters = new List <FilterDefinition <MongoAssetFolderEntity> >
{
Filter.Eq(x => x.IndexedAppId, appId),
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));
}
}
return(Filter.And(filters));
}
public async Task <IResultList <Event> > QueryAsync(string appId, EventQuery query, CancellationToken ct)
{
var filters = new List <FilterDefinition <MongoDbEvent> >
{
Filter.Eq(x => x.Doc.AppId, appId)
};
if (!string.IsNullOrWhiteSpace(query.Query))
{
var regex = new BsonRegularExpression(query.Query, "i");
filters.Add(
Filter.Or(
Filter.Regex(x => x.Doc.Topic, regex),
Filter.Regex(x => x.SearchText, regex)));
}
var filter = Filter.And(filters);
var resultItems = await Collection.Find(filter).SortByDescending(x => x.Doc.Created).ToListAsync(query, ct);
var resultTotal = (long)resultItems.Count;
if (query.ShouldQueryTotal(resultItems))
{
resultTotal = await Collection.Find(filter).CountDocumentsAsync(ct);
}
return(ResultList.Create(resultTotal, resultItems.Select(x => x.ToEvent())));
}
public async Task <IResultList <Topic> > QueryAsync(string appId, TopicQuery query, CancellationToken ct)
{
var filters = new List <FilterDefinition <MongoDbTopic> >
{
Filter.Eq(x => x.Doc.AppId, appId)
};
if (!string.IsNullOrWhiteSpace(query.Query))
{
var regex = new BsonRegularExpression(query.Query, "i");
filters.Add(Filter.Regex(x => x.Doc.Path, regex));
}
var filter = Filter.And(filters);
var taskForItems = Collection.Find(filter).SortByDescending(x => x.Doc.LastUpdate).ToListAsync(query, ct);
var taskForCount = Collection.Find(filter).CountDocumentsAsync(ct);
await Task.WhenAll(
taskForItems,
taskForCount);
return(ResultList.Create(taskForCount.Result, taskForItems.Result.Select(x => x.Doc)));
}
private static FilterDefinition <MongoDbSubscription> BuildFilter(string appId, SubscriptionQuery query)
{
var filters = new List <FilterDefinition <MongoDbSubscription> >
{
Filter.Eq(x => x.AppId, appId)
};
if (!string.IsNullOrWhiteSpace(query.UserId))
{
filters.Add(Filter.Eq(x => x.UserId, query.UserId));
}
if (query.Topics != null)
{
filters.Add(Filter.In(x => x.TopicPrefix, query.Topics));
}
else if (!string.IsNullOrWhiteSpace(query.Query))
{
var regex = new BsonRegularExpression(Regex.Escape(query.Query), "i");
filters.Add(Filter.Regex(x => x.TopicPrefix, regex));
}
return(Filter.And(filters));
}
private static FilterDefinition <MongoContentEntity> CreateFilter(DomainId appId, IEnumerable <DomainId>?schemaIds, HashSet <DomainId> ids)
{
var filters = new List <FilterDefinition <MongoContentEntity> >();
var documentIds = ids.Select(x => DomainId.Combine(appId, x)).ToList();
if (documentIds.Count > 1)
{
filters.Add(
Filter.Or(
Filter.In(x => x.DocumentId, documentIds)));
}
else
{
var first = documentIds.First();
filters.Add(
Filter.Or(
Filter.Eq(x => x.DocumentId, first)));
}
if (schemaIds != null)
{
filters.Add(Filter.In(x => x.IndexedSchemaId, schemaIds));
}
filters.Add(Filter.Ne(x => x.IsDeleted, true));
return(Filter.And(filters));
}
public async Task <IReadOnlyDictionary <string, IReadOnlyList <StoredEvent> > > QueryManyAsync(IEnumerable <string> streamNames,
CancellationToken ct = default)
{
Guard.NotNull(streamNames);
using (Telemetry.Activities.StartActivity("MongoEventStore/QueryManyAsync"))
{
var position = EtagVersion.Empty;
var filter =
Filter.And(
Filter.In(EventStreamField, streamNames),
Filter.Gte(EventStreamOffsetField, position));
var commits =
await Collection.Find(filter).Sort(Sort.Ascending(TimestampField))
.ToListAsync(ct);
var result = commits.GroupBy(x => x.EventStream)
.ToDictionary(
x => x.Key,
x => (IReadOnlyList <StoredEvent>)x.SelectMany(y => y.Filtered(position)).ToList());
return(result);
}
}
private static FilterDefinition <MongoContentEntity> CreateFilter(Guid appId, ICollection <Guid> ids)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Eq(x => x.IndexedAppId, appId),
Filter.Ne(x => x.IsDeleted, true)
};
if (ids != null && ids.Count > 0)
{
if (ids.Count > 1)
{
filters.Add(
Filter.Or(
Filter.In(x => x.Id, ids)));
}
else
{
var first = ids.First();
filters.Add(
Filter.Or(
Filter.Eq(x => x.Id, first)));
}
}
return(Filter.And(filters));
}
public async Task TrackSeenAsync(IEnumerable <Guid> ids, HandledInfo handle)
{
var writes = new List <WriteModel <UserNotification> >();
foreach (var id in ids)
{
writes.Add(new UpdateOneModel <UserNotification>(
Filter.And(
Filter.Eq(x => x.Id, id),
Filter.Exists(x => x.IsSeen, false)),
Update
.Set(x => x.IsSeen, handle)
.Set(x => x.Updated, handle.Timestamp)));
writes.Add(new UpdateOneModel <UserNotification>(
Filter.And(
Filter.Eq(x => x.Id, id),
Filter.Eq(x => x.Formatting.ConfirmMode, ConfirmMode.Seen),
Filter.Exists(x => x.IsConfirmed, false)),
Update
.Set(x => x.IsConfirmed, handle)
.Set(x => x.Updated, handle.Timestamp)));
}
if (writes.Count == 0)
{
return;
}
await Collection.BulkWriteAsync(writes);
}
public async Task <IResultList <Subscription> > QueryAsync(string appId, SubscriptionQuery query, CancellationToken ct = default)
{
var filters = new List <FilterDefinition <MongoDbSubscription> >
{
Filter.Eq(x => x.AppId, appId)
};
if (!string.IsNullOrWhiteSpace(query.UserId))
{
filters.Add(Filter.Eq(x => x.UserId, query.UserId));
}
if (!string.IsNullOrWhiteSpace(query.Query))
{
var regex = new BsonRegularExpression(query.Query, "i");
filters.Add(Filter.Regex(x => x.TopicPrefix, regex));
}
var filter = Filter.And(filters);
var taskForItems = Collection.Find(filter).ToListAsync(query, ct);
var taskForCount = Collection.Find(filter).CountDocumentsAsync(ct);
await Task.WhenAll(
taskForItems,
taskForCount);
return(ResultList.Create(taskForCount.Result, taskForItems.Result.Select(x => x.ToSubscription())));
}
public async Task <IResultList <Subscription> > QueryAsync(string appId, SubscriptionQuery query, CancellationToken ct)
{
var filters = new List <FilterDefinition <MongoDbSubscription> >
{
Filter.Eq(x => x.AppId, appId)
};
if (!string.IsNullOrWhiteSpace(query.UserId))
{
filters.Add(Filter.Eq(x => x.UserId, query.UserId));
}
if (!string.IsNullOrWhiteSpace(query.Query))
{
var regex = new BsonRegularExpression(query.Query, "i");
filters.Add(Filter.Regex(x => x.TopicPrefix, regex));
}
var filter = Filter.And(filters);
var resultItems = await Collection.Find(filter).ToListAsync(query, ct);
var resultTotal = (long)resultItems.Count;
if (query.ShouldQueryTotal(resultItems))
{
resultTotal = await Collection.Find(filter).CountDocumentsAsync(ct);
}
return(ResultList.Create(resultTotal, resultItems.Select(x => x.ToSubscription())));
}
public void TestNamespaceRunQuery()
{
UpsertTaskList();
Eventually(() =>
{
// [START datastore_namespace_run_query]
KeyFactory keyFactory = _db.CreateKeyFactory("__namespace__");
// List all the namespaces between a lower and upper bound.
string lowerBound = _db.NamespaceId.Substring(0,
_db.NamespaceId.Length - 1);
string upperBound = _db.NamespaceId + "z";
Key startNamespace = keyFactory.CreateKey(lowerBound);
Key endNamespace = keyFactory.CreateKey(upperBound);
Query query = new Query("__namespace__")
{
Filter = Filter.And(
Filter.GreaterThan("__key__", startNamespace),
Filter.LessThan("__key__", endNamespace))
};
var namespaces = new List <string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
namespaces.Add(entity.Key.Path[0].Name);
}
;
// [END datastore_namespace_run_query]
Assert.Contains(_db.NamespaceId, namespaces.ToArray());
});
}
private static FilterDefinition <MongoContentEntity> CreateFilter(DomainId appId, IEnumerable <DomainId> schemaIds, ClrQuery?query,
DomainId referenced, RefToken?createdBy)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Eq(x => x.IndexedAppId, appId),
Filter.In(x => x.IndexedSchemaId, schemaIds),
};
if (query?.HasFilterField("dl") != true)
{
filters.Add(Filter.Ne(x => x.IsDeleted, true));
}
if (query?.Filter != null)
{
filters.Add(query.Filter.BuildFilter <MongoContentEntity>());
}
if (referenced != default)
{
filters.Add(Filter.AnyEq(x => x.ReferencedIds, referenced));
}
if (createdBy != null)
{
filters.Add(Filter.Eq(x => x.CreatedBy, createdBy));
}
return(Filter.And(filters));
}
private static FilterDefinition <MongoDbSubscription> CreatePrefixFilter(string appId, string?userId, TopicId topic, bool withUser)
{
var filters = new List <FilterDefinition <MongoDbSubscription> >();
if (withUser)
{
filters.Add(Filter.Eq(x => x.UserId, userId));
}
else
{
filters.Add(Filter.Ne(x => x.UserId, userId));
}
filters.Add(Filter.Eq(x => x.AppId, appId));
var index = 0;
foreach (var part in topic.GetParts())
{
var fieldName = $"ta.{index}";
filters.Add(
Filter.Or(
Filter.Eq(fieldName, part),
Filter.Exists(fieldName, false)));
index++;
}
return(Filter.And(filters));
}
public void TestNamespaceRunQuery()
{
UpsertTaskList();
Eventually(() =>
{
// [START namespace_run_query]
KeyFactory keyFactory = _db.CreateKeyFactory("__namespace__");
Key startNamespace = keyFactory.CreateKey("g");
Key endNamespace = keyFactory.CreateKey("h");
Query query = new Query("__namespace__")
{
Filter = Filter.And(
Filter.GreaterThan("__key__", startNamespace),
Filter.LessThan("__key__", endNamespace))
};
var namespaces = new List <string>();
foreach (Entity entity in _db.RunQuery(query).Entities)
{
namespaces.Add(entity.Key.Path[0].Name);
}
;
// [END namespace_run_query]
Assert.Equal(new[] { "ghijklmnop" }, namespaces.ToArray());
});
}
// [START list]
public PlaceList List(int pageSize, string nextPageToken, string userId = null, GeoCoordinate coordinates = null)
{
var query = new Query("Place")
{
Limit = pageSize
};
if (userId != null)
{
query.Filter = Filter.Equal("CreatedById", userId);
}
if (coordinates != null)
{
query.Filter = Filter.And(
Filter.GreaterThan("Latitude", coordinates.MaxLatitude(100)),
Filter.GreaterThan("Latitude", coordinates.MinLatitude(100)),
Filter.GreaterThan("Longitude", coordinates.MaxLongitude(100)),
Filter.GreaterThan("Longitude", coordinates.MinLongitude(100))
);
}
if (!string.IsNullOrWhiteSpace(nextPageToken))
{
query.StartCursor = ByteString.FromBase64(nextPageToken);
}
var results = _db.RunQuery(query);
return(new PlaceList()
{
Places = results.Entities.Select(entity => entity.ToPlace()),
NextPageToken = results.Entities.Count == query.Limit ?
results.EndCursor.ToBase64() : null
});
}
private static FilterDefinition <MongoContentEntity> CreateFilter(DomainId appId, IEnumerable <DomainId> schemaIds, ICollection <DomainId>?ids, ClrQuery?query, DomainId referenced)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Eq(x => x.IndexedAppId, appId),
Filter.In(x => x.IndexedSchemaId, schemaIds),
Filter.Ne(x => x.IsDeleted, true)
};
if (ids != null && ids.Count > 0)
{
var documentIds = ids.Select(x => DomainId.Combine(appId, x)).ToList();
filters.Add(
Filter.Or(
Filter.AnyIn(x => x.ReferencedIds, documentIds),
Filter.In(x => x.DocumentId, documentIds)));
}
if (query?.Filter != null)
{
filters.Add(query.Filter.BuildFilter <MongoContentEntity>());
}
if (referenced != default)
{
filters.Add(Filter.AnyEq(x => x.ReferencedIds, referenced));
}
return(Filter.And(filters));
}
public async Task <PagedListResult <CalendarEvent> > GetAll(
string teamId, int pageSize = 50, int pageNumber = 1, string orderBy = "", string search = "")
{
var totalCount = await this.Count(teamId);
var totalPages = (long)Math.Ceiling((double)totalCount / pageSize);
var filter = Filter.Eq(u => u.TeamId, teamId);
if (!string.IsNullOrWhiteSpace(search))
{
filter = Filter.And(filter,
Filter.Regex(u => u.Description, new BsonRegularExpression($@"/{search}/i")));
}
var sort = Sort.Descending(x => x.CreatedAt);
if (!string.IsNullOrWhiteSpace(orderBy))
{
sort = Sort.Ascending(orderBy);
}
return(new PagedListResult <CalendarEvent> {
TotalCount = totalCount,
TotalPages = totalPages,
Result = await Collection
.Find(filter)
.Skip((pageNumber - 1) * pageSize)
.Limit(pageSize)
.Sort(sort)
.ToListAsync()
});
}
private static FilterDefinition <MongoEventCommit> CreateFilter(string streamFilter, StreamPosition streamPosition)
{
var filters = new List <FilterDefinition <MongoEventCommit> >();
if (streamPosition.IsEndOfCommit)
{
filters.Add(Filter.Gt(TimestampField, streamPosition.Timestamp));
}
else
{
filters.Add(Filter.Gte(TimestampField, streamPosition.Timestamp));
}
if (!string.IsNullOrWhiteSpace(streamFilter) && !string.Equals(streamFilter, ".*", StringComparison.OrdinalIgnoreCase))
{
if (streamFilter.Contains("^"))
{
filters.Add(Filter.Regex(EventStreamField, streamFilter));
}
else
{
filters.Add(Filter.Eq(EventStreamField, streamFilter));
}
}
return(Filter.And(filters));
}
protected override async Task DeleteAsync(string persistenceId, SnapshotSelectionCriteria criteria)
{
var filter = Filter.And(
Filter.HasAncestor(RootKey(persistenceId)),
Filter.GreaterThanOrEqual(SnapshotFields.SequenceNr, criteria.MinSequenceNr),
Filter.LessThanOrEqual(SnapshotFields.SequenceNr, criteria.MaxSequenceNr)
//,Filter.LessThanOrEqual(SnapshotFields.Timestamp, criteria.MaxTimeStamp.Ticks)
);
// if (criteria.MinTimestamp.HasValue)
// {
// filter = Filter.And(filter,
// Filter.GreaterThanOrEqual(SnapshotFields.Timestamp, criteria.MinTimestamp.Value.Ticks)
// );
// }
Query query = new Query(_snapshotKind)
{
Filter = filter,
Order = { { JournalFields.SequenceNr, PropertyOrder.Types.Direction.Ascending } }
//,Limit = (int) max
};
var results = await _db.RunQueryAsync(query).ConfigureAwait(false);
var timestampFiltered =
results.Entities?.Where(
e => e[SnapshotFields.SequenceNr].IntegerValue <= criteria.MaxSequenceNr &&
e[SnapshotFields.SequenceNr].IntegerValue >= criteria.MinSequenceNr &&
e[SnapshotFields.Timestamp].IntegerValue <= criteria.MaxTimeStamp.Ticks &&
e[SnapshotFields.Timestamp].IntegerValue >= criteria.MinTimestamp?.Ticks
);
await _db.DeleteAsync(timestampFiltered);
await CheckDeleteRootsnapshot(persistenceId, criteria.MaxSequenceNr, criteria.MaxTimeStamp.Ticks);
}
private async Task <(IEnumerable <Entity> Entities, string NextPageToken)> QueryGameState(ICriteria searchCriteria)
{
// Create our query
var query = new Query(_tableName)
{
Limit = searchCriteria.PageSize,
Filter = Filter.And(Filter.Equal("PlayerId", searchCriteria.SearchFields["PlayerId"]),
Filter.GreaterThanOrEqual("CurrentLevel", Convert.ToInt32(searchCriteria.SearchFields["CurrentLevel"]))),
Projection = { "RecordId", "CurrentLevel", "Health", "Inventory", "GameId", "RecordCreatedAt" },
Order = { { "CurrentLevel", PropertyOrder.Types.Direction.Descending },
{ "RecordCreatedAt", PropertyOrder.Types.Direction.Descending } }
};
// Use NextPageState if specified
if (!string.IsNullOrWhiteSpace(searchCriteria.NextPageState))
{
query.StartCursor = ByteString.FromBase64(searchCriteria.NextPageState);
}
// Run the query
var results = await _db.RunQueryAsync(query);
// Check for next page token
var nextPageToken = results.Entities.Count == searchCriteria.PageSize ? results.EndCursor.ToBase64() : null;
// Return the tuple
return(results.Entities, nextPageToken);
}
private async Task <SelectedSnapshot> GetSnapShotByCriteria(string persistenceId, SnapshotSelectionCriteria criteria)
{
var filter = Filter.And(
Filter.HasAncestor(RootKey(persistenceId)),
Filter.GreaterThanOrEqual(SnapshotFields.SequenceNr, criteria.MinSequenceNr),
Filter.LessThanOrEqual(SnapshotFields.SequenceNr, criteria.MaxSequenceNr)//,
//Filter.LessThanOrEqual(SnapshotFields.Timestamp, criteria.MaxTimeStamp.Ticks)
);
// if (criteria.MinTimestamp.HasValue)
// {
// filter = Filter.And(filter,
// Filter.GreaterThanOrEqual(SnapshotFields.Timestamp, criteria.MinTimestamp.Value.Ticks)
// );
// }
Query query = new Query(_snapshotKind)
{
Filter = filter,
Order = { { JournalFields.SequenceNr, PropertyOrder.Types.Direction.Descending } },
//,Limit = (int) max
};
var results = await _db.RunQueryAsync(query).ConfigureAwait(false);
if (!results.Entities.Any())
{
return(null);
}
var result = results.Entities.FirstOrDefault(
e => e[SnapshotFields.Timestamp].IntegerValue <= criteria.MaxTimeStamp.Ticks &&
e[SnapshotFields.Timestamp].IntegerValue >= criteria.MinTimestamp?.Ticks);
return(result != null?EntityToSnapshot(persistenceId, result) : null);
}
private static FilterDefinition <MongoContentEntity> CreateFilter(Guid schemaId, ICollection <Guid>?ids, Status[]?status, ClrQuery?query)
{
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));
}
if (ids != null && ids.Count > 0)
{
filters.Add(Filter.In(x => x.Id, ids));
}
if (query?.Filter != null)
{
filters.Add(query.Filter.BuildFilter <MongoContentEntity>());
}
return(Filter.And(filters));
}
private static FilterDefinition <MongoContentEntity> CreateFilter(DomainId appId, ICollection <DomainId> ids)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Ne(x => x.IsDeleted, true)
};
if (ids != null && ids.Count > 0)
{
var documentIds = ids.Select(x => DomainId.Combine(appId, x)).ToList();
if (ids.Count > 1)
{
filters.Add(
Filter.Or(
Filter.In(x => x.DocumentId, documentIds)));
}
else
{
var first = documentIds.First();
filters.Add(
Filter.Or(
Filter.Eq(x => x.DocumentId, first)));
}
}
return(Filter.And(filters));
}
public async Task <IResultList <User> > QueryAsync(string appId, UserQuery query, CancellationToken ct)
{
var filters = new List <FilterDefinition <MongoDbUser> >
{
Filter.Eq(x => x.Doc.AppId, appId)
};
if (!string.IsNullOrWhiteSpace(query.Query))
{
var regex = new BsonRegularExpression(query.Query, "i");
filters.Add(
Filter.Or(
Filter.Regex(x => x.Doc.Id, regex),
Filter.Regex(x => x.Doc.FullName, regex),
Filter.Regex(x => x.Doc.EmailAddress, regex)));
}
var filter = Filter.And(filters);
var taskForItems = Collection.Find(filter).ToListAsync(query, ct);
var taskForCount = Collection.Find(filter).CountDocumentsAsync(ct);
await Task.WhenAll(
taskForItems,
taskForCount);
return(ResultList.Create(taskForCount.Result, taskForItems.Result.Select(x => x.ToUser())));
}
public async Task <bool> UpsertRow(string deploymentId, MembershipEntry entry, string etag, TableVersion tableVersion)
{
try
{
var subDocument = MembershipBase.Create <DeploymentMembership>(entry);
var memberKey = $"Members.{BuildKey(entry.SiloAddress)}";
var etagCheck =
etag == null?
Filter.Not(Filter.Exists(memberKey)) :
Filter.Eq($"{memberKey}.Etag", etag);
var result = await Collection.UpdateOneAsync(
Filter.And(
Filter.Eq(x => x.DeploymentId, deploymentId),
Filter.Eq(x => x.VersionEtag, tableVersion.VersionEtag),
etagCheck),
Update
.Set(memberKey, subDocument)
.Set(x => x.Version, tableVersion.Version)
.Set(x => x.VersionEtag, EtagHelper.CreateNew()),
Upsert);
return(true);
}
catch (MongoException ex)
{
if (ex.IsDuplicateKey())
{
return(false);
}
throw;
}
}
