/// <summary>
/// Converts object value from public to internal format.
/// </summary>
/// <param name="value">an object in public format to convert</param>
/// <returns>converted object in internal format</returns>
protected virtual AnyValueMap ConvertFromPublic(T value)
{
var json = JsonConverter.ToJson(value);
var map = new AnyValueMap(MapConverter.ToMap(JsonConverter.FromJson(json)));
return(map);
}
public async Task TestModifyNestedCollection()
{
// arrange
var dummy = await _persistence.CreateAsync(null, _dummy1);
var innerInnerDummies = new List <InnerDummy>()
{
new InnerDummy()
{
Id = "Test Inner Id #1",
Name = "Test Inner Dummy #1"
},
new InnerDummy()
{
Id = "Test Inner Id #2",
Name = "Test Inner Dummy #2"
},
};
var updateMap = new AnyValueMap()
{
{ "inner_dummy.inner_inner_dummies", innerInnerDummies }
};
// act - It's important to pass the type of updated object!
var result = await _persistence.ModifyByIdAsync(null, dummy.Id, ComposeUpdate <List <InnerDummy> >(updateMap));
// assert 1
Assert.NotNull(result);
Assert.Equal(innerInnerDummies[0].Id, result.InnerDummy.InnerInnerDummies[0].Id);
Assert.Equal(innerInnerDummies[0].Name, result.InnerDummy.InnerInnerDummies[0].Name);
Assert.Equal(innerInnerDummies[1].Id, result.InnerDummy.InnerInnerDummies[1].Id);
Assert.Equal(innerInnerDummies[1].Name, result.InnerDummy.InnerInnerDummies[1].Name);
}
/// <summary>
/// Updates only few selected fields in a data item.
/// </summary>
/// <param name="correlation_id">(optional) transaction id to trace execution through call chain.</param>
/// <param name="id">an id of data item to be updated.</param>
/// <param name="data">a map with fields to be updated.</param>
/// <returns>updated item.</returns>
public async Task <T> UpdatePartiallyAsync(string correlationId, K id, AnyValueMap data)
{
_lock.EnterWriteLock();
object item;
try
{
var index = _items.FindIndex(x => x.Id.Equals(id));
if (index < 0)
{
return(default(T));
}
item = _items[index];
var properties = ObjectReader.GetProperties(data.GetAsObject());
ObjectWriter.SetProperties(item, properties);
_items[index] = (T)item;
_logger.Trace(correlationId, "Partially updated item {0}", id);
}
finally
{
_lock.ExitWriteLock();
}
await SaveAsync(correlationId);
return((T)item);
}
/// <summary>
/// Converts object value from internal to public format.
/// </summary>
/// <param name="map">an object in internal format to convert</param>
/// <returns>converted object in public format</returns>
protected virtual T ConvertToPublic(AnyValueMap map)
{
var json = JsonConverter.ToJson(map);
T obj = JsonConverter.FromJson <T>(json);
return(obj);
}
/// <summary>
/// Converts object value from internal to public format.
/// </summary>
/// <param name="value">an object in internal format to convert.</param>
/// <returns>converted object in public format.</returns>
protected override T ConvertToPublic(AnyValueMap map)
{
if (map != null && map.TryGetValue("data", out object value) && value != null)
{
return(base.ConvertToPublic(value as AnyValueMap));
}
return(default);
public RestOperationParameters GetAsNullableParameters(string key)
{
AnyValueMap asNullableMap = this.GetAsNullableMap(key);
if (asNullableMap == null)
{
return((RestOperationParameters)null);
}
return(new RestOperationParameters((IDictionary)asNullableMap));
}
private static LogMessageV1 ExtractLogMessage(AnyValueMap map)
{
var time = map.GetAsDateTimeWithDefault("time", DateTime.UtcNow);
var level = map.GetAsEnum <LogLevel>("level");
var source = map.GetAsStringWithDefault("source", string.Empty);
var correlationId = map.GetAsStringWithDefault("correlation_id", string.Empty);
var error = ExtractError(map.GetAsMap("error"));
var message = map.GetAsStringWithDefault("message", string.Empty);
return(new LogMessageV1(time, level, source, correlationId, error, message));
}
public virtual async Task <T> ModifyAsync(string correlationId, string id, AnyValueMap updateMap)
{
updateMap = updateMap ?? new AnyValueMap();
var order = await GetByIdAsync(correlationId, id);
foreach (var propertyName in updateMap.Keys)
{
ModifyObjectFields(order, propertyName, updateMap[propertyName]);
}
return(order);
}
private LogMessageV1[] ExtractLogMessages(Parameters args)
{
var result = new List <LogMessageV1>();
foreach (var parameters in args.GetAsParameters("messages").Values)
{
var message = ExtractLogMessage(AnyValueMap.FromValue(parameters));
result.Add(message);
}
return(result.ToArray());
}
public async Task TestCrudOperationsAsync()
{
// Create one dummy
var dummy1 = await _persistence.CreateAsync(null, _dummy1);
Assert.NotNull(dummy1);
Assert.NotNull(dummy1.Id);
Assert.Equal(_dummy1.Key, dummy1.Key);
Assert.Equal(_dummy1.Content, dummy1.Content);
// Create another dummy
var dummy2 = await _persistence.CreateAsync(null, _dummy2);
Assert.NotNull(dummy2);
Assert.NotNull(dummy2.Id);
Assert.Equal(_dummy2.Key, dummy2.Key);
Assert.Equal(_dummy2.Content, dummy2.Content);
//// Get all dummies
//var dummies = await _get.GetAllAsync(null);
//Assert.NotNull(dummies);
//Assert.Equal(2, dummies.Count());
// Update the dummy
dummy1.Content = "Updated Content 1";
var dummy = await _persistence.UpdateAsync(null, dummy1);
Assert.NotNull(dummy);
Assert.Equal(dummy1.Id, dummy.Id);
Assert.Equal(dummy1.Key, dummy.Key);
Assert.Equal(dummy1.Content, dummy.Content);
// Update partially the dummy
dummy = await _persistence.UpdatePartiallyAsync(null, dummy1.Id, AnyValueMap.FromTuples(
"content", "Partially Updated Content 1"
));
Assert.NotNull(dummy);
Assert.Equal(dummy1.Id, dummy.Id);
Assert.Equal(dummy1.Key, dummy.Key);
Assert.Equal("Partially Updated Content 1", dummy.Content);
// Delete the dummy
await _persistence.DeleteByIdAsync(null, dummy1.Id);
// Try to get deleted dummy
dummy = await _persistence.GetOneByIdAsync(null, dummy1.Id);
Assert.Null(dummy);
}
protected virtual UpdateDefinition <T> ComposeUpdate(AnyValueMap updateMap)
{
updateMap = updateMap ?? new AnyValueMap();
var builder = Builders <T> .Update;
var updateDefinitions = new List <UpdateDefinition <T> >();
foreach (var key in updateMap.Keys)
{
updateDefinitions.Add(builder.Set(key, updateMap[key]));
}
return(builder.Combine(updateDefinitions));
}
public void TestGetAsString()
{
var message = AnyValueMap.FromTuples(
"key1", 123,
"key2", "ABC"
);
var restoredMessageObject = JsonConverter.FromJson <object>(JsonConverter.ToJson(message));
var restoredMessage = AnyValueMap.FromValue(restoredMessageObject);
Assert.Equal(2, restoredMessage.Count);
Assert.Equal(123, restoredMessage.GetAsInteger("key1"));
Assert.Equal("ABC", restoredMessage.GetAsString("key2"));
}
private UpdateDefinition <Dummy> ComposeUpdate <T>(AnyValueMap updateMap)
where T : class
{
updateMap = updateMap ?? new AnyValueMap();
var builder = Builders <Dummy> .Update;
var updateDefinitions = new List <UpdateDefinition <Dummy> >();
foreach (var key in updateMap.Keys)
{
updateDefinitions.Add(builder.Set(key, (T)updateMap[key]));
}
return(builder.Combine(updateDefinitions));
}
public void TestSetMapProperty()
{
AnyValueMap map = AnyValueMap.FromTuples(
"key1", 123,
"key2", "ABC"
);
ObjectWriter.SetProperty(map, "key3", "AAAA");
Assert.Equal("AAAA", map.Get("key3"));
ObjectWriter.SetProperty(map, "Key1", 5555);
Assert.Equal(5555, map.Get("Key1"));
ObjectWriter.SetProperty(map, "Key2", "BBBB");
Assert.Equal("BBBB", map.Get("Key2"));
}
private static ErrorDescription ExtractError(AnyValueMap map)
{
if (map.Count == 0)
{
return(null);
}
var code = map.GetAsStringWithDefault("code", string.Empty);
var message = map.GetAsStringWithDefault("message", string.Empty);
var stack_trace = map.GetAsStringWithDefault("stack_trace", string.Empty);
return(new ErrorDescription()
{
Code = code,
Message = message,
StackTrace = stack_trace
});
}
public void TestGetMapProperties()
{
AnyValueMap map = AnyValueMap.FromTuples(
"key1", 123,
"key2", "ABC"
);
var names = ObjectReader.GetPropertyNames(map);
Assert.Equal(2, names.Count);
Assert.Contains("key1", names);
Assert.Contains("key2", names);
var values = ObjectReader.GetProperties(map);
Assert.Equal(2, values.Count);
Assert.Equal(123, values["key1"]);
Assert.Equal("ABC", values["key2"]);
}
public void TestGetMapProperty()
{
var map = AnyValueMap.FromTuples(
"key1", 123,
"key2", "ABC"
);
var key3Value = ObjectReader.GetProperty(map, "key3");
Assert.Null(key3Value);
var key1Value = ObjectReader.GetProperty(map, "Key1");
Assert.Equal(123, key1Value);
var key2Value = ObjectReader.GetProperty(map, "KEY2");
Assert.Equal("ABC", key2Value);
}
public async Task TestModifyExistingPropertiesBySelectedFields()
{
// arrange
var dummy = await _persistence.CreateAsync(null, _dummy1);
var updateMap = new AnyValueMap()
{
{ "Content", "Modified Content" },
{ "InnerDummy.Description", "Modified InnerDummy Description" }
};
// act
var result = await _persistence.ModifyByIdAsync(null, dummy.Id, ComposeUpdate(updateMap));
// assert
Assert.NotNull(result);
Assert.Equal(dummy.Id, result.Id);
Assert.Equal("Modified Content", result.Content);
Assert.Equal("Modified InnerDummy Description", result.InnerDummy.Description);
}
public void TestConfigFromObject()
{
var value = AnyValueMap.FromTuples(
"field1", ConfigParams.FromString("field11=123;field12=ABC"),
"field2", AnyValueArray.FromValues(
123, "ABC", ConfigParams.FromString("field21=543;field22=XYZ")
),
"field3", true
);
var config = ConfigParams.FromValue(value);
Assert.Equal(7, config.Count);
Assert.Equal(123, config.GetAsInteger("field1.field11"));
Assert.Equal("ABC", config.GetAsString("field1.field12"));
Assert.Equal(123, config.GetAsInteger("field2.0"));
Assert.Equal("ABC", config.GetAsString("field2.1"));
Assert.Equal(543, config.GetAsInteger("field2.2.field21"));
Assert.Equal("XYZ", config.GetAsString("field2.2.field22"));
Assert.Equal(true, config.GetAsBoolean("field3"));
}
public async Task TestMultiThreadOperationsAsync(int i)
{
var dummy = new Dummy
{
Id = null,
Key = $"Key {i}",
Content = "Content 1",
CreateTimeUtc = DateTime.UtcNow,
SubDummy = new SubDummy {
Type = "some type", ArrayOfDouble = new double[] { 10, 10 }
}
};
// Create one dummy
var dummy1 = await _persistence.CreateAsync(null, dummy);
Assert.NotNull(dummy1);
Assert.NotNull(dummy1.SubDummy);
Assert.Equal(dummy.Key, dummy1.Key);
Assert.Equal(dummy.Content, dummy1.Content);
Assert.Equal(dummy.CreateTimeUtc, dummy1.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(dummy.SubDummy.Type, dummy1.SubDummy.Type);
Assert.Equal(dummy.SubDummy.ArrayOfDouble, dummy1.SubDummy.ArrayOfDouble);
// Update the dummy
dummy1.Content = "Updated Content 1";
var result = await _persistence.UpdateAsync(null, dummy1);
Assert.NotNull(result);
Assert.NotNull(result.SubDummy);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
Assert.Equal(dummy1.Content, result.Content);
Assert.Equal(dummy1.CreateTimeUtc, result.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(dummy1.SubDummy.Type, result.SubDummy.Type);
Assert.Equal(dummy1.SubDummy.ArrayOfDouble, result.SubDummy.ArrayOfDouble);
// Set the dummy
dummy1.Content = "Updated Content 2";
result = await _persistence.SetAsync(null, dummy1);
Assert.NotNull(result);
Assert.NotNull(result.SubDummy);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
Assert.Equal(dummy1.Content, result.Content);
Assert.Equal(dummy1.CreateTimeUtc, result.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(dummy1.SubDummy.Type, result.SubDummy.Type);
Assert.Equal(dummy1.SubDummy.ArrayOfDouble, result.SubDummy.ArrayOfDouble);
// Partially update the dummy
result = await _persistence.UpdatePartially(null, dummy1.Id,
AnyValueMap.FromTuples("content", "Partially Updated Content 1"));
Assert.NotNull(result);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
Assert.Equal("Partially Updated Content 1", result.Content);
// Get the dummy by Id
result = await _persistence.GetOneByIdAsync(null, dummy1.Id);
Assert.NotNull(result);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
// Delete the dummy
result = await _persistence.DeleteByIdAsync(null, dummy1.Id);
Assert.NotNull(result);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
// Get the deleted dummy
result = await _persistence.GetOneByIdAsync(null, dummy1.Id);
Assert.Null(result);
}
/// <summary>
/// Creates a new Parameters object filled with provided key-value pairs called
/// tuples.Tuples parameters contain a sequence of key1, value1, key2, value2, ... pairs.
/// </summary>
/// <param name="tuples">the tuples to fill a new Parameters object.</param>
/// <returns>a new Parameters object.</returns>
/// See <see cref="AnyValueMap.FromTuples(object[])"/>
public new static Parameters FromTuples(params object[] tuples)
{
return(new Parameters(AnyValueMap.FromTuples(tuples)));
}
public async Task TestCrudOperationsAsync()
{
// Create one dummy
var dummy1 = await _persistence.CreateAsync(null, _dummy1);
Assert.NotNull(dummy1);
Assert.NotNull(dummy1.SubDummy);
Assert.Equal(_dummy1.Key, dummy1.Key);
Assert.Equal(_dummy1.Content, dummy1.Content);
Assert.Equal(_dummy1.CreateTimeUtc, dummy1.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(_dummy1.SubDummy.Type, dummy1.SubDummy.Type);
Assert.Equal(_dummy1.SubDummy.ArrayOfDouble, dummy1.SubDummy.ArrayOfDouble);
// Create another dummy
var dummy2 = await _persistence.CreateAsync(null, _dummy2);
Assert.NotNull(dummy2);
Assert.NotNull(dummy2.SubDummy);
Assert.Equal(_dummy2.Key, dummy2.Key);
Assert.Equal(_dummy2.Content, dummy2.Content);
Assert.Equal(_dummy2.CreateTimeUtc, dummy2.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(_dummy2.SubDummy.Type, dummy2.SubDummy.Type);
Assert.Equal(_dummy2.SubDummy.ArrayOfDouble, dummy2.SubDummy.ArrayOfDouble);
var page = await _persistence.GetPageByFilterAsync(null, null, null);
Assert.NotNull(page);
Assert.Equal(2, page.Data.Count);
page = await _persistence.GetPageByFilterAsync(null, FilterParams.FromTuples("key", _dummy2.Key), null);
Assert.NotNull(page);
Assert.Single(page.Data);
// Update the dummy
dummy1.Content = "Updated Content 1";
var result = await _persistence.UpdateAsync(null, dummy1);
Assert.NotNull(result);
Assert.NotNull(result.SubDummy);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
Assert.Equal(dummy1.Content, result.Content);
Assert.Equal(dummy1.CreateTimeUtc, result.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(dummy1.SubDummy.Type, result.SubDummy.Type);
Assert.Equal(dummy1.SubDummy.ArrayOfDouble, result.SubDummy.ArrayOfDouble);
// Set the dummy
dummy1.Content = "Updated Content 2";
result = await _persistence.SetAsync(null, dummy1);
Assert.NotNull(result);
Assert.NotNull(result.SubDummy);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
Assert.Equal(dummy1.Content, result.Content);
Assert.Equal(dummy1.CreateTimeUtc, result.CreateTimeUtc, TimeSpan.FromMilliseconds(1000));
Assert.Equal(dummy1.SubDummy.Type, result.SubDummy.Type);
Assert.Equal(dummy1.SubDummy.ArrayOfDouble, result.SubDummy.ArrayOfDouble);
// Partially update the dummy
result = await _persistence.UpdatePartially(null, dummy1.Id,
AnyValueMap.FromTuples("content", "Partially Updated Content 1"));
Assert.NotNull(result);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
Assert.Equal("Partially Updated Content 1", result.Content);
// Get the dummy by Id
result = await _persistence.GetOneByIdAsync(null, dummy1.Id);
Assert.NotNull(result);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
// Delete the dummy
result = await _persistence.DeleteByIdAsync(null, dummy1.Id);
Assert.NotNull(result);
Assert.Equal(dummy1.Id, result.Id);
Assert.Equal(dummy1.Key, result.Key);
// Get the deleted dummy
result = await _persistence.GetOneByIdAsync(null, dummy1.Id);
Assert.Null(result);
var count = await _persistence.GetCountByFilterAsync(null, null);
Assert.Equal(1, count);
}
private UpdateDefinition <Dummy> ComposeUpdate(AnyValueMap updateMap)
{
return(ComposeUpdate <object>(updateMap));
}
/// <summary>
/// Generates a list of column names to use in SQL statements like: "column1,column2,column3"
/// </summary>
/// <param name="map">key-value map</param>
/// <returns>a generated list of column names</returns>
protected string GenerateColumns(AnyValueMap map)
{
return(GenerateColumns(map.Keys.ToList()));
}
/// <summary>
/// Generates a list of column sets to use in UPDATE statements like: column1=@Param1,column2=@Param2
/// </summary>
/// <param name="map">a key-value map with columns and values</param>
/// <returns></returns>
protected string GenerateSetParameters(AnyValueMap map)
{
return(GenerateSetParameters(map.Keys.ToList()));
}
/// <summary>
/// Generates a list of column parameters
/// </summary>
/// <param name="map">a key-value map with columns and values</param>
/// <returns>generated list of column values</returns>
protected List <object> GenerateValues(AnyValueMap map)
{
return(map.Values.ToList());
}
public static RestOperationParameters MergeParams(params RestOperationParameters[] parameters)
{
return(new RestOperationParameters((IDictionary)AnyValueMap.FromMaps((IDictionary[])parameters)));
}
public static new RestOperationParameters FromTuples(params object[] tuples)
{
return(new RestOperationParameters((IDictionary)AnyValueMap.FromTuples(tuples)));
}
public async Task <Dummy> ModifyAsync(string correlationId, string id, AnyValueMap updateMap)
{
return(await ModifyByIdAsync(correlationId, id, ComposeUpdate(updateMap)));
}
/// <summary>
/// Updates only few selected fields in a data item.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
/// <param name="id">an id of data item to be updated.</param>
/// <param name="data">a map with fields to be updated.</param>
/// <returns>the updated item.</returns>
public virtual async Task <T> UpdatePartiallyAsync(string correlationId, K id, AnyValueMap data)
{
if (id == null)
{
return(default(T));
}
var options = new FindOneAndUpdateOptions <T>
{
ReturnDocument = ReturnDocument.After,
IsUpsert = false
};
var builder = Builders <T> .Filter;
var filter = builder.Eq(x => x.Id, id);
var update = ComposeUpdate(data);
var result = await _collection.FindOneAndUpdateAsync(filter, update, options);
if (result != null)
{
_logger.Trace(correlationId, "Updated partially in {0} with id = {1}", _collectionName, id);
}
return(result);
}
