public void EntityProcessor_Property_Get_Method_Should_Set_and_Get_nullable_value_types()
{
DateTime dateValue = DateTime.Now;
DateTime verifyDate = DateTime.Now.AddDays(2);
long val = 8;
var accessor = new EntityAccessor(typeof(FakeEntityAccessor3));
accessor.Load(new DynamicEntityMap(typeof(FakeEntityAccessor3)));
FakeEntityAccessor3 fake = new FakeEntityAccessor3()
{
Prop = "Hello", Prop4 = 5
};
var nullableProp = accessor.Properties["Prop4"];
Assert.AreEqual(5, nullableProp.GetMethod(fake));
nullableProp.SetMethod(fake, val);
Assert.AreEqual(val, fake.Prop4);
//now let's handle null values
nullableProp.SetMethod(fake, null);
Assert.IsNull(fake.Prop4);
Assert.IsNull(nullableProp.GetMethod(fake));
}
public void Can_create_entity_wrapper()
{
var service = Substitute.For <IOrganizationService>();
var context = Substitute.For <ITransactionContextBase>();
context.Service.Returns(service);
var entity = new Entity("xts_nongenericentity")
{
Id = Guid.NewGuid()
};
var xtsEntity = new xts_entity {
Id = Guid.NewGuid()
};
InstanceEntityWrapper <Entity, TestWrapper> .Create(entity, context);
InstanceEntityWrapper <xts_entity, TestGenericWrapper <xts_entity> > .Create(xtsEntity, context);
InstanceEntityWrapper <xts_entity, EntityWrapper <xts_entity> > .Create(xtsEntity, context);
InstanceEntityWrapper <Entity, TestWrapper> .Create(xtsEntity, context);
var accessor = new EntityAccessor <Entity>(entity);
InstanceEntityWrapper <Entity, TestWrapper> .Create(accessor, context);
var xtsAccessor = new EntityAccessor <xts_entity>(xtsEntity);
InstanceEntityWrapper <xts_entity, TestGenericWrapper <xts_entity> > .Create(xtsAccessor, context);
InstanceEntityWrapper <xts_entity, EntityWrapper <xts_entity> > .Create(xtsAccessor, context);
InstanceEntityWrapper <Entity, TestWrapper> .Create(xtsAccessor, context);
}
QueryParam[] BuildParameterArray(StatementMap statement, QueryParam[] paramArray, IDictionary <string, object> inputObjects)
{
var dbParams = paramArray.ToDictionary(p => p.Name);
if ((inputObjects != null) && (inputObjects.Count > 0))
{
foreach (var inParam in statement.ParamPropertyMap.Values)
{
object paramObj;
if (inputObjects.TryGetValue(inParam.Property.VarName, out paramObj))
{
EntityAccessor getSetInfo = store.GetEntityAccessor(inParam.ClrType, inParam.Map);
PropertyAccessor pInfo;
if (getSetInfo.Properties.TryGetValue(inParam.Property.PropName, out pInfo))
{
QueryParam dbParam = new QueryParam(inParam.QueryParamName, null);
dbParam.Value = pInfo.GetMethod(paramObj);
if (!dbParams.ContainsKey(inParam.QueryParamName))
{
dbParams.Add(inParam.QueryParamName, dbParam);
}
}
}
}
}
return(dbParams.Values.ToArray());
}
internal void SerializeSingle(object instanceEntity, Type type, ComplexType complextType,
EntityAccessor entityAccessor, Dictionary <string, int> columns, DbDataReader dbReader)
{
var trackable = instanceEntity as ITrackable;
if (trackable != null)
{
//logger.Log(LogLevel.Debug, string.Format("Stopping and clearing Entity {0} change tracker.", type));
trackable.ChangeTracker.StopAndClear();
//logger.Log(LogLevel.Debug, "Initializing trackable entity change tracker.");
trackable.ChangeTracker.Init();
}
foreach (var keyVal in entityAccessor.Properties)
{
/* NOTE: Intentionally going only 1 level up the inheritance. something like :
* SuperSuperClass
* SuperClass
* Class
*
* SuperSuperClass if is a mapped entity its properties will be ignored. May be implement this later on.
* For now too ugly don't want to touch.
*/
var prop = complextType.GetProperty(keyVal.Key);
if (prop != null)
{
int ordinal;
if (columns.TryGetValue(prop.ColumnName, out ordinal))
{
var val = dbReader[ordinal];
var fieldType = dbReader.GetFieldType(ordinal);
if ((fieldType == keyVal.Value.PropertyType) && (val != DBNull.Value) && (val != null))
{
keyVal.Value.SetMethod(instanceEntity, val);
LoadInitialValueForInTracker(trackable, prop.PropertyName, val);
}
else if (keyVal.Value.PropertyType.IsEnum)
{
var enumVal = TypeConverterStore.ConvertToEnum(keyVal.Value.PropertyType, val);
keyVal.Value.SetMethod(instanceEntity, enumVal);
LoadInitialValueForInTracker(trackable, prop.PropertyName, enumVal);
}
else
{
var converter = TypeConverterStore.GetConverterFactoryMethod(keyVal.Value.PropertyType);
var convertedValue = converter.Invoke(val);
keyVal.Value.SetMethod(instanceEntity, convertedValue);
LoadInitialValueForInTracker(trackable, prop.PropertyName, convertedValue);
}
}
}
}
if (trackable != null)
{
trackable.ChangeTracker.Start();
trackable.Version = trackable.ChangeTracker.Version;
//logger.Log(LogLevel.Debug, string.Format("Restarted tracker -- version {0}.", trackable.Version));
}
}
public void EntityProcessor_Property_Get_Method_Should_Set_and_Get_value_types()
{
DateTime dateValue = DateTime.Now;
DateTime verifyDate = DateTime.Now.AddDays(2);
var accessor = new EntityAccessor(typeof(FakeEntityAccessor3));
accessor.Load(new DynamicEntityMap(typeof(FakeEntityAccessor3)));
FakeEntityAccessor3 fake = new FakeEntityAccessor3()
{
Prop = "Hello", Prop2 = dateValue, Prop3 = 5
};
var dateProp = accessor.Properties["Prop2"];
Assert.AreEqual(dateValue, dateProp.GetMethod(fake));
dateProp.SetMethod(fake, verifyDate);
Assert.AreEqual(verifyDate, fake.Prop2);
var intProp = accessor.Properties["Prop3"];
Assert.AreEqual(5, intProp.GetMethod(fake));
intProp.SetMethod(fake, 8);
Assert.AreEqual(8, fake.Prop3);
}
//This method below in case we want to implement eager loading.
private bool CheckAndRemoveDupes(EntityMap entityMap, EntityAccessor accessor, object entity,
Dictionary <object, object> resultStore)
{
if (entityMap.PrimaryKey != null)
{
var k = entityMap.PrimaryKey.Keys[0].Key;
PropertyAccessor propAccessor = accessor.GetPropertyAccessor(k.PropertyName);
var keyVal = propAccessor.GetMethod(entity);
object storedEntity;
if (resultStore.TryGetValue(keyVal, out storedEntity))
{
//we have duplicate due to eager-loaded relations
foreach (var rel in entityMap.Relations)
{
if (!rel.LazyLoad)
{
var rPropAccessor = accessor.GetPropertyAccessor(rel.PropertyName);
var collection = rPropAccessor.GetMethod(storedEntity);
var newCollection = rPropAccessor.GetMethod(entity);
rPropAccessor.PropertyType.GetMethod("AddRange").Invoke(collection, new[] { newCollection });
}
}
}
else
{
resultStore.Add(keyVal, entity);
}
return(true);
}
return(false);
}
/// <summary>
/// 创建或获取一个非泛型类型的 <see cref="EntityAccessor"/> 实体数据模型访问器对象，并指定其可操作的 实体数据模型类型。<br />
/// 该 实体数据模型访问器对象 在未更改 EntityType 属性的情况下仅可用于操作 指定的实体数据模型类型。<br />
/// 因实体数据模型访问器对象由 实体数据上下文 <see cref="DbContext"/> 创建，其 AutoDisposeContext 属性值为 false，表示不销毁其 DbContext 属性。
/// </summary>
/// <param name="_this">实体数据上下文对象。</param>
/// <param name="entityType">指定的实体数据模型类型。</param>
/// <returns>返回一个非泛型类型的 <see cref="EntityAccessor"/> 实体数据模型访问器对象。</returns>
public static EntityAccessor Accessor(this System.Data.Entity.DbContext _this, Type entityType)
{
EntityAccessor accessor = new EntityAccessor(_this, entityType);
accessor.AutoDisposeContext = false;
return(accessor);
}
public void Can_set_formatted_value_generic()
{
var entity = new xts_entity();
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.SetFormattedValue(e => e.xts_optionsetvalue, "formatted-value-4567");
Assert.Equal("formatted-value-4567", entity.FormattedValues["xts_optionsetvalue"]);
}
public void Should_Set_Entity_Node_Id()
{
var entity = new Entity();
EntityAccessor.SetNodeId(entity, 1);
Assert.AreEqual(1, entity.Id);
}
public void Should_Not_Set_Properties_If_Entity_Does_Not_Use_NodeIdAttribute()
{
var entity = new NonEntity();
EntityAccessor.SetNodeId(entity, 1);
Assert.AreEqual(0, entity.Id);
}
public void Can_set_formatted_value()
{
var entity = new xts_entity();
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.SetFormattedValue("xts_attribute", "formatted-value-1234");
Assert.Equal("formatted-value-1234", entity.FormattedValues["xts_attribute"]);
}
/// <summary>
/// 创建或获取一个泛型类型的 <see cref="EntityAccessor"/> 实体数据模型访问器对象，并指定其可操作的 实体数据模型类型。<br />
/// 该 实体数据模型访问器对象 仅可用于操作 指定的实体数据模型类型。<br />
/// 因实体数据模型访问器对象由 实体数据上下文 <see cref="DbContext"/> 创建，其 AutoDisposeContext 属性值为 false，表示不销毁其 DbContext 属性。
/// </summary>
/// <typeparam name="TEntity">指定的实体数据模型类型。</typeparam>
/// <param name="_this">实体数据上下文对象。</param>
/// <returns>返回一个泛型类型的 <see cref="EntityAccessor<TEntity>"/> 实体数据模型访问器对象。</returns>
public static EntityAccessor <TEntity> Accessor <TEntity>(this System.Data.Entity.DbContext _this)
where TEntity : class, new()
{
EntityAccessor <TEntity> accessor = new EntityAccessor <TEntity>(_this);
accessor.AutoDisposeContext = false;
return(accessor);
}
private void SetCleanContextState()
{
_context = new TestDbContext();
Accessor = new EntityAccessor(_context, TestUserInfo.Instance);
SetInitialData();
_context.SaveChanges();
}
public void Should_Return_Null_If_Entity_Does_Not_Use_NodeIdAttribute()
{
var entity = new NonEntity {
Id = 1
};
var id = EntityAccessor.GetNodeId(entity);
Assert.IsNull(id);
}
public void Should_Return_Entity_Node_Id_For_Nullable_Id()
{
var entity = new EntityWithNullableId {
Id = 1
};
var id = EntityAccessor.GetNodeId(entity);
Assert.AreEqual(1, id);
}
public void Can_set_option_set_value_using_int()
{
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_optionsetvalue, 12);
Assert.Equal(12, accessor.Get(e => e.xts_optionsetvalue).Value);
}
public void Can_set_money_using_decimal()
{
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_money, 1234);
Assert.Equal(1234m, accessor.Get(e => e.xts_money).Value);
}
public void Can_get_formatted_value_generic()
{
var entity = new xts_entity();
entity.FormattedValues["xts_optionsetvalue"] = "formatted-value-4567";
var accessor = new EntityAccessor <xts_entity>(entity);
Assert.Equal("formatted-value-4567", accessor.GetFormattedValue(e => e.xts_optionsetvalue));
Assert.Null(accessor.GetFormattedValue(e => e.xts_decimal));
}
public void Can_get_formatted_value()
{
var entity = new xts_entity();
entity.FormattedValues["xts_attribute"] = "formatted-value-1234";
var accessor = new EntityAccessor <xts_entity>(entity);
Assert.Equal("formatted-value-1234", accessor.GetFormattedValue("xts_attribute"));
Assert.Null(entity.GetFormattedValue("xts_notexist"));
}
public void Can_set_through_value_provider()
{
var valueProvider = Substitute.For <IValueProvider>();
valueProvider.GetValue().Returns("1234");
var entity = new Entity();
var accessor = new EntityAccessor <Entity>(entity);
accessor.Set("xts_attribute", valueProvider);
Assert.Equal("1234", entity.Get <string>("xts_attribute"));
}
public void Can_set_attribute_value()
{
var entity = new xts_entity
{
Id = Guid.NewGuid()
};
var accessor = new EntityAccessor <xts_entity>(entity);
var reference = new EntityReference("reference", Guid.NewGuid());
accessor.Set("xts_attribute", reference);
Assert.Equal(reference, entity["xts_attribute"]);
}
[Fact] // Assume ActivityParty
public void Can_set_entity_collection_using_single_entity_reference()
{
var entityReference = new EntityReference("equipment", Guid.NewGuid());
var entity = new xts_entity();
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_activityparties, entityReference);
var collection = accessor.Get(e => e.xts_activityparties);
var activityParty = collection.Entities[0].ToEntity <ActivityParty>();
Assert.Equal(entityReference, activityParty.Get(e => e.PartyId));
}
public void Can_get_aliased_value()
{
var entity = new Entity("lead")
{
Id = Guid.NewGuid(),
["aliased"] = new AliasedValue(null, null, new Money(1234m))
};
var accessor = new EntityAccessor <Entity>(entity);
Assert.Equal(1234m, accessor.GetAliasedValue <Money>("aliased").Value);
Assert.Null(accessor.GetAliasedValue <EntityReference>("not_exists"));
}
public void Can_get_attribute_value()
{
var entity = new xts_entity
{
Id = Guid.NewGuid()
};
var reference = new EntityReference("reference", Guid.NewGuid());
entity["xts_attribute"] = reference;
var accessor = new EntityAccessor <xts_entity>(entity);
Assert.Equal(reference, accessor.Get <EntityReference>("xts_attribute"));
}
public void Can_set_money_from_decimal_value_provider()
{
var decimalValueProvider = Substitute.For <IValueProvider <decimal> >();
decimalValueProvider.GetValue().Returns(1500m);
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_money, decimalValueProvider);
Assert.Equal(1500m, entity.Get(e => e.xts_money).Value);
}
public void Can_set_through_attribute_value_provider_generic()
{
var valueProvider = Substitute.For <IAttributeValueProvider <xts_entity, string> >();
valueProvider.GetValueFor(Arg.Any <Expression <Func <xts_entity, string> > >()).Returns("1234");
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_string, valueProvider);
Assert.Equal("1234", entity.Get(e => e.xts_string));
}
public void Can_set_through_value_provider_generic()
{
var valueProvider = Substitute.For <IValueProvider <string> >();
valueProvider.GetValue().Returns("1234");
var entity = new xts_entity {
Id = Guid.NewGuid()
};
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_string, valueProvider);
Assert.Equal("1234", entity.Get(e => e.xts_string));
}
[Fact] // Assume ActivityParty
public void Can_set_entity_collection_using_entity_references()
{
var equipmentReference = new EntityReference("equipment", Guid.NewGuid());
var leadReference = new EntityReference("lead", Guid.NewGuid());
var references = new[] { equipmentReference, leadReference };
var entity = new xts_entity();
var accessor = new EntityAccessor <xts_entity>(entity);
accessor.Set(e => e.xts_activityparties, references);
var collection = accessor.Get(e => e.xts_activityparties);
Assert.Equal(equipmentReference, collection.Entities[0].ToEntity <ActivityParty>().Get(e => e.PartyId));
Assert.Equal(leadReference, collection.Entities[1].ToEntity <ActivityParty>().Get(e => e.PartyId));
}
public void Can_use_equal_string_attribute_name()
{
var id = Guid.NewGuid();
var reference = new EntityReference("xts_reference", id);
var entity = new xts_entity {
Id = Guid.NewGuid()
};
entity.Set(e => e.xts_referenceid, reference);
var accessor = new EntityAccessor <xts_entity>(entity);
var comparisonValue = new EntityReference("xts_reference", id);
Assert.True(accessor.Equal("xts_referenceid", comparisonValue));
Assert.False(accessor.Equal("xts_referenceid", new EntityReference("xts_reference", Guid.NewGuid())));
}
public void Can_get_value_nullable_type()
{
var entity = new xts_entity();
var accessor = new EntityAccessor <xts_entity>(entity);
Assert.Equal(0, accessor.GetValue(e => e.xts_int));
Assert.Equal(111, accessor.GetValue(e => e.xts_int, 111));
entity.Set(e => e.xts_int, 123);
Assert.Equal(123, accessor.GetValue(e => e.xts_int));
Assert.Equal(123, accessor.GetValue(e => e.xts_int, 3333));
Assert.Equal(0m, accessor.GetValue(e => e.xts_decimal));
Assert.Equal(1000m, accessor.GetValue(e => e.xts_decimal, 1000m));
entity.Set(e => e.xts_decimal, 2300m);
Assert.Equal(2300m, accessor.GetValue(e => e.xts_decimal));
Assert.Equal(2300m, accessor.GetValue(e => e.xts_decimal, 4000m));
}
