public async Task <PatientDTO> EditPatientInfo(PatientDTO patient)
{
Patient clientPatient = patient.ConvertToModel();
Patient dbPatient = _patients.Find(p => p.PatientId == clientPatient.PatientId).First();
var updates = new List <UpdateDefinition <Patient> > {
Builders <Patient> .Update.CurrentDate("LastModified")
};
string[] unchanged = { "Id", "PatientId", "LastModified", "Diagnosis" };
IEnumerable <PropertyInfo> properties = typeof(Patient).GetProperties().Where(p => !unchanged.Contains(p.Name));
foreach (PropertyInfo propertyInfo in properties)
{
if (propertyInfo.CanRead)
{
object firstValue = propertyInfo.GetValue(clientPatient);
object secondValue = propertyInfo.GetValue(dbPatient);
if (!Equals(firstValue, secondValue))
{
updates.Add(Builders <Patient> .Update.Set(propertyInfo.Name, firstValue));
}
}
}
var resPatient = await _patients.FindOneAndUpdateAsync(p => p.PatientId == clientPatient.PatientId, Builders <Patient> .Update.Combine(updates));
return(resPatient.ConvertToDTO());
}
public async Task <Asistente> UpdateSolicitudInicial(Asistente asistente, String nombreexpediente)
{
Pasos pasos = await pasoService.GetPasoByNombreExpediente(nombreexpediente);
pasos.documentos.Find(x => x.tipo == asistente.tipodocumento)
.pasos.Find(x => x.indice == asistente.paso - 1).fechainicio = asistente.pasos.documentos.ElementAt(0).pasos.ElementAt(0).fechainicio;
pasos.documentos.Find(x => x.tipo == asistente.tipodocumento)
.pasos.Find(x => x.indice == asistente.paso - 1).fechafin = asistente.pasos.documentos.ElementAt(0).pasos.ElementAt(0).fechafin;
pasos.documentos.Find(x => x.tipo == asistente.tipodocumento)
.pasos.Find(x => x.indice == asistente.paso - 1).fechalimite = asistente.pasos.documentos.ElementAt(0).pasos.ElementAt(0).fechalimite;
FilterDefinition <Asistente> queryUpdate = Builders <Asistente> .Filter.Eq("idexpediente", asistente.idexpediente);
UpdateDefinition <Asistente> updateAsistente = Builders <Asistente> .Update
.Set("paso", asistente.paso)
.Set("subpaso", asistente.subpaso)
.Set("tipodocumento", asistente.tipodocumento)
.Set("pasos", new PasoAsistente {
documentos = pasos.documentos, nombreexpediente = pasos.nombreexpediente
});
Asistente asistenteActualizado = await _asistentes.FindOneAndUpdateAsync(queryUpdate, updateAsistente, new FindOneAndUpdateOptions <Asistente>
{
ReturnDocument = ReturnDocument.After
});
return(asistenteActualizado);
}
private string GetBestOnlineStrategy(OnlineStrategyParameters parameters)
{
string bestStrategy = null;
Campaign cpg = _campaigns.Find(cpg => cpg.Id == parameters.Id).FirstOrDefault();
foreach (Strategy strategy in cpg.Strategies)
{
if (strategy.StrategyType == StrategyType.Online &&
strategy.ExtraElements.URL == parameters.URL &&
strategy.StrategyBudget >= parameters.Budget)
{
bestStrategy = strategy.StrategyName;
int remainingBudget = strategy.StrategyBudget - parameters.Budget;
FilterDefinition <Campaign> filter = Builders <Campaign> .Filter.And(
Builders <Campaign> .Filter.Eq(cpg => cpg.Id, parameters.Id),
Builders <Campaign> .Filter.ElemMatch <Strategy>(cpg => cpg.Strategies, x => x.StrategyName == bestStrategy)
);
UpdateDefinition <Campaign> update = Builders <Campaign> .Update.Set(cpg => cpg.Strategies[-1].StrategyBudget, remainingBudget);
_campaigns.FindOneAndUpdateAsync(filter, update);
break;
}
}
return(bestStrategy);
}
public async Task <Device> UpdateDeviceAsync(Device device, bool isUpsert = false, params string[] fieldsToUnset)
{
device.UpdatedAt = DateTime.Now;
var newValues = device.ToBsonDocument();
foreach (var f in fieldsToUnset)
{
// Avoid "Updating the path would create a conflict at..." -- https://stackoverflow.com/a/50947773
newValues.Remove(f);
}
var filter = new FilterDefinitionBuilder <Device>().Eq(d => d._id, device._id);
var update = new BsonDocument {
{ "$set", newValues }
};
if (fieldsToUnset.Length > 0)
{
update.Add("$unset", new BsonDocument(fieldsToUnset.Select(f => new BsonElement(f, ""))));
}
var options = new FindOneAndUpdateOptions <Device>()
{
IsUpsert = isUpsert, ReturnDocument = ReturnDocument.After
};
return(await _deviceCollection.FindOneAndUpdateAsync(filter, update, options));
}
public async Task <User> UpdatePasswordHash(string id, string hash)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (hash == null)
{
throw new ArgumentNullException(nameof(hash));
}
var filter = Builders <User> .Filter.Eq("_id", id);
var update = Builders <User> .Update.Set("PasswordHash", hash);
var user = await _users.FindOneAndUpdateAsync(filter, update, new FindOneAndUpdateOptions <User, User>
{
ReturnDocument = ReturnDocument.After
});
if (user == null)
{
throw new DocumentNotFoundException($"id: {id}");
}
return(user);
}
private async Task <Cart> _updateCartById(string cartId, Cart cart)
{
cart.Products.ForEach(cartProduct =>
{
cartProduct.TotalPrice = cartProduct.UnitPrice * (decimal)cartProduct.Quantity;
});
cart.TotalPrice = cart.Products.Sum(s => s.TotalPrice);
cart.Quantity = cart.Products.Sum(s => s.Quantity);
cart.UpdatedAt = DateTime.Now;
var update = Builders <Cart> .Update
.Set("Quantity", cart.Quantity)
.Set("TotalPrice", cart.TotalPrice)
.Set("UpdatedAt", cart.UpdatedAt)
.Set("Products", cart.Products);
var options = new FindOneAndUpdateOptions <Cart, Cart> {
ReturnDocument = ReturnDocument.After
};
var updatedCart = await _carts.FindOneAndUpdateAsync <Cart, Cart>(r => r.ID == cartId, update, options);
updatedCart = await _populateCartProductsImage(updatedCart);
return(updatedCart);
}
public async Task Consume(ConsumeContext <FolderNameChanged> context)
{
var filter = new BsonDocument("_id", context.Message.Id).Add("Version", context.Message.Version - 1);
var update = Builders <BsonDocument> .Update
.Set("Name", context.Message.NewName)
.Set("UpdatedBy", context.Message.UserId)
.Set("UpdatedDateTime", context.Message.TimeStamp.UtcDateTime)
.Set("Version", context.Message.Version);
var element = await _foldersCollection.FindOneAndUpdateAsync(filter, update);
if (element == null)
{
throw new ConcurrencyException(context.Message.Id);
}
//await context.Publish(new FolderPersisted(context.Message.Id, context.Message.UserId));
await context.Publish <RenamedFolderPersisted>(new
{
Id = context.Message.Id,
TimeStamp = DateTimeOffset.UtcNow,
Version = context.Message.Version
});
}
public async Task <string> CreateAsync(string hallId, string standId, ExhibitViewModel entity)
{
if (entity.Photos != null)
{
foreach (var photo in entity.Photos)
{
ObjectId id = await _gridFS.UploadFromBytesAsync(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffffff"), photo?.Photo);
photo.Id = id.ToString();
photo.Photo = null;
}
}
else
{
entity.Photos = new List <PhotoInfo>();
}
var filter = Builders <HallViewModel> .Filter.And(
Builders <HallViewModel> .Filter.Where(hall => hall.Id.Equals(hallId)),
Builders <HallViewModel> .Filter.Eq("Stands.Id", standId));
entity.Id = ObjectId.GenerateNewId().ToString();
var update = Builders <HallViewModel> .Update.Push("Stands.$.Exhibits", entity);
await _halls.FindOneAndUpdateAsync(filter, update);
return(entity.Id);
}
public async Task <AccountConfiguration> AddOrUpdateAccountConfiguration_WXMFields(string adminUser, string apiKey, string user, string baseUrl)
{
Dictionary <string, string> defaultExtendedProperties = new Dictionary <string, string>
{
{ "BatchingQueue", "inmemory" },
{ "Sampler", "wxm" },
{ "Unsubscriber", "wxm" },
{ "AccountNotifications", "" }
};
var filter = Builders <AccountConfiguration> .Filter.Empty;
var update = Builders <AccountConfiguration> .Update
.SetOnInsert(x => x.DispatchChannels, null)
.SetOnInsert(x => x.Id, ObjectId.GenerateNewId().ToString())
.SetOnInsert(x => x.Vendors, null)
.SetOnInsert(x => x.ExtendedProperties, defaultExtendedProperties)
.Set(x => x.Queue, null)
.Set(x => x.WXMAdminUser, adminUser)
.Set(x => x.WXMAPIKey, apiKey)
.Set(x => x.WXMBaseURL, baseUrl)
.Set(x => x.WXMUser, user);
var opts = new FindOneAndUpdateOptions <AccountConfiguration> {
IsUpsert = true, ReturnDocument = ReturnDocument.After
};
return(await _AccountConfiguration.FindOneAndUpdateAsync <AccountConfiguration>(filter, update, opts));
}
public Task <ImdbRating> SaveImdbRating(string movieId, ImdbRating rating)
{
if (!ObjectId.TryParse(movieId, out var movieIdValue))
{
throw NewInvalidMovieIdArgumentException(movieId);
}
if (rating is null)
{
throw new ArgumentNullException(nameof(rating));
}
return(SaveImdbRating());
async Task <ImdbRating> SaveImdbRating()
{
var filter = Builders <Movie> .Filter.Eq(movie => movie.Id, new ObjectId(movieId));
var update = Builders <Movie> .Update.Set(movie => movie.Imdb, rating);
var movie = await _collection
.FindOneAndUpdateAsync
(
filter,
update,
options : new() { ReturnDocument = ReturnDocument.After }
)
.ConfigureAwait(false);
return(movie?.Imdb ?? throw NewEntityNotFoundException(nameof(SaveImdbRating), movieId));
}
}
public Task UpdateEnvironment(string appId, string environmentId, EnvironmentInfo environment)
{
var replacement = MapEnvironment(environment);
return(_collection.FindOneAndUpdateAsync(
c => c.ApplicationId == appId && c.Environments.Any(e => e.EnvironmentId == environmentId),
Builders <ApplicationDefinition> .Update.Set(doc => doc.Environments[-1], replacement)));
}
public static void updateArray(string filterField, string filterCriteria, string arrayField, string arrayCriteria)
{
var filter = Builders <BsonDocument> .Filter.Eq(filterField, filterCriteria);
var update = Builders <BsonDocument> .Update.Push(arrayField, arrayCriteria);
Collection.FindOneAndUpdateAsync(filter, update);
}
public async Task AddOptionAsync(string id, string optionId)
{
var filter = Builders <Options> .Filter.Where(options => options.Id == id);
var update = Builders <Options> .Update.Push <string>(options => options.ListOfOptionId, optionId);
await OptionsCollection.FindOneAndUpdateAsync(filter, update);
}
public virtual void UpdateAndFindOne(FilterDefinition <T> predicate, UpdateDefinition <T> update)
{
_context.AddCommand(async() =>
{
await _dbSet.FindOneAndUpdateAsync(predicate, update);
});
_uow.Commit();
}
//public void UpdateOneInnerArray(String id, String innerDocId, String field, IDocument m)
//{
// FilterDefinition<TDocument> filter = Builders<TDocument>.Filter.Where(x => x.Id == new ObjectId(id));
// FilterDefinition<TDocument> projection =
// UpdateDefinition<TDocument> update = Builders<TDocument>.Update.Push(field, m);
// _collection.FindOneAndUpdate(filter, update);
//}
public Task UpdateOneArrayAsync(String id, String field, IDocument m)
{
FilterDefinition <TDocument> filter = Builders <TDocument> .Filter.Where(x => x.Id == new ObjectId(id));
UpdateDefinition <TDocument> update = Builders <TDocument> .Update.Push(field, m);
return(Task.Run(() => _collection.FindOneAndUpdateAsync(filter, update)));
}
public async Task AddItemAsync(string id, string itemId)
{
var filter = Builders <Category> .Filter.Where(category => category.Id == id);
var update = Builders <Category> .Update.Push <string>(category => category.ListOfItemId, itemId);
await CategoriesCollection.FindOneAndUpdateAsync(filter, update);
}
public async Task UpdateNameAsync(Guid id, string name)
{
await _chargeStationDocuments.FindOneAndUpdateAsync(
Builders <ChargeStationDocument> .Filter.Where(s => s.Id == id.ToString()),
Builders <ChargeStationDocument> .Update
.Set(rec => rec.Name, name)
).ConfigureAwait(false);
}
public async Task <Player> Modify(Guid id, string name)
{
var filter = Builders <Player> .Filter.Eq(p => p._id, id);
var update = Builders <Player> .Update.Set(p => p._Name, name);
return(await _collection.FindOneAndUpdateAsync(filter, update)); //TODO
}
public Task HandleAsync(ProductMarkedForSaleEvent @event, CancellationToken cancellationToken = default(CancellationToken))
{
var filter = Builders <ProductViewModel> .Filter.Eq(p => p.ProductId, @event.ProductId);
var update = Builders <ProductViewModel> .Update.Set(p => p.IsProductForSale, true); // For sale.
return(_productViewCollection.FindOneAndUpdateAsync(filter, update, null, cancellationToken));
}
public async Task AddMessageToChatAsync(string chatId, ChatConversation conversation)
{
try {
await _chats.FindOneAndUpdateAsync(Builders <Chat> .Filter.Eq("Id", chatId), Builders <Chat> .Update.Push("ChatConversations", conversation));
} catch (Exception ex) {
_logger.LogError(ex, "AddMessageToChatAsync ChatRepository Exception");
}
}
public async Task <T> UpsertOne(Expression <Func <T, bool> > filter, UpdateDefinition <T> updater)
{
var options = new FindOneAndUpdateOptions <T, T> {
IsUpsert = true, ReturnDocument = ReturnDocument.After
};
return(await _collection.FindOneAndUpdateAsync(CombineExpression(filter), updater, options));
}
public async Task <Player> UpdatePlayer(Guid id, ModifiedPlayer player)
{
var filter = Builders <Player> .Filter.Eq("_id", id);
var update = Builders <Player> .Update.Set("Score", player.Score);
return(await _collection.FindOneAndUpdateAsync(filter, update));;
}
public async Task <Quest> TakeQuest(Guid id, QuestTakeInfo info)
{
var filter = IdFilter(id);
var update = Builders <Quest> .Update
.Set(quest => quest.Taker, info.Taker)
.Set(quest => quest.Status, QuestStatus.Taken);
return(await collection.FindOneAndUpdateAsync(filter, update));
}
public Task <TProjection> FindOneAndUpdateAsync <TProjection>(
FilterDefinition <T> filter,
UpdateDefinition <T> update,
FindOneAndUpdateOptions <T, TProjection>?options = null,
CancellationToken cancellationToken = default
)
{
return(collection.FindOneAndUpdateAsync(filter, update, options, cancellationToken));
}
public async Task <User> BanUser(Guid id)
{
FilterDefinition <User> filter = Builders <User> .Filter.Eq("id", id);
var banuser = Builders <User> .Update.Set("IsBanned", true);
User user = await _collection.FindOneAndUpdateAsync(filter, banuser);
return(user);
}
public async Task <Item> CreateItem(Guid playerId, Item item)
{
FilterDefinition <Player> filter = Builders <Player> .Filter.Eq("_id", playerId);
var update = Builders <Player> .Update.Push("Items", item);
await collection.FindOneAndUpdateAsync(filter, update);
return(item);
}
public async Task SetCurrentAsync(string id)
{
var updateDefinition = Builders <ContestSettingsStorage> .Update.Set(x => x.CurrentId, id);
await _contestSettingsCollection.FindOneAndUpdateAsync <ContestSettingsStorage>(x => x.Id == "current",
updateDefinition,
new FindOneAndUpdateOptions <ContestSettingsStorage, ContestSettingsStorage> {
IsUpsert = true
});
}
public async Task UpdateRouteWithTriggerPoint(string recordId, double longtitude, double latitude, double speed)
{
await _routes.FindOneAndUpdateAsync(
Builders <Route> .Filter.Eq(r => r.Id, recordId),
Builders <Route> .Update
.Set(x => x.TriggerLatitude, latitude)
.Set(x => x.TriggerLongitude, longtitude)
.Set(x => x.StartingSpeed, speed)
);
}
public async Task IncrementLmaoCount(long userID)
{
await CreateUserSettings(userID);
var filter = Builders <LmaoBotUser> .Filter.Eq("UserID", userID);
var update = Builders <LmaoBotUser> .Update.Inc(settings => settings.Settings.LmaoCount, 1);
await Collection.FindOneAndUpdateAsync(filter, update);
}
public async Task <Player> UpdatePlayerName(Guid playerid, String name)
{
FilterDefinition <Player> filter = Builders <Player> .Filter.Eq("id", playerid);
var updatename = Builders <Player> .Update.Set("name", name);
Player player = await _collection.FindOneAndUpdateAsync(filter, updatename);
return(player);
}
private async Task<MongoTodoItem> UpdateStatus(IMongoCollection<MongoTodoItem> collection, string id, bool status)
{
var todo = await collection.FindOneAndUpdateAsync(t => t.Id == id, Builders<MongoTodoItem>.Update.Set(t => t.Done, status));
return todo;
}
