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