private void Assert <TDocument>(UpdateDefinition <TDocument> update, BsonDocument expected)
{
var documentSerializer = BsonSerializer.SerializerRegistry.GetSerializer <TDocument>();
var renderedUpdate = update.Render(documentSerializer, BsonSerializer.SerializerRegistry);
renderedUpdate.Should().Be(expected);
}
public void can_check_for_fields_to_be_updated_from_a_request_object_and_prepare_update_definition()
{
//arrange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = _faker.Random.Word(),
anyField = _faker.Random.Words(),
numberField = _faker.Random.Number()
};
matProcessData.DateLastModified = _faker.Date.Recent();
var expectedUpdateDefinition = Builders <BsonDocument> .Update.Combine(
Builders <BsonDocument> .Update.Set("dateLastModified", matProcessData.DateLastModified),
Builders <BsonDocument> .Update.Set("processDataAvailable", true),
Builders <BsonDocument> .Update.Set("processData", BsonDocument.Parse(JsonConvert.SerializeObject(matProcessData.ProcessData))));
//act
UpdateDefinition <BsonDocument> processDataUpdateDefinition = UpdateProcessDocumentHelper.PrepareFieldsToBeUpdated(matProcessData);
//assert
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <BsonDocument>();
//compare what the update definitions render to
Assert.AreEqual(expectedUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString(),
processDataUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString());
}
public static BsonDocument RenderToBsonDocument <T>(this UpdateDefinition <T> filter)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
return(filter.Render(documentSerializer, serializerRegistry));
}
private BsonDocument Render <T>(UpdateDefinition <T> filter)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
return((BsonDocument)filter.Render(documentSerializer, serializerRegistry));
}
public void can_check_for_fields_to_be_updated_from_a_request_object_correctly(string firstField)
{
//this test ensures that the update definition is built correctly and will be recognised as different when compared to a different
//update definition
//arrange
var matProcessData = new MatUpdateProcessData();
//add fields to be updated
matProcessData.ProcessData = new
{
firstField = _faker.Random.Word(),
anyField = _faker.Random.Words(),
numberField = _faker.Random.Number()
};
matProcessData.DateLastModified = _faker.Date.Recent();
var expectedUpdateDefinition = Builders <BsonDocument> .Update.Combine(
Builders <BsonDocument> .Update.Set("dateLastModified", matProcessData.DateLastModified),
Builders <BsonDocument> .Update.Set("processDataa", matProcessData.ProcessData));
//act
UpdateDefinition <BsonDocument> processDataUpdateDefinition = UpdateProcessDocumentHelper.PrepareFieldsToBeUpdated(matProcessData);
//assert
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <BsonDocument>();
//test that update definitions are succesfully recognised as different
Assert.AreNotEqual(expectedUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString(),
processDataUpdateDefinition.Render(documentSerializer, serializerRegistry).ToString());
}
private BsonDocument RenderDefinition <TEntity>(UpdateDefinition <TEntity> definition)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <TEntity>();
return(definition.Render(documentSerializer, serializerRegistry));
}
public BsonDocument Render(UpdateDefinition <BsonDocument> update)
{
var registry = BsonSerializer.SerializerRegistry;
var serializer = registry.GetSerializer <BsonDocument>();
return(update.Render(serializer, registry));
}
private BsonValue Render <TDocument>(UpdateDefinition <TDocument> update, LinqProvider linqProvider)
{
var documentSerializer = BsonSerializer.LookupSerializer <TDocument>();
var serializerRegistry = BsonSerializer.SerializerRegistry;
return(update.Render(documentSerializer, serializerRegistry, linqProvider));
}
/// <summary>
/// Converts a UpdateDefinition to a BSON Document
/// </summary>
/// <typeparam name="T">The Type used in the UpdateDefinition</typeparam>
/// <param name="definition">The definition to converted</param>
/// <returns>A BSON value representing the definition</returns>
public static BsonValue ToBson <T>(this UpdateDefinition <T> definition)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
return(definition.Render(documentSerializer, serializerRegistry));
}
private UpdateResult UpdateDocuments(IEnumerable <TDocument> documents, UpdateDefinition <TDocument> update)
{
var matchedCount = 0;
var modifiedCount = 0;
var bsobUpdate = update.Render(DocumentSerializer, Settings.SerializerRegistry).AsBsonDocument;
foreach (var docObject in documents)
{
var docIndex = docObjects.IndexOf(docObject);
if (docIndex == -1)
{
throw new InvalidOperationException();
}
var doc = docs[docIndex];
var docId = GetDocumentIdValue(doc);
var updatedDoc = doc.DeepClone().AsBsonDocument;
foreach (var updateElement in bsobUpdate)
{
var operationName = updateElement.Name;
switch (operationName)
{
case "$set":
{
var setDoc = updateElement.Value.AsBsonDocument;
updatedDoc = updatedDoc.Merge(setDoc, true);
modifiedCount += setDoc.ElementCount;
break;
}
default:
throw new NotSupportedException($"Not supported update operation {operationName}.");
}
}
var updatedId = GetDocumentIdValue(updatedDoc);
using (var bsonReader = new BsonDocumentReader(updatedDoc))
{
var bsonDeserializationContext = BsonDeserializationContext.CreateRoot(bsonReader);
var updatedDocObject = DocumentSerializer.Deserialize(bsonDeserializationContext);
docObjects[docIndex] = updatedDocObject;
}
if (updatedId != docId)
{
if (!docIds.Remove(docId))
{
throw new InvalidOperationException();
}
docIds.Add(updatedId, docIndex);
}
matchedCount++;
}
return(new UpdateResult.Acknowledged(matchedCount, modifiedCount, null));
}
public static bool HasChanges <TEntity>(this UpdateDefinition <TEntity> definition)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <TEntity>();
var renderedDefinition = definition.Render(documentSerializer, serializerRegistry);
return(!renderedDefinition.Equals(new BsonDocument()));
}
public static string RenderToString <T>(UpdateDefinition <T> filter)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
// ReSharper disable once SpecifyACultureInStringConversionExplicitly
var result = filter.Render(documentSerializer, serializerRegistry).ToString();
return(result);
}
private static string GetJson <T>(UpdateDefinition <T> updateDefinition)
{
if (updateDefinition is null)
{
return(null);
}
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
return(updateDefinition.Render(documentSerializer, serializerRegistry).ToJson());
}
public static BsonDocument RenderToBsonDocument <T>(this UpdateDefinition <T> update)
{
if (update == null)
{
return(new BsonDocument());
}
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
return(update.Render(documentSerializer, serializerRegistry));
}
private void LogUpdateFilter(FilterDefinition <T> filter, UpdateDefinition <T> update)
{
if (!Logger.IsDebugEnabled)
{
return;
}
var filterJson = filter.Render(_collection.DocumentSerializer, _collection.Settings.SerializerRegistry);
var updateJson = update.Render(_collection.DocumentSerializer, _collection.Settings.SerializerRegistry);
Logger.DebugFormat($"Detected partial delete parameters: {updateJson}");
Logger.DebugFormat($"Detected partial delete filters: {filterJson}");
}
/// <summary>
/// Logs the update filter.
/// </summary>
/// <param name="filter">The filter definition.</param>
/// <param name="update">The update definition.</param>
protected virtual void LogUpdateFilter(FilterDefinition <T> filter, UpdateDefinition <T> update)
{
if (!Logger.IsDebugEnabled)
{
return;
}
var filterJson = filter.Render(Collection.DocumentSerializer, Collection.Settings.SerializerRegistry);
var updateJson = update.Render(Collection.DocumentSerializer, Collection.Settings.SerializerRegistry);
Logger.Debug($"Detected update parameters: {updateJson}");
Logger.Debug($"Detected update filters: {filterJson}");
}
public static string ToJson <T>(this UpdateDefinition <T> updateDefinition, JsonOutputMode outputMode = JsonOutputMode.Strict)
{
if (updateDefinition == null)
{
return(string.Empty);
}
var serializerRegistry = BsonSerializer.SerializerRegistry;
var documentSerializer = serializerRegistry.GetSerializer <T>();
var bson = updateDefinition.Render(documentSerializer, serializerRegistry);
return(bson.ToJson(new JsonWriterSettings {
OutputMode = outputMode
}));
}
public void BuildEnteredInError_ValidVersionNull()
{
var service = new NrlsMaintain(_nrlsApiSettings, _fhirMaintain, _fhirSearch, _sdsService, _fhirValidation);
UpdateDefinition <BsonDocument> updates = null;
service.BuildEnteredInError(null, out updates);
Assert.NotNull(updates);
var bson = updates.Render(BsonSerializer.LookupSerializer <BsonDocument>(), BsonSerializer.SerializerRegistry);
BsonDocument updateElements = bson.Elements.FirstOrDefault().Value.ToBsonDocument();
Assert.Equal("1", updateElements.Elements.FirstOrDefault(x => x.Name == "meta.versionId").Value.AsString);
}
public long Apply <T>(UpdateDefinition <T> updateDefinition, IEnumerable <BsonDocument> docs)
{
var serializer = BsonSerializer.SerializerRegistry.GetSerializer <T>();
var updateDoc = updateDefinition.Render(serializer, BsonSerializer.SerializerRegistry);
var updateActions = GetActions(updateDoc);
long updated = 0;
foreach (var doc in docs)
{
foreach (var action in updateActions)
{
action(doc);
}
updated++;
}
return(updated);
}
public void BuildSupersede_ValidVersionAlt()
{
var service = new NrlsMaintain(_nrlsApiSettings, _fhirMaintain, _fhirSearch, _cache, _fhirValidation);
UpdateDefinition <BsonDocument> updates = null;
FhirRequest updateRequest = null;
service.BuildSupersede("1", "10", out updates, out updateRequest);
Assert.NotNull(updates);
var bson = updates.Render(BsonSerializer.LookupSerializer <BsonDocument>(), BsonSerializer.SerializerRegistry);
BsonDocument updateElements = bson.Elements.FirstOrDefault().Value.ToBsonDocument();
Assert.Equal("11", updateElements.Elements.FirstOrDefault(x => x.Name == "meta.versionId").Value.AsString);
}
public static string RenderQuery <T>(UpdateDefinition <T> filterDefinition) where T : TDocument
{
var query = string.Empty;
try
{
IBsonSerializerRegistry registry = BsonSerializer.SerializerRegistry;
IBsonSerializer <T> serializer = BsonSerializer.SerializerRegistry.GetSerializer <T>();
FilterDefinitionBuilder <T> __subject = Builders <T> .Filter;
query = filterDefinition.Render(serializer, registry).ToString();
}
catch (Exception)
{
}
return(query);
}
public override UpdateResult UpdateOne(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
var documentsToUpdate = Filter(filter);
var documentToUpdate = documentsToUpdate.FirstOrDefault();
if (documentToUpdate != null)
{
var updateDefenition = update.Render(BsonSerializer.LookupSerializer <TDocument>(), new BsonSerializerRegistry());
var operation = new UpdateOperation <TDocument>(documentToUpdate, updateDefenition, options);
var updatedItem = operation.Execute().First();
_documents.Remove(documentToUpdate);
_documents.Add(updatedItem);
BsonValue objectId = null;
try
{
objectId = documentToUpdate.GetElement("_id").Value;
}
catch { }
return(new FakeUpdateResult(documentsToUpdate.Count(), objectId, 1));
}
return(new FakeUpdateResult(0));
}
public void WithTheDocumentsUpdatedSuccessfullyInMongoDb <TDocument>(
Mock <IMongoCollection <TDocument> > mongoCollection,
FilterDefinition <TDocument> filter,
UpdateDefinition <TDocument> update,
UpdateResult expectedResult)
{
var(docSerializer, serializer) = GetRendererForDocumentExpresion <TDocument>();
mongoCollection.Setup(_ =>
_.UpdateMany(It.Is <ExpressionFilterDefinition <TDocument> >(f =>
f.Render(docSerializer, serializer) == filter.Render(docSerializer, serializer)),
It.Is <UpdateDefinition <TDocument> >(u =>
u.Render(docSerializer, serializer) == update.Render(docSerializer, serializer)),
null,
CancellationToken.None))
.Returns(expectedResult);
}
private BsonDocument RenderUpdate <TDocument>(UpdateDefinition <TDocument> update)
{
var serializer = BsonSerializer.SerializerRegistry.GetSerializer <TDocument>();
return(update.Render(serializer, BsonSerializer.SerializerRegistry));
}
public static BsonDocument Render <TDocument>(this UpdateDefinition <TDocument> update)
{
return((BsonDocument)update.Render(
BsonSerializer.LookupSerializer <TDocument>(), BsonSerializer.SerializerRegistry));
}
private void PrintFilter(FilterDefinition <AirTravel> filter, UpdateDefinition <AirTravel> updateOperation)
{
Console.WriteLine(filter.Render(BsonSerializer.SerializerRegistry.GetSerializer <AirTravel>(), BsonSerializer.SerializerRegistry));
Console.WriteLine(updateOperation.Render(BsonSerializer.SerializerRegistry.GetSerializer <AirTravel>(), BsonSerializer.SerializerRegistry));
}
private BsonValue Render <TDocument>(UpdateDefinition <TDocument> update)
{
var documentSerializer = BsonSerializer.SerializerRegistry.GetSerializer <TDocument>();
return(update.Render(documentSerializer, BsonSerializer.SerializerRegistry));
}
public static string[] ObterDoUpdate <T>(UpdateDefinition <T> upd)
{
var bval = upd.Render(BsonSerializer.LookupSerializer <T>(), BsonSerializer.SerializerRegistry);
return(bval[0].AsBsonDocument.ToArray().Select(b => b.ToString()).ToArray());
}
/// <summary>
/// Renders the update to a MongoDB.Bson.BsonDocument.
/// </summary>
/// <param name="update"></param>
/// <returns></returns>
public BsonDocument Render(UpdateDefinition <TEntity> update)
{
var collection = GetCollection();
return((BsonDocument)update.Render(collection.DocumentSerializer, collection.Settings.SerializerRegistry));
}
