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