public async Task OneStepUpdate(int amount = 1000) { var filterDefinitionBuilder = new FilterDefinitionBuilder<Student>(); var updateDefinitionBuilder = new UpdateDefinitionBuilder<Student>(); for (var i = 0; i < amount; i++) { await studentsCollection.UpdateOneAsync( filterDefinitionBuilder.Eq<string>((Student x) => x.Id, $"Students/{i}"), updateDefinitionBuilder.Inc<int>((Student x) => x.Age, 1)); } }
public async Task SaveSmallFire(string fileId, byte[] data) { var update = new UpdateDefinitionBuilder<FireRecord>().Set(fr => fr.SmallFileData, data).Set(fr => fr.State, (int)FireRecordState.Saved); var collection = Client.GetDatabase(FireDBName).GetCollection<FireRecord>("FireRecord"); var fOid = new ObjectId(fileId); await collection.UpdateOneAsync(f => f.Id == fOid, update); }
public async void UpdateBatch(int amount = 1000) { var studentsCollection = database.GetCollection<Student>("Students"); var filterDefinitionBuilder = new MongoDB.Driver.FilterDefinitionBuilder<Student>(); var updateDefinitionBuilder = new UpdateDefinitionBuilder<Student>(); var updateDefinition = updateDefinitionBuilder.Inc(x => x.Age, 1); await studentsCollection.UpdateManyAsync(new FilterDefinitionBuilder<Student>().Exists((Student x) => x.Id, true), updateDefinition); for (var i = 0; i < amount; i++) { var filterDefinitino = filterDefinitionBuilder.Eq<string>((Student x) => x.Id, $"Students/{i}"); var students = await studentsCollection.Find<Student>(filterDefinitino, new FindOptions { CursorType = CursorType.NonTailable, }).ToListAsync(); if (students.Count == 0 || students.Count != 1 || students[0].Id != $"Students/{i}") { throw new Exception("Errorous Read"); } } }
private async Task <ApiScopeModel> Enable(string id, bool isEnabled) { var updateDefinitionBuilder = new UpdateDefinitionBuilder <ApiScopeData>(); var updateDefinition = updateDefinitionBuilder.Set(scopeData => scopeData.Enabled, isEnabled); var updated = await ApiScopeDataAccess.UpdateAsync(data => data.Id, id, updateDefinition); return(updated ? await GetApiScopeById(id) : default(ApiScopeModel)); }
public UpdateDefinition <Rental> AdjustPriceUsingModif(AdjustPrice adjustPrice) { var adj = new PriceAdjusment(adjustPrice, Price); var modUpd = new UpdateDefinitionBuilder <Rental>().Push(r => r.PriceAdjusments, adj) .Set(r => r.Price, adj.NewPrice); return(modUpd); }
private LabMongo() : base() { this.FilterBuiler = Builders<MReport>.Filter; this.UpdateBuiler = Builders<MReport>.Update; this.ProjectionBuiler = Builders<MReport>.Projection; this.LisMDB = MClient.GetDatabase(MongoDBName); }
public async Task <bool> GenerateNewToken(string Token) { if (await CheackToken(Token)) { try { var NewToken = ObjectId.GenerateNewId().ToString(); var Filter = new BsonDocument { { "AccountSetting.Token", Token } }; var Update = new UpdateDefinitionBuilder <BsonDocument>().Set("AccountSetting.Token", NewToken); await Client.GetDatabase("Users").GetCollection <BsonDocument>("Users").UpdateOneAsync(Filter, Update); var SettingUser = await Client.GetDatabase("Users").GetCollection <BsonDocument>("Users").FindAsync(new BsonDocument { { "AccountSetting.Token", NewToken } }).Result.SingleAsync(); foreach (var Studios in SettingUser["Games"].AsBsonArray) { var Update1 = new UpdateDefinitionBuilder <BsonDocument>().Set("Setting.Creator", NewToken); await Client.GetDatabase(Studios.AsString).GetCollection <BsonDocument>("Setting").UpdateOneAsync(new BsonDocument { { "_id", "Setting" } }, Update1); } //send Email try { var Body = $"Hi Dear " + $"Your token was successfully changed in all studios" + "\n" + $"Previous token: {Token}" + "\n" + $"New token: {NewToken}" + "\n\n" + $"Thanks" + "\n" + $"Backendi.ir"; SendMail_Info(new System.Net.Mail.MailMessage("*****@*****.**", SettingUser["AccountSetting"]["Email"].AsString, "Token Change", Body)); } catch (Exception) { } return(true); } catch (Exception) { return(false); } } else { return(false); } }
public static UpdateDefinition <TDocument> Toggle <TDocument>(this UpdateDefinitionBuilder <TDocument> builder, FieldDefinition <TDocument, bool> field) { var serializer = BsonSerializer.LookupSerializer <TDocument>(); var renderedField = field.Render(serializer, BsonSerializer.SerializerRegistry); var pipeline = new EmptyPipelineDefinition <TDocument>() .AppendStage("{$set:{" + renderedField + ":{$eq:[false,\"" + renderedField + "\"]}}}", serializer); return(Builders <TDocument> .Update.Pipeline(pipeline)); }
public async Task Update(UserDto userDto) { var db = _connection.GetDatabase(_dbString); var collection = db.GetCollection <UserDto>(_collectionString); var update = new UpdateDefinitionBuilder <UserDto>() .Set(i => i.Name, userDto.Name) .Set(i => i.Email, userDto.Email); await collection.UpdateOneAsync(i => i.Id == userDto.Id, update); }
public User UpdateUserPurchase(int id, double purchaseAmount) { var filter = Builders <User> .Filter.Eq("EmployeeId", id); var update = new UpdateDefinitionBuilder <User>().Inc(user => user.Balance, -purchaseAmount); _Users.FindOneAndUpdate(filter, update); return(GetBalanceById(id)); }
public async Task <UpdateResult> Remove(ObjectId id, string removedBy) { var update = new UpdateDefinitionBuilder <EndpointEntity>() .Set(x => x.Deleted, true) .Set(x => x.UpdatedBy, removedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _endpointsServicesCollection.UpdateOneAsync(x => x.Id == id, update)); }
public async Task <UpdateResult> Update(ServiceManagerEntity serviceManager) { var update = new UpdateDefinitionBuilder <ServiceManagerEntity>() .Set(x => x.RunningServices, serviceManager.RunningServices) .Set(x => x.UpdatedBy, serviceManager.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _erviceManagersCollection.UpdateOneAsync(x => x.Id == serviceManager.Id, update)); }
/// <summary> /// 修改数据 /// </summary> public void UpdateDB() { FilterDefinitionBuilder <BsonDocument> filDefBui = Builders <BsonDocument> .Filter; FilterDefinition <BsonDocument> filDef = filDefBui.Eq("Name", "zq"); UpdateDefinitionBuilder <BsonDocument> updDefBui = Builders <BsonDocument> .Update; UpdateDefinition <BsonDocument> updDef = updDefBui.Set("Name", "zq2"); collectionBD.UpdateMany(filDef, updDef); }
public MongoProjectionStateProvider(MongoUrl url) { var mongo = new MongoClient(url); var db = mongo.GetDatabase(url.DatabaseName); Collection = db.GetCollection <ProjectionState>("projectionstate"); Filters = Builders <ProjectionState> .Filter; Update = Builders <ProjectionState> .Update; }
public async Task <UpdateResult> Remove(string id, string removedBy) { var update = new UpdateDefinitionBuilder <UserEntity>() .Set(x => x.Deleted, true) .Set(x => x.UpdatedBy, removedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _usersCollection.UpdateOneAsync(x => x.Id == id, update)); }
public async Task <int> Recovery_Step1(string Token, string Studio, string TokenPlayer, string Email) { if (await CheackToken(Token)) { try { var code = new Random().Next(); var Filter = new BsonDocument { { "Account.Token", ObjectId.Parse(TokenPlayer) }, { "Account.Email", Email } }; var Update = new UpdateDefinitionBuilder <BsonDocument>().Set("Account.RecoveryCode", code); var Result = await Client.GetDatabase(Studio).GetCollection <BsonDocument>("Players").UpdateOneAsync(Filter, Update); var bodyMessage = $"Hello dear " + "\n" + "\n" + "This email was sent to your request to recover your account." + "\n" + "Ignore this email if you have not submitted an account recovery request. " + "\n\n" + "Or use this code to recover the account." + "\n\n" + $"Code : {code}" + "\n\n\n" + "Thanks for choosing us" + "\n" + "Backendi.ir"; var Message = new MailMessage("*****@*****.**", Email, "Recovery Account", bodyMessage); SendMail_Recovery(Message, (s, e) => { }, () => { }); if (Result.ModifiedCount >= 1) { return(code); } else { return(0); } } catch (Exception) { return(0); } } else { return(0); } }
public async Task <UpdateResult> Update(MicroServiceEntity microService) { var update = new UpdateDefinitionBuilder <MicroServiceEntity>() .Set(x => x.Description, microService.Description) .Set(x => x.Name, microService.Name) .Set(x => x.UpdatedBy, microService.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _microServicesCollection.UpdateOneAsync(x => x.Id == microService.Id, update)); }
public StreamBasedEventStore(IMongoDatabase mongoDatabase, EventStoreSettings settings) { _eventSerializer = new DomainEventSerializer(); _mongoDatabase = mongoDatabase; _settings = settings; Streams = mongoDatabase.GetCollection <EventStream>(settings.StreamsesCollectionName); _settings = settings; _updater = Builders <EventStream> .Update; }
public Repository(IMongoDatabase Db) { this.Db = Db; Collection = Db.GetCollection <T>(typeof(T).Name); FilterBuilder = Builders <T> .Filter; UpdateBuilder = Builders <T> .Update; }
/// <summary> /// 更新 /// </summary> /// <param name="predicate"></param> /// <param name="entity"></param> /// <returns></returns> public async Task <long> UpdateAsync(Expression <Func <T, bool> > predicate, T entity) { var updateDefinitionList = MongoDBUtil.BuilderDefinition <T>(entity); var updateDefinitionBuilder = new UpdateDefinitionBuilder <T>().Combine(updateDefinitionList); var result = await _collection.UpdateOneAsync <T>(predicate, updateDefinitionBuilder).ConfigureAwait(false); return(result.ModifiedCount); }
public async Task <UpdateResult> Update(CommandEntity command) { var update = new UpdateDefinitionBuilder <CommandEntity>() .Set(x => x.Description, command.Description) .Set(x => x.Name, command.Name) .Set(x => x.UpdatedBy, command.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _commandsCollection.UpdateOneAsync(x => x.Id == command.Id, update)); }
public async Task <UpdateResult> Update(UserEntity user) { var update = new UpdateDefinitionBuilder <UserEntity>() .Set(x => x.FirstName, user.FirstName) .Set(x => x.LastName, user.LastName) .Set(x => x.UpdatedBy, user.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _usersCollection.UpdateOneAsync(x => x.Id == user.Id, update)); }
/// <summary> /// 获取更新信息 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="entity"></param> /// <returns></returns> internal static UpdateDefinition <T> GetUpdateDefinition <T>(this T entity) { var properties = typeof(T).GetEntityProperties(); var updateDefinitionList = GetUpdateDefinitionList <T>(properties, entity); var updateDefinitionBuilder = new UpdateDefinitionBuilder <T>().Combine(updateDefinitionList); return(updateDefinitionBuilder); }
public async Task <UpdateResult> Update(EndpointEntity endpointsService) { var update = new UpdateDefinitionBuilder <EndpointEntity>() .Set(x => x.Description, endpointsService.Description) .Set(x => x.Name, endpointsService.Name) .Set(x => x.UpdatedBy, endpointsService.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _endpointsServicesCollection.UpdateOneAsync(x => x.Id == endpointsService.Id, update)); }
public async Task <UpdateResult> Update(EventEntity eventEntity) { var update = new UpdateDefinitionBuilder <EventEntity>() .Set(x => x.Description, eventEntity.Description) .Set(x => x.Name, eventEntity.Name) .Set(x => x.UpdatedBy, eventEntity.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _eventsCollection.UpdateOneAsync(x => x.Id == eventEntity.Id, update)); }
public async Task <UpdateResult> Update(ProcessEntity process) { var update = new UpdateDefinitionBuilder <ProcessEntity>() .Set(x => x.Description, process.Description) .Set(x => x.Name, process.Name) .Set(x => x.UpdatedBy, process.UpdatedBy) .Set(x => x.LastUpdated, DateTime.Now); return(await _processsServicesCollection.UpdateOneAsync(x => x.Id == process.Id, update)); }
private void Initialize() { this.Db = Db; Collection = Db.GetCollection <T>(typeof(T).Name); FilterBuilder = Builders <T> .Filter; UpdateBuilder = Builders <T> .Update; }
/// <summary> /// 获取更新信息 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="entity"></param> /// <returns></returns> internal static UpdateDefinition <T> GetUpdateDefinition <T>(this T entity) { var properties = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public); var updateDefinitionList = GetUpdateDefinitionList <T>(properties, entity); var updateDefinitionBuilder = new UpdateDefinitionBuilder <T>().Combine(updateDefinitionList); return(updateDefinitionBuilder); }
public async Task <string> UpsertReminderRowAsync( string serviceId, GrainReference grainRef, string reminderName, DateTime startTime, TimeSpan period) { var collection = ReturnOrCreateRemindersCollection(); var reminder = collection.AsQueryable() .FirstOrDefault( r => r.ServiceId == serviceId && r.GrainId == grainRef.ToKeyString() && r.ReminderName == reminderName); if (reminder == null) { // Insert await collection.InsertOneAsync( new RemindersCollection { ServiceId = serviceId, GrainId = grainRef.ToKeyString(), ReminderName = reminderName, StartTime = startTime, Period = period.TotalMilliseconds, GrainHash = grainRef.GetUniformHashCode(), Version = 0 }); return("0"); } else { reminder.Version++; // Update var update = new UpdateDefinitionBuilder <RemindersCollection>() .Set(x => x.StartTime, startTime) .Set(x => x.Period, period.TotalMilliseconds) .Set(x => x.GrainHash, grainRef.GetUniformHashCode()) .Set(x => x.Version, reminder.Version); //reminder.StartTime = startTime; //reminder.Period = Convert.ToInt64(period.TotalMilliseconds); //reminder.GrainHash = grainRef.GetUniformHashCode(); //reminder.Version++; var result = await collection.UpdateOneAsync(r => r.ServiceId == serviceId && r.GrainId == grainRef.ToKeyString() && r.ReminderName == reminderName, update); return(reminder.Version.ToString()); } }
public async Task <dynamic> Get(string token) { var tokenCollection = MongoWrapper.Database.GetCollection <ReferenceToken>(nameof(ReferenceToken)); var userCollection = MongoWrapper.Database.GetCollection <Models.User>(nameof(Models.User)); var currentTime = DateTime.UtcNow; var confirmationFilterBuilder = new FilterDefinitionBuilder <ReferenceToken>(); var confirmationFilter = confirmationFilterBuilder.And ( confirmationFilterBuilder.Eq(conf => conf._id, token), confirmationFilterBuilder.Eq(conf => conf.TokenType, TokenType.Confirmation), GeneralUtils.NotDeactivated(confirmationFilterBuilder, currentTime) ); var confirmationUpdateBuilder = new UpdateDefinitionBuilder <ReferenceToken>(); var confirmationUpdate = confirmationUpdateBuilder.Set(conf => conf.DeactivationDate, currentTime); var oldConfirmation = await tokenCollection.FindOneAndUpdateAsync(confirmationFilter, confirmationUpdate, new FindOneAndUpdateOptions <ReferenceToken>() { ReturnDocument = ReturnDocument.Before }); if (oldConfirmation == null) { HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound; return(new ResponseBody() { Code = ResponseCode.NotFound, Data = null, Message = "O token especificado não existe ou já foi expirado!", Success = false }); } var userFilterBuilder = new FilterDefinitionBuilder <Models.User>(); var userFilter = userFilterBuilder.And ( userFilterBuilder.Eq(user => user._id, oldConfirmation.UserId), GeneralUtils.NotDeactivated(userFilterBuilder) ); var userUpdateBuilder = new UpdateDefinitionBuilder <Models.User>(); var userUpdate = userUpdateBuilder.Set(user => user.EmailConfirmed, true); await userCollection.UpdateOneAsync(userFilter, userUpdate); return(new ResponseBody() { Code = ResponseCode.GenericSuccess, Data = null, Message = "E-mail validado com sucesso!", Success = true }); }
/// <summary> /// 更新一个文档 /// </summary> /// <typeparam name="T">文档类型</typeparam> /// <param name="collcetionName">集合名称</param> /// <param name="filter">过滤器</param> /// <param name="entity">更新对象</param> /// <returns></returns> public async Task <long> UpdateOneAsync <T>(string collcetionName, Expression <Func <T, bool> > filter, T entity) where T : MongoEntity { var collcetion = GetCollection <T>(collcetionName); var updateDefinitionList = entity.GetUpdateDefinition(); var updateDefinitionBuilder = new UpdateDefinitionBuilder <T>().Combine(updateDefinitionList); var result = await collcetion.UpdateOneAsync <T>(filter, updateDefinitionBuilder); return(result.ModifiedCount); }
public Task Subscribe(Subscriber subscriber, MessageType messageType, ContextBag context) { var key = GetMessageTypeKey(messageType); var update = new UpdateDefinitionBuilder <Subscription>().AddToSet(s => s.Subscribers, SubscriberToString(subscriber)); return(_subscriptions.UpdateOneAsync(s => s.Id == key, update, new UpdateOptions() { IsUpsert = true })); }
public Task IncrementReportDownloadCountAsync(Guid reportId) { var filter = Builders <Report> .Filter.Eq(r => r.Id, reportId); var update = new UpdateDefinitionBuilder <Report>().Inc(r => r.DownloadCount, 1); var collection = GetCollection <Report>(); return(RetryPolicy.Execute(async _ => await collection.FindOneAndUpdateAsync(filter, update), new Context(nameof(IncrementReportDownloadCountAsync)))); }
protected override async Task ProcessItemsMissingFromApi(IEnumerable <Rune> itemsMissingFromApi) { this.logger.Info("Processing runes missing from API"); var updateDefinitionBuilder = new UpdateDefinitionBuilder <Rune>(); var updateDefinition = updateDefinitionBuilder.Set <bool>(r => r.Available, true); foreach (var rune in itemsMissingFromApi) { await this.Repository.Update(rune, r => r.RuneId == rune.RuneId, updateDefinition); } }
public async Task<bool> DeleteSharelinkTags(string userId, string[] tagIds) { ObjectId userOId = new ObjectId(userId); var collection = Client.GetDatabase("Sharelink").GetCollection<Sharelinker>("Sharelinker"); var ids = from id in tagIds select new ObjectId(id); var update = new UpdateDefinitionBuilder<Sharelinker>().PullAll(u => u.SharelinkTags, ids); var res = await collection.UpdateOneAsync(u => u.Id == userOId ,update); var tagCollection = Client.GetDatabase("Sharelink").GetCollection<SharelinkTag>("SharelinkTag"); var tagFilter = new FilterDefinitionBuilder<SharelinkTag>().In(t => t.Id, ids); var uId = new ObjectId(); var tagUpdate = new UpdateDefinitionBuilder<SharelinkTag>().Set(t => t.UserId, uId); await tagCollection.UpdateManyAsync(tagFilter,tagUpdate); try { return res.ModifiedCount > 0; } catch (Exception) { return false; } }
public async Task<bool> UpdateSharelinkTag(string userId, string tagId ,string newTagName,string newColor,string dataUpdated,bool isFocus,string type,bool isShowToLinkers) { var collection = Client.GetDatabase("Sharelink").GetCollection<Sharelinker>("Sharelinker"); var collectionTag = Client.GetDatabase("Sharelink").GetCollection<SharelinkTag>("SharelinkTag"); var tagOId = new ObjectId(tagId); var userOId = new ObjectId(userId); var updateBuilder = new UpdateDefinitionBuilder<SharelinkTag>(); var update = updateBuilder .Set(tt => tt.TagName, newTagName) .Set(tt => tt.TagColor, newColor) .Set(tt => tt.Data, dataUpdated) .Set(tt => tt.IsFocus, isFocus) .Set(tt => tt.ShowToLinkers, isShowToLinkers); try { var result = await collectionTag.UpdateOneAsync(t => t.Id == tagOId && t.UserId == userOId, update); return true; } catch (Exception) { return false; } }
public async Task<ShareThing> UnvoteShare(string userId, string shareId) { var sId = new ObjectId(shareId); var shareThingCollection = Client.GetDatabase("Sharelink").GetCollection<ShareThing>("ShareThing"); var UserId = new ObjectId(userId); var op = new UpdateDefinitionBuilder<ShareThing>().PullFilter(t => t.Votes, t => t.UserId == UserId); var result = await shareThingCollection.FindOneAndUpdateAsync(s => s.Id == sId, op); return result; }
public async Task<bool> UpdateUserlinkStateWithUser(string masterUserId, string otherUserId, string state) { var collection = Client.GetDatabase("Sharelink").GetCollection<SharelinkerLink>("SharelinkerLink"); var mUOId = new ObjectId(masterUserId); var oUId = new ObjectId(otherUserId); var update = new UpdateDefinitionBuilder<SharelinkerLink>(); var result = await collection.UpdateOneAsync(u => u.MasterUserObjectId == mUOId && u.SlaveUserObjectId == oUId , update.Set(u => u.StateDocument, state)); try { return result.ModifiedCount > 0; } catch (Exception) { return false; } }
public async Task<SharelinkerLink> CreateNewLinkWithOtherUser(string masterUserId, string otherUserId, SharelinkerLink.State state,string noteName = null) { var mUOId = new ObjectId(masterUserId); var otherUser = await GetUserOfUserId(otherUserId); var linkCollection = Client.GetDatabase("Sharelink").GetCollection<SharelinkerLink>("SharelinkerLink"); var newLink = new SharelinkerLink() { CreateTime = DateTime.UtcNow, StateDocument = state.ToJson(), MasterUserObjectId = mUOId, SlaveUserObjectId = otherUser.Id, SlaveUserNoteName = noteName == null ? otherUser.NickName : noteName }; await linkCollection.InsertOneAsync(newLink); var update = new UpdateDefinitionBuilder<Sharelinker>().Push(slu => slu.LinkedUsers, newLink.Id); var collection = Client.GetDatabase("Sharelink").GetCollection<Sharelinker>("Sharelinker"); await collection.UpdateOneAsync(slu => slu.Id == mUOId, update); return newLink; }
public async Task<ShareThing> VoteShare(string userId, string shareId) { var sId = new ObjectId(shareId); var shareThingCollection = Client.GetDatabase("Sharelink").GetCollection<ShareThing>("ShareThing"); var newVote = new Vote() { UserId = new ObjectId(userId), VoteTime = DateTime.UtcNow }; var update = new UpdateDefinitionBuilder<ShareThing>().Push(ts => ts.Votes, newVote); var result = await shareThingCollection.FindOneAndUpdateAsync(s => s.Id == sId, update); return result; }
private async Task<WeatherAggregate> IncrementMessageCount(Guid correlationId) { var increment = new UpdateDefinitionBuilder<WeatherAggregate>() .Inc(wa => wa.MessagesProcessed, 1); var result = await db.GetCollection<WeatherAggregate>(WeatherAggregate.Collection) .FindOneAndUpdateAsync<WeatherAggregate>(wa => wa.CorrelationId == correlationId, increment, new FindOneAndUpdateOptions<WeatherAggregate> { ReturnDocument = ReturnDocument.After }); return result; }
private async Task UpdateHighestTemperature(Guid correlationId, double? temperature, string cityName) { var update = new UpdateDefinitionBuilder<WeatherAggregate>() .Set(wa => wa.Highest, new Weather {CityName = cityName, Temperature = temperature}); await db.GetCollection<WeatherAggregate>(WeatherAggregate.Collection) .FindOneAndUpdateAsync(wa => wa.CorrelationId == correlationId && (wa.Highest.Temperature == null || wa.Highest.Temperature < temperature), update); }
public async Task<long> DeleteFires(string accountId, IEnumerable<string> fileIds) { var update = new UpdateDefinitionBuilder<FireRecord>().Set(fr => fr.State, (int)FireRecordState.Delete); var result = await Client.GetDatabase(FireDBName).GetCollection<FireRecord>("FireRecord").UpdateManyAsync(fr => fr.AccountId == accountId && fileIds.Contains(fr.Id.ToString()), update); return result.ModifiedCount; }
/// <summary> /// updates the advocate given the user name /// </summary> /// <param name="toUpdate">this is the advocate object that is due for updation</param> /// <returns>void if all is well , send out an exception if something went wrong</returns> public async Task PATCHAdvocate(string objID, Advocate toUpdate) { if (toUpdate!=null) { //getting the advocate to modify //var filter = Builders<Advocate>.Filter.Eq(x => x.username, // toUpdate.username); //this woudl get the advocate object desite the fact that we may have changed the object var filter = Builders<Advocate>.Filter.Eq(x => x.id,new BsonObjectId(objID)); //this runs into a problem cause im not if this is atomic operation ? var updateDef = new UpdateDefinitionBuilder<Advocate>() .Set(x => x.password, toUpdate.password) .Set(x => x.access, toUpdate.access) .Set(x => x.alias, toUpdate.alias) .Set(x=>x.username, toUpdate.username); var collection = this.Database.GetCollection<Advocate>(Properties.Settings.Default.advocatesCollection); //updating the item var updateTask = collection.UpdateOneAsync(filter,updateDef); await updateTask; if (updateTask.Result.ModifiedCount>0) { return; } else { throw new IOException("the advocate was not updated"); } } else { return ; } }
protected async Task ProcessItemsMissingFromApi(IEnumerable<Champion> itemsMissingFromApi) { var updateDefinitionBuilder = new UpdateDefinitionBuilder<BsonDocument>(); var updateDefinition = updateDefinitionBuilder.Set(c => c[ChampionAvailableParameterName], false); var jsonStringChampions = JsonConvert.SerializeObject(itemsMissingFromApi, Formatting.Indented); var bsonChampions = BsonSerializer.Deserialize<IEnumerable<BsonDocument>>(jsonStringChampions); foreach (var champion in bsonChampions) { await this.championSavingRepository.Update(champion, c => c[ChampionIdParameterName] == champion[ChampionIdParameterName], updateDefinition); } }