public void TransformedType_RequiredProperties_ReturnsRequiredProperties()
{
var mapper = new TypeMapper(new CritterPomonaConfiguration());
var type = mapper.FromType(typeof(Planet));
var requiredProperties = type.RequiredProperties.ToList();
Assert.That(requiredProperties.All(x => x.IsRequiredForConstructor), Is.True);
}
public void MapEntityType_should_not_map_invalid_structural_type()
{
var model = new EdmModel().Initialize();
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
Assert.Null(typeMapper.MapEntityType(typeof(string)));
}
/// <summary>
/// 获取指定类型映射器的属性集合。
/// </summary>
/// <param name="mapper">类型映射器。</param>
/// <param name="entity">类型映射器关联的对象实例，并将 <paramref name="entity"/> 转换成映射器的类型 。</param>
/// <returns>映射属性的集合枚举。</returns>
protected virtual IEnumerable<PropertyMapper> FindProperties(TypeMapper mapper, ref object entity)
{
IEnumerable<PropertyMapper> pms = mapper.Properties;
var entityType = entity.GetType();
if(entityType.IsAssignableFrom(mapper.Type)) return pms;
var mapper2 = TypeMapper.Create(entityType);
var query = from op in pms
join np in mapper2.Properties on op.Property.Name.ToLower() equals np.Name.ToLower()
select new { op, np };
var entity2 = Activator.CreateInstance(mapper.Type, true);
List<PropertyMapper> pms2 = new List<PropertyMapper>();
foreach(var item in query)
{
pms2.Add(item.op);
var value = item.np.GetValue(entity);
if(!item.op.Property.PropertyType.IsAssignableFrom(item.np.Property.PropertyType))
{
value = Convert.ChangeType(value, item.op.Property.PropertyType);
}
item.op.SetValue(entity2, value);
}
entity = entity2;
return pms2;
}
public void FromType_QueryResult_ReturnsQueryResultType()
{
this.typeMapper = new TypeMapper(new SimplePomonaConfiguration());
var type = TypeMapper.FromType(typeof(QueryResult<Critter>));
Assert.That(type, Is.InstanceOf<QueryResultType>());
Assert.That(type, Is.InstanceOf<QueryResultType<Critter>>());
}
public void Setup()
{
var fakeRepository = MockRepository.GenerateStub<IMapperRepository>();
_mapper = new TypeMapper(fakeRepository);
_dummyA = new DummyA { Name = "dummy A", Family = "family A", Age = 37 };
_dummyB = new DummyB { Name = "dummy A", Family = "family A", Age = 37 };
_dummyC = new DummyC { Name = "dummy A", Family = "family A", Address = null };
}
public void Start()
{
var bootstrapper = new CritterBootstrapper();
Repository = bootstrapper.Repository;
TypeMapper = bootstrapper.TypeMapper;
Host = new NancyHost(BaseUri, bootstrapper);
Host.Start();
}
public void Start()
{
var bootstrapper = new CritterBootstrapper();
this.Repository = bootstrapper.Repository;
this.TypeMapper = bootstrapper.TypeMapper;
host = new NancyHost(baseUri, bootstrapper);
host.Start();
}
public void GetUriFor_WithEntityWithSpaceInPath_EncodesUrlTheRightWay()
{
var typeMapper = new TypeMapper(new CritterPomonaConfiguration());
var uriResolver = new UriResolver(typeMapper,
new DummyBaseUriProvider() { BaseUri = new Uri("http://whateva/") });
var galaxy = new Galaxy() { Name = "this is it" };
var url = uriResolver.GetUriFor(galaxy);
Assert.That(url, Is.EqualTo("http://whateva/galaxies/this%20is%20it"));
}
public void CanMapEnumerableIntegerTypes(Type collectionType)
{
var mapper = new TypeMapper();
var param = mapper.Register(collectionType);
Assert.AreEqual("array", param.Type);
Assert.AreEqual("integer", param.Items.Type);
Assert.IsEmpty(mapper.Models);
}
public void MapComplexType_should_not_map_ignored_type()
{
var model = new EdmModel(DataSpace.CSpace);
var mockModelConfiguration = new Mock<ModelConfiguration>();
var typeMapper = new TypeMapper(new MappingContext(mockModelConfiguration.Object, new ConventionsConfiguration(), model));
mockModelConfiguration.Setup(m => m.IsIgnoredType(typeof(AType1))).Returns(true);
var complexType = typeMapper.MapComplexType(typeof(AType1));
Assert.Null(complexType);
}
public void CanMapSimpleNullableTypes(Type type, string expectedParamType, string expectedFormat = "")
{
var mapper = new TypeMapper();
var inputParam = new InputParameter { Type = type };
var param = mapper.Map(inputParam);
Assert.AreEqual(expectedParamType, param.type);
Assert.AreEqual(expectedFormat, param.format);
Assert.IsEmpty(mapper.Models);
}
public Factory ToFactory(IEnumerable<Column> columns, TypeMapper typeMapper)
{
if (columns.Count() != _attributes.Count())
{
throw new InvalidOperationException("Did not get equal number of Columns and Attributes");
}
var readers = columns.Zip<Column, Attribute, Func<object[], object>>(_attributes, (column, attribute) => {
var mapper = typeMapper.MappingFor(column, attribute);
return (row) => mapper(column.Read(row));
});
return new Factory(_info, readers.ToArray());
}
public ClientLibGenerator(TypeMapper typeMapper)
{
if (typeMapper == null)
throw new ArgumentNullException("typeMapper");
this.typeMapper = typeMapper;
this.allowedReferencedAssemblies = new[]
{
/*mscorlib*/typeof(string).Assembly, typeof(IPomonaClient).Assembly, /*System.Core*/
typeof(Func<>).Assembly, /*System*/ typeof(Uri).Assembly
};
PomonaClientEmbeddingEnabled = true;
}
public void MapEntityType_should_not_map_ignored_type()
{
var model = new EdmModel().Initialize();
var mockModelConfiguration = new Mock<ModelConfiguration>();
var typeMapper = new TypeMapper(new MappingContext(mockModelConfiguration.Object, new ConventionsConfiguration(), model));
var mockType = new MockType("Foo");
mockModelConfiguration.Setup(m => m.IsIgnoredType(mockType)).Returns(true);
var entityType = typeMapper.MapEntityType(mockType);
Assert.Null(entityType);
}
public HandlerMethod(MethodInfo methodInfo, TypeMapper typeMapper)
{
if (methodInfo == null)
throw new ArgumentNullException(nameof(methodInfo));
if (typeMapper == null)
throw new ArgumentNullException(nameof(typeMapper));
MethodInfo = methodInfo;
TypeMapper = typeMapper;
this.parameters =
new Lazy<IList<HandlerParameter>>(
() => methodInfo.GetParameters().Select(x => new HandlerParameter(x, this)).ToList());
this.parameterTypes = new Lazy<IList<Type>>(() => Parameters.MapList(x => x.Type));
}
public void MapEntityType_should_not_bring_in_base_class_by_default()
{
var model = new EdmModel(DataSpace.CSpace);
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
var entityType = typeMapper.MapEntityType(typeof(AType3));
Assert.NotNull(entityType);
Assert.Null(entityType.BaseType);
Assert.Equal(1, model.EntityTypes.Count());
Assert.Equal(1, model.Containers.Single().EntitySets.Count);
Assert.Equal("AType3", model.GetEntitySet(entityType).Name);
}
public void HandlesCircularReferences__ObjectReferencesSelfDirectly()
{
var n = new LinkedListNode { Id = 13 };
n.Next = n;
n.Previous = n;
var tm = new TypeMapper();
var clone = tm.DeepClone<LinkedListNode>(n);
Assert.AreEqual(13, clone.Id);
Assert.AreSame(n, n.Next);
Assert.AreSame(n, n.Previous);
}
public void MapEntityType_should_not_bring_in_base_class_by_default()
{
var model = new EdmModel().Initialize();
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
var mockType = new MockType("Bar").BaseType(new MockType("Foo"));
var entityType = typeMapper.MapEntityType(mockType);
Assert.NotNull(entityType);
Assert.Null(entityType.BaseType);
Assert.Equal(1, model.Namespaces.Single().EntityTypes.Count);
Assert.Equal(1, model.Containers.Single().EntitySets.Count);
Assert.Equal("Bar", model.GetEntitySet(entityType).Name);
}
public void MapEntityType_should_bring_in_derived_types_from_the_same_assembly()
{
var model = new EdmModel(DataSpace.CSpace);
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
var mockType1 = new MockType("Foo");
var mockType2 = new MockType("Bar").BaseType(mockType1);
new MockAssembly(mockType1, mockType2);
typeMapper.MapEntityType(mockType1);
Assert.Equal(2, model.EntityTypes.Count());
Assert.Equal(1, model.Containers.Single().EntitySets.Count);
}
public void CanCloneAnObject()
{
var st = new SimpleType();
st.EnumProperty = DayOfWeek.Friday;
st.IntegerProperty = 13;
st.StringProperty = "some string";
var tm = new TypeMapper();
var clone = tm.DeepClone<SimpleType>(st);
Assert.AreEqual(st.EnumProperty, clone.EnumProperty);
Assert.AreEqual(st.IntegerProperty, clone.IntegerProperty);
Assert.AreEqual(st.StringProperty, clone.StringProperty);
}
public DataSourceRootRoute(TypeMapper typeMapper, Type dataSource)
: base(0, null)
{
if (typeMapper == null)
throw new ArgumentNullException(nameof(typeMapper));
var dataSourceInterface = typeof(IPomonaDataSource);
dataSource = dataSource ?? dataSourceInterface;
if (!dataSourceInterface.IsAssignableFrom(dataSource))
{
throw new ArgumentException($"dataSourceType must be castable to {dataSourceInterface.FullName}");
}
TypeMapper = typeMapper;
DataSource = dataSource;
}
public void Bug001__MapToInterfaceProperty()
{
var c1 = new Bug001_Class();
c1.Id = 1;
c1.Property = new Bug001_Class();
c1.Property.Id = 2;
var tm = new TypeMapper();
var clone = tm.DeepClone(c1);
Assert.IsNotNull(clone);
Assert.AreEqual(clone.Id, c1.Id);
Assert.AreEqual(clone.Property.Id, c1.Property.Id);
Assert.IsNull(clone.Property.Property);
}
public void Bug002__MapToInterfaceProperty_WhereTargetInterfaceIsDifferentThanSourceType()
{
var c1 = new Bug002_Class_One();
c1.Id = 1;
c1.Property = new Bug002_Class_One();
c1.Property.Id = 2;
var tm = new TypeMapper();
var clone = tm.Map<Bug002_Class_Two>(c1);
Assert.IsNotNull(clone);
Assert.AreEqual(clone.Id, c1.Id);
Assert.AreEqual(clone.Property.Id, c1.Property.Id);
Assert.IsNull(clone.Property.Property);
}
/// <summary>
/// 指定属性元数据，初始化一个 <see cref="PropertyMapper"/> 类的新实例。
/// </summary>
/// <param name="typeMapper">类型的映射器。</param>
/// <param name="property">成员的属性元数据。</param>
public PropertyMapper(TypeMapper typeMapper, PropertyInfo property)
: base(property)
{
if(typeMapper == null) throw new ArgumentNullException(nameof(typeMapper));
this.TypeMapper = typeMapper;
this.IsIgnore = property.GetAttribute<IgnoreAttribute>() != null;
this._LazyTypeDefaultValue = new Lazy<object>(property.PropertyType.GetDefaultValue);
var aliasAttr = property.GetAttribute<IAliasAttribute>();
this.Name = aliasAttr != null && aliasAttr.Name != null
? aliasAttr.Name
: property.Name;
var keyAttr = property.GetAttribute<IKeyAttribute>();
this.IsKey = keyAttr != null && keyAttr.IsKey;
}
public void DestinationCollectionHasSameNumberOfItemsAsSource()
{
TypeMapper<T1, T2> mapper = new TypeMapper<T1, T2>();
CollectionMapper<T1, int, T2, int> collectionMapper =
new CollectionMapper<T1, int, T2, int>(
mapper,
t => t.IntCollection, () => new List<int>(), null,
t => t.IntCollection, () => new List<int>(), null);
T1 t1 = new T1() { IntCollection = new[] { 1, 2, 3 } };
T2 t2 = mapper.Forward().Map(t1);
T1 t3 = mapper.Reverse().Map(t2);
Assert.AreEqual(t1.IntCollection.Count, t2.IntCollection.Count);
Assert.AreEqual(t1.IntCollection.Count, t1.IntCollection.Count);
}
public void Setup()
{
var fakeRepository = MockRepository.GenerateStub<IMapperRepository>();
_mapper = new TypeMapper(fakeRepository);
_listDummyA = new List<DummyA>
{
new DummyA
{
Name = "A",
Family = "A Family",
Age = 1
},
new DummyA
{
Name = "A_A",
Family = "A_A Family",
Age = 10
},new DummyA
{
Name = "A_1",
Family = "A_1 Family",
Age = 15
}
};
_listDummyB = new List<DummyB>
{
new DummyB
{
Name = "A",
Family = "A Family",
Age = 1
},
new DummyB
{
Name = "A_A",
Family = "A_A Family",
Age = 10
},new DummyB
{
Name = "A_1",
Family = "A_1 Family",
Age = 15
}
};
}
public void ConvertedPrimitiveDestinationCollectionHasEquivalentItemsAsSource()
{
TypeMapper<T1, T2> mapper = new TypeMapper<T1, T2>();
CollectionMapper<T1, int, T2, long> collectionMapper =
new CollectionMapper<T1, int, T2, long>(
mapper,
t => t.IntCollection, () => new List<int>(), null,
t => t.LongCollection, () => new List<long>(), null);
T1 t1 = new T1() { IntCollection = new[] { 1, 2, 3 } };
T2 t2 = mapper.Forward().Map(t1);
T1 t3 = mapper.Reverse().Map(t2);
Assert.IsTrue(t1.IntCollection.All(i => t2.LongCollection.Any(l => i == l)));
Assert.IsTrue(t2.LongCollection.All(i => t3.IntCollection.Any(l => i == l)));
}
public void PrimitiveDestinationCollectionHasSameItemsAsSource()
{
TypeMapper<T1, T2> mapper = new TypeMapper<T1, T2>();
CollectionMapper<T1, int, T2, int> collectionMapper =
new CollectionMapper<T1, int, T2, int>(
mapper,
t => t.IntCollection, () => new List<int>(), null,
t => t.IntCollection, () => new List<int>(), null);
T1 t1 = new T1() { IntCollection = new[] { 1, 2, 3 } };
T2 t2 = mapper.Forward().Map(t1);
T1 t3 = mapper.Reverse().Map(t2);
Assert.IsFalse(t1.IntCollection.Except(t2.IntCollection).Any());
Assert.IsFalse(t2.IntCollection.Except(t3.IntCollection).Any());
}
/// <summary>
/// 指定属性元数据，初始化一个 <see cref="PropertyMapper"/> 类的新实例。
/// </summary>
/// <param name="typeMapper">类型的映射器。</param>
/// <param name="property">成员的属性元数据。</param>
public PropertyMapper(TypeMapper typeMapper, PropertyInfo property)
: base(property)
{
if(typeMapper == null) throw new ArgumentNullException(nameof(typeMapper));
this.TypeMapper = typeMapper;
this.IsIgnore = property.GetAttribute<IgnoreAttribute>() != null;
this._LazyTypeDefaultValue = new Lazy<object>(property.PropertyType.GetDefaultValue);
var aliasAttr = property.GetAttribute<IAliasAttribute>();
this.Name = aliasAttr != null && aliasAttr.Name != null
? aliasAttr.Name
: property.Name;
var keyAttr = property.GetAttribute<IKeyAttribute>();
this.IsKey = (keyAttr != null && keyAttr.IsKey) || string.Equals(property.Name, DbExtensions.DefaultKeyName, StringComparison.CurrentCultureIgnoreCase);
this.Validators = property.GetAttributes<IPropertyValidator>().ToArray();
}
/// <summary> /// Resolves the equivalent <see cref="DbType"/> object of the .NET CLR type. /// </summary> /// <param name="type">The .NET CLR type.</param> /// <returns>The equivalent <see cref="DbType"/> object of the .NET CLR type.</returns> public DbType?Resolve(Type type) => TypeMapper.Get(type);
protected virtual PropertyBuilder VisitColumn([NotNull] EntityTypeBuilder builder, [NotNull] ColumnModel column)
{
Check.NotNull(builder, nameof(builder));
Check.NotNull(column, nameof(column));
var typeMapping = GetTypeMapping(column);
var clrType = typeMapping?.ClrType;
if (clrType == null)
{
_unmappedColumns.Add(column);
Logger.LogWarning(
RelationalDesignEventId.ColumnTypeNotMappedWarning,
() => RelationalDesignStrings.CannotFindTypeMappingForColumn(column.DisplayName, column.DataType));
return(null);
}
if (column.IsNullable)
{
clrType = clrType.MakeNullable();
}
var property = builder.Property(clrType, GetPropertyName(column));
if (TypeMapper.GetMapping(property.Metadata).StoreType != column.DataType &&
!string.IsNullOrWhiteSpace(column.DataType))
{
property.HasColumnType(column.DataType);
}
property.HasColumnName(column.Name);
if (column.MaxLength.HasValue)
{
property.HasMaxLength(column.MaxLength.Value);
}
if (column.ValueGenerated == ValueGenerated.OnAdd)
{
property.ValueGeneratedOnAdd();
}
if (column.ValueGenerated == ValueGenerated.OnAddOrUpdate)
{
property.ValueGeneratedOnAddOrUpdate();
}
if (column.DefaultValue != null)
{
property.HasDefaultValueSql(column.DefaultValue);
}
if (column.ComputedValue != null)
{
property.HasComputedColumnSql(column.ComputedValue);
}
if (!column.PrimaryKeyOrdinal.HasValue)
{
property.IsRequired(!column.IsNullable);
}
property.Metadata.Scaffolding().ColumnOrdinal = column.Ordinal;
return(property);
}
public static void Map()
=> TypeMapper
.Map <Events.CustomerRegistered>("CustomerRegistered");
private static SybaseProviderAdapter CreateAdapter(string assemblyName, string clientNamespace, string?dbFactoryName, bool supportsBulkCopy)
{
var assembly = Common.Tools.TryLoadAssembly(assemblyName, dbFactoryName);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {assemblyName}");
}
var connectionType = assembly.GetType($"{clientNamespace}.AseConnection", true);
var commandType = assembly.GetType($"{clientNamespace}.AseCommand", true);
var parameterType = assembly.GetType($"{clientNamespace}.AseParameter", true);
var dataReaderType = assembly.GetType($"{clientNamespace}.AseDataReader", true);
var transactionType = assembly.GetType($"{clientNamespace}.AseTransaction", true);
var dbType = assembly.GetType($"{clientNamespace}.AseDbType", true);
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <AseConnection>(connectionType);
typeMapper.RegisterTypeWrapper <AseParameter>(parameterType);
typeMapper.RegisterTypeWrapper <AseDbType>(dbType);
typeMapper.RegisterTypeWrapper <AseTransaction>(transactionType);
BulkCopyAdapter?bulkCopy = null;
if (supportsBulkCopy)
{
var bulkCopyType = assembly.GetType($"{clientNamespace}.AseBulkCopy", true);
var bulkCopyOptionsType = assembly.GetType($"{clientNamespace}.AseBulkCopyOptions", true);
var bulkRowsCopiedEventHandlerType = assembly.GetType($"{clientNamespace}.AseRowsCopiedEventHandler", true);
var bulkCopyColumnMappingType = assembly.GetType($"{clientNamespace}.AseBulkCopyColumnMapping", true);
var bulkCopyColumnMappingCollectionType = assembly.GetType($"{clientNamespace}.AseBulkCopyColumnMappingCollection", true);
var rowsCopiedEventArgsType = assembly.GetType($"{clientNamespace}.AseRowsCopiedEventArgs", true);
typeMapper.RegisterTypeWrapper <AseBulkCopy>(bulkCopyType);
typeMapper.RegisterTypeWrapper <AseBulkCopyOptions>(bulkCopyOptionsType);
typeMapper.RegisterTypeWrapper <AseRowsCopiedEventHandler>(bulkRowsCopiedEventHandlerType);
typeMapper.RegisterTypeWrapper <AseBulkCopyColumnMapping>(bulkCopyColumnMappingType);
typeMapper.RegisterTypeWrapper <AseBulkCopyColumnMappingCollection>(bulkCopyColumnMappingCollectionType);
typeMapper.RegisterTypeWrapper <AseRowsCopiedEventArgs>(rowsCopiedEventArgsType);
typeMapper.FinalizeMappings();
bulkCopy = new BulkCopyAdapter(
typeMapper.BuildWrappedFactory((IDbConnection connection, AseBulkCopyOptions options, IDbTransaction? transaction) => new AseBulkCopy((AseConnection)connection, options, (AseTransaction?)transaction)),
typeMapper.BuildWrappedFactory((string source, string destination) => new AseBulkCopyColumnMapping(source, destination)));
}
else
{
typeMapper.FinalizeMappings();
}
var paramMapper = typeMapper.Type <AseParameter>();
var dbTypeBuilder = paramMapper.Member(p => p.AseDbType);
return(new SybaseProviderAdapter(
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
dbTypeBuilder.BuildSetter <IDbDataParameter>(),
dbTypeBuilder.BuildGetter <IDbDataParameter>(),
bulkCopy));
}
public void ThrowExceptionOnTypeMapperViaExpressionWithNullTargetColumnName()
{
// Setup
TypeMapper.Add <TypeMapperTestClass>(e => e.ColumnString, null);
}
/// <summary>
/// Create the command parameters from the <see cref="IDictionary{TKey, TValue}"/> object.
/// </summary>
/// <param name="command">The command object to be used.</param>
/// <param name="dictionary">The parameters from the <see cref="Dictionary{TKey, TValue}"/> object.</param>
/// <param name="propertiesToSkip">The list of the properties to be skpped.</param>
/// <param name="resetOthers">True to reset the other parameter object. This will ignore the skipped properties.</param>
private static void SetParameters(this IDbCommand command,
IDictionary <string, object> dictionary,
IEnumerable <string> propertiesToSkip,
bool resetOthers = true)
{
// Variables needed
var dbType = (DbType?)null;
var others = (IList <DbParameter>)null;
var fitered = dictionary
.Where(kvp => propertiesToSkip?.Contains(kvp.Key, StringComparer.CurrentCultureIgnoreCase) != true);
// Iterate the parameter instead
foreach (var parameter in command.Parameters.OfType <DbParameter>())
{
var kvp = fitered.FirstOrDefault(item => item.Key.ToLower() == parameter.ParameterName.ToLower());
// Skip and add to missing if null
if (ReferenceEquals(null, kvp))
{
// Add to missing properties if allowed to
if (resetOthers == true)
{
if (others == null)
{
others = new List <DbParameter>();
}
others.Add(parameter);
}
// Continue to next
continue;
}
// Get the value
var value = kvp.Value;
// Cast the proper object and identify the properties
if (kvp.Value is CommandParameter)
{
var commandParameter = (CommandParameter)kvp.Value;
var property = commandParameter.MappedToType.GetProperty(kvp.Key);
// Get the value
value = commandParameter.Value;
// Get the DB Type
dbType = property?.GetCustomAttribute <TypeMapAttribute>()?.DbType ??
TypeMapper.Get(property?.PropertyType.GetUnderlyingType());
}
else
{
// Get the DB Type
dbType = TypeMapper.Get(kvp.Value?.GetType()?.GetUnderlyingType());
}
// Set the parameter
parameter.Value = value;
if (dbType != null)
{
parameter.DbType = dbType.Value;
}
else
{
parameter.ResetDbType();
}
}
// If there is any (then set to null)
if (resetOthers == true && others?.Any() == true)
{
foreach (var parameter in others)
{
parameter.Value = DBNull.Value;
parameter.ResetDbType();
}
}
}
public ModelAnnotationsMapper(TypeMapperConventions conventions)
{
typeMapper =
TypeMapperFactory.Create(conventions);
}
private static InformixProviderAdapter CreateIfxAdapter()
{
var assembly = Common.Tools.TryLoadAssembly(IfxAssemblyName, IfxProviderFactoryName);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {IfxAssemblyName}");
}
var connectionType = assembly.GetType($"{IfxClientNamespace}.IfxConnection", true);
var parameterType = assembly.GetType($"{IfxClientNamespace}.IfxParameter", true);
var dataReaderType = assembly.GetType($"{IfxClientNamespace}.IfxDataReader", true);
var commandType = assembly.GetType($"{IfxClientNamespace}.IfxCommand", true);
var transactionType = assembly.GetType($"{IfxClientNamespace}.IfxTransaction", true);
var dbType = assembly.GetType($"{IfxClientNamespace}.IfxType", true);
var mappingSchema = new MappingSchema();
var blobType = loadType("IfxBlob", DataType.VarBinary) !;
var clobType = loadType("IfxClob", DataType.Text) !;
var dateTimeType = loadType("IfxDateTime", DataType.DateTime2) !;
// those two types obsoleted in recent providers
var decimalType = loadType("IfxDecimal", DataType.Decimal) !;
var timeSpanType = loadType("IfxTimeSpan", DataType.Time, true, true);
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <IfxConnection>(connectionType);
typeMapper.RegisterTypeWrapper <IfxParameter>(parameterType);
typeMapper.RegisterTypeWrapper <IfxType>(dbType);
if (timeSpanType != null)
{
typeMapper.RegisterTypeWrapper <IfxTimeSpan>(timeSpanType);
}
// bulk copy exists only for IDS provider version
BulkCopyAdapter?bulkCopy = null;
var bulkCopyType = assembly.GetType($"{IfxClientNamespace}.IfxBulkCopy", false);
if (bulkCopyType != null)
{
var bulkCopyOptionsType = assembly.GetType($"{IfxClientNamespace}.IfxBulkCopyOptions", true);
var bulkRowsCopiedEventHandlerType = assembly.GetType($"{IfxClientNamespace}.IfxRowsCopiedEventHandler", true);
var bulkCopyColumnMappingType = assembly.GetType($"{IfxClientNamespace}.IfxBulkCopyColumnMapping", true);
var bulkCopyColumnMappingCollectionType = assembly.GetType($"{IfxClientNamespace}.IfxBulkCopyColumnMappingCollection", true);
var rowsCopiedEventArgsType = assembly.GetType($"{IfxClientNamespace}.IfxRowsCopiedEventArgs", true);
typeMapper.RegisterTypeWrapper <IfxBulkCopy>(bulkCopyType);
typeMapper.RegisterTypeWrapper <IfxBulkCopyOptions>(bulkCopyOptionsType);
typeMapper.RegisterTypeWrapper <IfxRowsCopiedEventHandler>(bulkRowsCopiedEventHandlerType);
typeMapper.RegisterTypeWrapper <IfxBulkCopyColumnMapping>(bulkCopyColumnMappingType);
typeMapper.RegisterTypeWrapper <IfxBulkCopyColumnMappingCollection>(bulkCopyColumnMappingCollectionType);
typeMapper.RegisterTypeWrapper <IfxRowsCopiedEventArgs>(rowsCopiedEventArgsType);
typeMapper.FinalizeMappings();
bulkCopy = new BulkCopyAdapter(
typeMapper.BuildWrappedFactory((IDbConnection connection, IfxBulkCopyOptions options) => new IfxBulkCopy((IfxConnection)connection, options)),
typeMapper.BuildWrappedFactory((int source, string destination) => new IfxBulkCopyColumnMapping(source, destination)));
}
else
{
typeMapper.FinalizeMappings();
}
var paramMapper = typeMapper.Type <IfxParameter>();
var dbTypeBuilder = paramMapper.Member(p => p.IfxType);
Func <TimeSpan, object>?timespanFactory = null;
if (timeSpanType != null)
{
timespanFactory = typeMapper.BuildFactory((TimeSpan ts) => new IfxTimeSpan(ts));
}
return(new InformixProviderAdapter(
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
mappingSchema,
blobType,
clobType,
decimalType,
dateTimeType,
timeSpanType,
dbTypeBuilder.BuildSetter <IDbDataParameter>(),
dbTypeBuilder.BuildGetter <IDbDataParameter>(),
timespanFactory,
bulkCopy));
Type?loadType(string typeName, DataType dataType, bool optional = false, bool obsolete = false, bool register = true)
{
var type = assembly !.GetType($"{IfxTypesNamespace}.{typeName}", !optional);
if (type == null)
{
return(null);
}
if (obsolete && type.GetCustomAttributes(typeof(ObsoleteAttribute), false).Length > 0)
{
return(null);
}
if (register)
{
var getNullValue = Expression.Lambda <Func <object> >(Expression.Convert(ExpressionHelper.Field(type, "Null"), typeof(object))).Compile();
mappingSchema.AddScalarType(type, getNullValue(), true, dataType);
}
return(type);
}
}
object Deserialize(Type fieldType, DataReader reader, bool skipMetaData = false, bool skipNullByte = false)
{
TypeCache typeCache = GetTypeCache(fieldType);
if (skipNullByte == false && typeCache.CanBeNull())
{
bool isNull = reader.ReadBoolean();
if (isNull)
{
return(null);
}
}
Type type = fieldType;
if (skipMetaData == false && typeCache.HasChildTypes)
{
type = ReadType(reader, typeCache.IsGeneric);
if (type == null)
{
return(null);
}
Type resultType = null;
if (TypeMapper.TryGetValue(type, out resultType))
{
type = resultType;
}
typeCache = GetTypeCache(type);
}
if (type == null)
{
return(null);
}
if (typeCache.IsNullable)
{
Type[] types = Reflection.GetGenericArgumentsExt(type);
return(Deserialize(types[0], reader));
}
if (type.IsPrimitive)
{
return(DeserializePrimitive(type, reader));
}
if (type == typeof(String))
{
return(reader.ReadUTF());
}
if (type == typeof(Guid))
{
return(new Guid(reader.ReadBytes(16))); //Automatically in BigEndianFormat
}
if (type.IsEnum)
{
Type subType = Enum.GetUnderlyingType(type);
object value = DeserializePrimitive(subType, reader);
return(Enum.ToObject(type, value));
}
if (typeCache.IsList)
{
if (type == typeof(object)) //Still no idea why
{
return(DeserializeArray(typeof(object), reader));
}
return(DeserializeList(type, reader));
}
object o = Reflection.CreateInstance(type);
if (o is IDictionary && typeCache.IsGeneric)
{
Type[] genericArguments = Reflection.GetGenericArgumentsExt(type);
DeserializeDictionary(genericArguments[0], genericArguments[1], (IDictionary)o, reader);
}
else
{
DeserializeObject(type, o, reader);
}
return(o);
}
public void IsEntityTest()
{
Assert.True(TypeMapper.IsEntity(typeof(Models.User)));
Assert.False(TypeMapper.IsEntity(typeof(IsClrTypeTestClass)));
}
DB2ProviderAdapter()
{
var clientNamespace = ClientNamespace;
var assembly = Tools.TryLoadAssembly(AssemblyName, ProviderFactoryName);
if (assembly == null && AssemblyNameOld != null)
{
assembly = Tools.TryLoadAssembly(AssemblyNameOld, ProviderFactoryName);
if (assembly != null)
{
clientNamespace = ClientNamespaceOld !;
}
}
else if (AssemblyNameOld != null && assembly.GetName().Name == AssemblyNameOld)
{
// cover case when provider factory loaded old assembly
clientNamespace = ClientNamespaceOld !;
}
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {AssemblyName}");
}
ConnectionType = assembly.GetType($"{clientNamespace}.DB2Connection", true) !;
ParameterType = assembly.GetType($"{clientNamespace}.DB2Parameter", true) !;
DataReaderType = assembly.GetType($"{clientNamespace}.DB2DataReader", true) !;
TransactionType = assembly.GetType($"{clientNamespace}.DB2Transaction", true) !;
CommandType = assembly.GetType($"{clientNamespace}.DB2Command", true) !;
var dbType = assembly.GetType($"{clientNamespace}.DB2Type", true) !;
var serverTypesType = assembly.GetType($"{clientNamespace}.DB2ServerTypes", true) !;
var bulkCopyType = assembly.GetType($"{clientNamespace}.DB2BulkCopy", true) !;
var bulkCopyOptionsType = assembly.GetType($"{clientNamespace}.DB2BulkCopyOptions", true) !;
var bulkCopyColumnMappingType = assembly.GetType($"{clientNamespace}.DB2BulkCopyColumnMapping", true) !;
var rowsCopiedEventHandlerType = assembly.GetType($"{clientNamespace}.DB2RowsCopiedEventHandler", true) !;
var rowsCopiedEventArgs = assembly.GetType($"{clientNamespace}.DB2RowsCopiedEventArgs", true) !;
var bulkCopyColumnMappingCollection = assembly.GetType($"{clientNamespace}.DB2BulkCopyColumnMappingCollection", true) !;
MappingSchema = new DB2AdapterMappingSchema();
DB2BinaryType = LoadType("DB2Binary", DataType.VarBinary) !;
DB2BlobType = LoadType("DB2Blob", DataType.Blob) !;
DB2ClobType = LoadType("DB2Clob", DataType.NText) !;
DB2DateType = LoadType("DB2Date", DataType.Date) !;
DB2DateTimeType = LoadType("DB2DateTime", DataType.DateTime, true);
DB2DecimalType = LoadType("DB2Decimal", DataType.Decimal) !;
DB2DecimalFloatType = LoadType("DB2DecimalFloat", DataType.Decimal) !;
DB2DoubleType = LoadType("DB2Double", DataType.Double) !;
DB2Int16Type = LoadType("DB2Int16", DataType.Int16) !;
DB2Int32Type = LoadType("DB2Int32", DataType.Int32) !;
DB2Int64Type = LoadType("DB2Int64", DataType.Int64) !;
DB2RealType = LoadType("DB2Real", DataType.Single) !;
DB2Real370Type = LoadType("DB2Real370", DataType.Single) !;
DB2RowIdType = LoadType("DB2RowId", DataType.VarBinary) !;
DB2StringType = LoadType("DB2String", DataType.NVarChar) !;
DB2TimeType = LoadType("DB2Time", DataType.Time) !;
DB2TimeStampType = LoadType("DB2TimeStamp", DataType.DateTime2) !;
DB2XmlType = LoadType("DB2Xml", DataType.Xml) !;
DB2TimeSpanType = LoadType("DB2TimeSpan", DataType.Timestamp, true, true);
// not mapped currently: DB2MonthSpan, DB2SmartLOB, DB2TimeStampOffset, DB2XsrObjectId
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <DB2ServerTypes>(serverTypesType);
typeMapper.RegisterTypeWrapper <DB2Connection>(ConnectionType);
typeMapper.RegisterTypeWrapper <DB2Parameter>(ParameterType);
typeMapper.RegisterTypeWrapper <DB2Type>(dbType);
typeMapper.RegisterTypeWrapper <DB2Transaction>(TransactionType);
typeMapper.RegisterTypeWrapper <DB2Binary>(DB2BinaryType);
// bulk copy types
typeMapper.RegisterTypeWrapper <DB2BulkCopy>(bulkCopyType);
typeMapper.RegisterTypeWrapper <DB2RowsCopiedEventArgs>(rowsCopiedEventArgs);
typeMapper.RegisterTypeWrapper <DB2RowsCopiedEventHandler>(rowsCopiedEventHandlerType);
typeMapper.RegisterTypeWrapper <DB2BulkCopyColumnMappingCollection>(bulkCopyColumnMappingCollection);
typeMapper.RegisterTypeWrapper <DB2BulkCopyOptions>(bulkCopyOptionsType);
typeMapper.RegisterTypeWrapper <DB2BulkCopyColumnMapping>(bulkCopyColumnMappingType);
typeMapper.FinalizeMappings();
var db2BinaryBuilder = typeMapper.Type <DB2Binary>().Member(p => p.IsNull);
IsDB2BinaryNull = db2BinaryBuilder.BuildGetter <object>();
var dbTypeBuilder = typeMapper.Type <DB2Parameter>().Member(p => p.DB2Type);
SetDbType = dbTypeBuilder.BuildSetter <DbParameter>();
GetDbType = dbTypeBuilder.BuildGetter <DbParameter>();
BulkCopy = new BulkCopyAdapter(
typeMapper.BuildWrappedFactory((DbConnection connection, DB2BulkCopyOptions options) => new DB2BulkCopy((DB2Connection)(object)connection, options)),
typeMapper.BuildWrappedFactory((int source, string destination) => new DB2BulkCopyColumnMapping(source, destination)));
CreateConnection = typeMapper.BuildWrappedFactory((string connectionString) => new DB2Connection(connectionString));
Type?LoadType(string typeName, DataType dataType, bool optional = false, bool obsolete = false, bool register = true)
{
var type = assembly !.GetType($"{TypesNamespace}.{typeName}", !optional);
if (type == null)
{
return(null);
}
if (obsolete && type.GetCustomAttributes(typeof(ObsoleteAttribute), false).Length > 0)
{
return(null);
}
if (register)
{
var getNullValue = Expression.Lambda <Func <object> >(Expression.Convert(ExpressionHelper.Field(type, "Null"), typeof(object))).CompileExpression();
MappingSchema.AddScalarType(type, getNullValue(), true, dataType);
}
return(type);
}
}
/// <summary>
/// Creates a parameter from object by mapping the property from the target entity type.
/// </summary>
/// <param name="command">The command object to be used.</param>
/// <param name="param">The object to be used when creating the parameters.</param>
/// <param name="propertiesToSkip">The list of the properties to be skpped.</param>
public static void CreateParameters(this IDbCommand command,
object param,
IEnumerable <string> propertiesToSkip)
{
// Check for presence
if (param == null)
{
return;
}
// Supporting the IDictionary<string, object>
if (param is ExpandoObject || param is IDictionary <string, object> )
{
CreateParameters(command, (IDictionary <string, object>)param, propertiesToSkip);
}
// Supporting the QueryField
else if (param is QueryField)
{
CreateParameters(command, (QueryField)param, propertiesToSkip);
}
// Supporting the IEnumerable<QueryField>
else if (param is IEnumerable <QueryField> )
{
CreateParameters(command, (IEnumerable <QueryField>)param, propertiesToSkip);
}
// Supporting the QueryGroup
else if (param is QueryGroup)
{
CreateParameters(command, (QueryGroup)param, propertiesToSkip);
}
// Otherwise, iterate the properties
else
{
var type = param.GetType();
// Check the validity of the type
if (type.IsGenericType && type.GetGenericTypeDefinition() == m_dictionaryType)
{
throw new InvalidOperationException("Invalid parameters passed. The supported type of dictionary object must be typeof(IDictionary<string, object>).");
}
// Variables for properties
var properties = (IEnumerable <ClassProperty>)null;
// Add this check for performance
if (propertiesToSkip == null)
{
properties = PropertyCache.Get(type);
}
else
{
properties = PropertyCache.Get(type)
.Where(p => propertiesToSkip?.Contains(p.PropertyInfo.Name,
StringComparer.CurrentCultureIgnoreCase) == false);
}
// Iterate the properties
foreach (var property in properties)
{
// Get the property vaues
var name = property.GetUnquotedMappedName();
var value = property.PropertyInfo.GetValue(param);
// Get property db type
var dbType = property.GetDbType();
// Ensure mapping based on the value type
if (dbType == null)
{
dbType = TypeMapper.Get(value?.GetType().GetUnderlyingType());
}
// Check for specialized
if (dbType == null)
{
var propertyType = property.PropertyInfo.PropertyType.GetUnderlyingType();
if (propertyType?.IsEnum == true)
{
dbType = DbType.String;
}
else if (propertyType == m_bytesType)
{
dbType = DbType.Binary;
}
}
// Add the new parameter
command.Parameters.Add(command.CreateParameter(name, value, dbType));
}
}
}
/// <summary>
/// Set the <see cref="IDbCommand"/> object existing <see cref="IDbDataParameter"/> values.
/// </summary>
/// <param name="command">The command object to be used.</param>
/// <param name="param">The instance of where the parameter values will be set.</param>
/// <param name="propertiesToSkip">The list of the properties to be skpped.</param>
/// <param name="resetOthers">True to reset the other parameter object. This will ignore the skipped properties.</param>
internal static void SetParameters(this IDbCommand command,
object param,
IEnumerable <string> propertiesToSkip = null,
bool resetOthers = true)
{
// Do nothing if there is no parameter
if (command.Parameters.Count == 0)
{
return;
}
// Check for presence
if (param == null)
{
foreach (var parameter in command.Parameters.OfType <DbParameter>())
{
parameter.Value = DBNull.Value;
parameter.ResetDbType();
}
}
// Supporting the IDictionary<string, object>
else if (param is ExpandoObject || param is IDictionary <string, object> )
{
SetParameters(command, (IDictionary <string, object>)param, propertiesToSkip, resetOthers);
}
// Supporting the QueryField
else if (param is QueryField)
{
SetParameters(command, (QueryField)param, propertiesToSkip, resetOthers);
}
// Supporting the IEnumerable<QueryField>
else if (param is IEnumerable <QueryField> )
{
SetParameters(command, (IEnumerable <QueryField>)param, propertiesToSkip, resetOthers);
}
// Supporting the QueryGroup
else if (param is QueryGroup)
{
SetParameters(command, (QueryGroup)param, propertiesToSkip, resetOthers);
}
// Otherwise, iterate the properties
else
{
var type = param.GetType();
// Check the validity of the type
if (type.IsGenericType && type.GetGenericTypeDefinition() == m_dictionaryType)
{
throw new InvalidOperationException("Invalid parameters passed. The supported type of dictionary object must be typeof(IDictionary<string, object>).");
}
// variables for properties
var properties = (IEnumerable <ClassProperty>)null;
// Add this check for performance
if (propertiesToSkip == null)
{
properties = PropertyCache.Get(type);
}
else
{
properties = PropertyCache.Get(type)
.Where(p => propertiesToSkip?.Contains(p.PropertyInfo.Name,
StringComparer.CurrentCultureIgnoreCase) == false);
}
// Ensure there are properties
if (resetOthers == true && properties.Any() != true)
{
SetParameters(command, null);
}
else
{
var parameters = command.Parameters.OfType <DbParameter>();
var missingParameters = (IList <DbParameter>)null;
// Iterate the parameter instead
foreach (var parameter in parameters)
{
var property = properties.FirstOrDefault(p => p.GetUnquotedMappedName().ToLower() == parameter.ParameterName.ToLower());
// Skip if null
if (property == null)
{
// Add to missing properties if allowed to
if (resetOthers == true)
{
if (missingParameters == null)
{
missingParameters = new List <DbParameter>();
}
missingParameters.Add(parameter);
}
// Continue to next
continue;
}
// Get the property values
var value = property.PropertyInfo.GetValue(param);
var dbType = property.GetDbType() ??
TypeMapper.Get(property.PropertyInfo.PropertyType.GetUnderlyingType());
// Ensure the type mapping
if (dbType == null)
{
if (value == null && property.PropertyInfo.PropertyType == m_bytesType)
{
dbType = DbType.Binary;
}
}
// Set the parameter
parameter.Value = value;
if (dbType != null)
{
parameter.DbType = dbType.Value;
}
}
// If there is any (then set to null)
if (resetOthers == true && missingParameters?.Any() == true)
{
foreach (var parameter in missingParameters)
{
parameter.Value = DBNull.Value;
parameter.ResetDbType();
}
}
}
}
}
private void AddPhoto(IDataContext database, Photo photo, string authorId, string conversationId)
{
var photoEntity = TypeMapper.MapPhoto(photo, _loader.ImagesOutputPath, authorId, conversationId);
database.Insert(photoEntity, tableName: "photos");
}
/// <summary>
/// Create the command parameters from the list of <see cref="QueryField"/> objects.
/// </summary>
/// <param name="command">The command object to be used.</param>
/// <param name="queryFields">The list of <see cref="QueryField"/> objects.</param>
/// <param name="propertiesToSkip">The list of the properties to be skpped.</param>
/// <param name="resetOthers">True to reset the other parameter object. This will ignore the skipped properties.</param>
private static void SetParameters(this IDbCommand command,
IEnumerable <QueryField> queryFields,
IEnumerable <string> propertiesToSkip,
bool resetOthers = true)
{
// Variables needed
var dbType = (DbType?)null;
var others = (IList <DbParameter>)null;
var filtered = queryFields
.Where(qf => propertiesToSkip?.Contains(qf.Field.UnquotedName, StringComparer.CurrentCultureIgnoreCase) != true);
// Iterate the parameter instead
foreach (var parameter in command.Parameters.OfType <DbParameter>())
{
var queryField = filtered.FirstOrDefault(qf => qf.Field.UnquotedName.ToLower() == parameter.ParameterName.ToLower());
// Skip and add to missing if null
if (queryField == null)
{
// Add to missing properties if allowed to
if (resetOthers == true)
{
if (others == null)
{
others = new List <DbParameter>();
}
others.Add(parameter);
}
// Continue to next
continue;
}
// Get the value
var value = queryField.Parameter.Value;
// Get the DB Type
dbType = TypeMapper.Get(value?.GetType()?.GetUnderlyingType());
// Set the parameter
parameter.Value = value;
if (dbType != null)
{
parameter.DbType = dbType.Value;
}
else
{
parameter.ResetDbType();
}
}
// If there is any (then set to null)
if (resetOthers == true && others?.Any() == true)
{
foreach (var parameter in others)
{
parameter.Value = DBNull.Value;
parameter.ResetDbType();
}
}
}
public static void ClassInitialize(TestContext context)
{
TypeMapper.AddMap(typeof(DateTime), DbType.DateTime2, true);
SetupHelper.InitDatabase();
}
protected override void RenderImplementation()
{
var httpMethodName = HttpMethod.ToString().ToLower();
string contentOptionsWithHeadersHandlerForString = $"{{ method: '{httpMethodName}', headers: headersHandler ? Object.assign(headersHandler(), {{ 'Content-Type': '{contentType}' }}): {{ 'Content-Type': '{contentType}' }}, body: JSON.stringify(requestBody) }}";
var ContentOptionsForString = settings.HandleHttpRequestHeaders ? contentOptionsWithHeadersHandlerForString : $"{{ method: '{httpMethodName}', headers: {{ 'Content-Type': '{contentType}' }}, body: JSON.stringify(requestBody) }}";
string contentOptionsWithHeadersHandlerForResponse = $"{{ method: '{httpMethodName}', headers: headersHandler ? Object.assign(headersHandler(), {{ 'Content-Type': '{contentType}' }}): {{ 'Content-Type': '{contentType}' }}, body: JSON.stringify(requestBody) }}";
var ContentOptionsForResponse = settings.HandleHttpRequestHeaders ? contentOptionsWithHeadersHandlerForResponse : $"{{ method: '{httpMethodName}', headers: {{ 'Content-Type': '{contentType}' }}, body: JSON.stringify(requestBody) }}";
string optionsWithHeadersHandlerAndContent = $"{{ method: '{httpMethodName}', headers: headersHandler ? Object.assign(headersHandler(), {{ 'Content-Type': '{contentType}' }}): {{ 'Content-Type': '{contentType}' }}, body: JSON.stringify(requestBody) }}";
var OptionsWithContent = settings.HandleHttpRequestHeaders ? optionsWithHeadersHandlerAndContent : $"{{ method: '{httpMethodName}', headers: {{ 'Content-Type': '{contentType}' }}, body: JSON.stringify(requestBody) }}";
string optionsWithHeadersHandlerForString = $"{{ method: '{httpMethodName}', headers: headersHandler ? headersHandler() : undefined }}";
var OptionsForString = settings.HandleHttpRequestHeaders ? optionsWithHeadersHandlerForString : $"{{ method: '{httpMethodName}' }}";
string optionsWithHeadersHandlerForResponse = $"{{ method: '{httpMethodName}', headers: headersHandler ? headersHandler() : undefined }}";
var OptionsForResponse = settings.HandleHttpRequestHeaders ? optionsWithHeadersHandlerForResponse : $"{{ method: '{httpMethodName}' }}";
string optionsWithHeadersHandler = $"{{ method: '{httpMethodName}', headers: headersHandler ? headersHandler() : undefined }}";
var Options = settings.HandleHttpRequestHeaders ? optionsWithHeadersHandler : $"{{ method: '{httpMethodName}' }}";
CodeParameterDeclarationExpression[] parameters = ParameterDescriptions.Select(d =>
new CodeParameterDeclarationExpression(TypeMapper.MapCodeTypeReferenceToTsText(d.ParameterTypeReference), d.Name))
.ToArray();
Method.Parameters.AddRange(parameters);
if (RequestBodyCodeTypeReference != null)
{
CodeParameterDeclarationExpression p = new CodeParameterDeclarationExpression(RequestBodyCodeTypeReference, "requestBody");
Method.Parameters.Add(p);
}
if (settings.HandleHttpRequestHeaders)
{
Method.Parameters.Add(new CodeParameterDeclarationExpression(
"() => {[header: string]: string}", "headersHandler?"));
}
string jsUriQuery = UriQueryHelper.CreateUriQueryForTs(RelativePath, ParameterDescriptions);
string uriText = jsUriQuery == null ? $"this.baseUri + '{RelativePath}'" :
RemoveTrialEmptyString($"this.baseUri + '{jsUriQuery}'");
if (ReturnTypeReference != null && ReturnTypeReference.BaseType == "System.String" && ReturnTypeReference.ArrayElementType == null) //stringAsString is for .NET Core Web API
{
if (httpMethodName == "get" || httpMethodName == "delete")
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsForString}).then(d => d.text());")); //todo: type cast is not really needed.
return;
}
if (httpMethodName == "post" || httpMethodName == "put" || httpMethodName == "patch")
{
if (RequestBodyCodeTypeReference == null)
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsForString}).then(d => d.text());"));
}
else
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {ContentOptionsForString}).then(d => d.text());"));
}
return;
}
}
//else if (returnTypeText == FetchHttpStringResponse)//translated from response to this
//{
// if (httpMethodName == "post" || httpMethodName == "put" || httpMethodName == "patch")
// {
// Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsForResponse}).then(d => d.text());"));
// return;
// }
// if (httpMethodName == "post" || httpMethodName == "put" || httpMethodName == "patch")
// {
// if (RequestBodyCodeTypeReference == null)
// {
// Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, null, {OptionsForResponse}).then(d => d.text());"));
// }
// else
// {
// Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, JSON.stringify(requestBody), {ContentOptionsForResponse});"));
// }
// return;
// }
//}
else if (returnTypeText == FetchHttpResponse) // client should care about only status
{
if (httpMethodName == "get" || httpMethodName == "delete")
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {Options});"));
return;
}
if (httpMethodName == "post" || httpMethodName == "put" || httpMethodName == "patch")
{
if (RequestBodyCodeTypeReference == null)
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {Options});"));
}
else
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsWithContent});"));
}
return;
}
}
else
{
string returnTypeCast = returnTypeText == null ? String.Empty : $"<{returnTypeText}>";
if (httpMethodName == "get" || httpMethodName == "delete")
{
if (returnTypeText == null)
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsForResponse});")); //only http response needed
}
else
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {Options}).then(d => d.json());"));
}
}
else if (httpMethodName == "post" || httpMethodName == "put" || httpMethodName == "patch")
{
if (returnTypeText == null) //http response
{
if (RequestBodyCodeTypeReference == null) //no content body
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsForResponse});"));
}
else
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {ContentOptionsForResponse});"));
}
}
else // type is returned
{
if (RequestBodyCodeTypeReference == null) // no body
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {Options}).then(d => d.json());"));
}
else
{
Method.Statements.Add(new CodeSnippetStatement($"return fetch({uriText}, {OptionsWithContent}).then(d => d.json());"));
}
}
}
else
{
Debug.Assert(false, $"How come with {httpMethodName}?");
}
}
}
public MarshalEngineSwiftToCSharp(SLImportModules imports, List <string> identifiersUsed, TypeMapper typeMapper)
{
this.imports = imports;
preMarshalCode = new List <ICodeElement> ();
postMarshalCode = new List <ICodeElement> ();
this.typeMapper = typeMapper;
this.identifiersUsed = Ex.ThrowOnNull(identifiersUsed, "identifiersUsed");
}
public static NpgsqlProviderAdapter GetInstance()
{
if (_instance == null)
{
lock (_syncRoot)
if (_instance == null)
{
var assembly = Tools.TryLoadAssembly(AssemblyName, null);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {AssemblyName}");
}
var connectionType = assembly.GetType($"{ClientNamespace}.NpgsqlConnection", true) !;
var parameterType = assembly.GetType($"{ClientNamespace}.NpgsqlParameter", true) !;
var dataReaderType = assembly.GetType($"{ClientNamespace}.NpgsqlDataReader", true) !;
var commandType = assembly.GetType($"{ClientNamespace}.NpgsqlCommand", true) !;
var transactionType = assembly.GetType($"{ClientNamespace}.NpgsqlTransaction", true) !;
var dbType = assembly.GetType($"{TypesNamespace}.NpgsqlDbType", true) !;
var npgsqlDateType = assembly.GetType($"{TypesNamespace}.NpgsqlDate", true) !;
var npgsqlPointType = assembly.GetType($"{TypesNamespace}.NpgsqlPoint", true) !;
var npgsqlLSegType = assembly.GetType($"{TypesNamespace}.NpgsqlLSeg", true) !;
var npgsqlBoxType = assembly.GetType($"{TypesNamespace}.NpgsqlBox", true) !;
var npgsqlCircleType = assembly.GetType($"{TypesNamespace}.NpgsqlCircle", true) !;
var npgsqlPathType = assembly.GetType($"{TypesNamespace}.NpgsqlPath", true) !;
var npgsqlPolygonType = assembly.GetType($"{TypesNamespace}.NpgsqlPolygon", true) !;
var npgsqlLineType = assembly.GetType($"{TypesNamespace}.NpgsqlLine", true) !;
var npgsqlInetType = assembly.GetType($"{TypesNamespace}.NpgsqlInet", true) !;
var npgsqlTimeSpanType = assembly.GetType($"{TypesNamespace}.NpgsqlTimeSpan", true) !;
var npgsqlDateTimeType = assembly.GetType($"{TypesNamespace}.NpgsqlDateTime", true) !;
var npgsqlRangeTType = assembly.GetType($"{TypesNamespace}.NpgsqlRange`1", true) !;
var npgsqlBinaryImporterType = assembly.GetType($"{ClientNamespace}.NpgsqlBinaryImporter", true) !;
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <NpgsqlConnection>(connectionType);
typeMapper.RegisterTypeWrapper <NpgsqlParameter>(parameterType);
typeMapper.RegisterTypeWrapper <NpgsqlDbType>(dbType);
typeMapper.RegisterTypeWrapper <NpgsqlBinaryImporter>(npgsqlBinaryImporterType);
typeMapper.FinalizeMappings();
var paramMapper = typeMapper.Type <NpgsqlParameter>();
var dbTypeBuilder = paramMapper.Member(p => p.NpgsqlDbType);
var pConnection = Expression.Parameter(typeof(IDbConnection));
var pCommand = Expression.Parameter(typeof(string));
var beginBinaryImport = Expression.Lambda <Func <IDbConnection, string, NpgsqlBinaryImporter> >(
typeMapper.MapExpression((IDbConnection conn, string command) => typeMapper.Wrap <NpgsqlBinaryImporter>(((NpgsqlConnection)conn).BeginBinaryImport(command)), pConnection, pCommand),
pConnection, pCommand)
.Compile();
// create mapping schema
var mappingSchema = new MappingSchema();
// date/time types
AddUdtType(npgsqlDateType);
AddUdtType(npgsqlDateTimeType);
mappingSchema.SetDataType(npgsqlTimeSpanType, DataType.Interval);
mappingSchema.SetDataType(npgsqlTimeSpanType.AsNullable(), DataType.Interval);
// NpgsqlDateTimeType => DateTimeOffset
{
var p = Expression.Parameter(npgsqlDateTimeType, "p");
var pi = p.Type.GetProperty("DateTime");
Expression expr;
if (pi != null)
{
// < 3.2.0
// https://github.com/npgsql/npgsql/commit/3894175f970b611f6428757a932b6393749da958#diff-c792076ac0455dd0f2852822ea38b0aaL166
expr = Expression.Property(p, pi);
}
else
{
// 3.2.0+
expr = Expression.Call(p, "ToDateTime", null);
}
var npgsqlDateTimeToDateTimeOffsetMapper = Expression.Lambda(
Expression.New(
MemberHelper.ConstructorOf(() => new DateTimeOffset(new DateTime())),
expr),
p);
mappingSchema.SetConvertExpression(npgsqlDateTimeType, typeof(DateTimeOffset), npgsqlDateTimeToDateTimeOffsetMapper);
}
// inet types
AddUdtType(npgsqlInetType);
AddUdtType(typeof(IPAddress));
AddUdtType(typeof(PhysicalAddress));
// npgsql4 obsoletes NpgsqlInetType and returns ValueTuple<IPAddress, int>
// still while it is here, we should be able to map it properly
// (IPAddress, int) => NpgsqlInet
{
var valueTypeType = Type.GetType("System.ValueTuple`2", false);
if (valueTypeType != null)
{
var inetTupleType = valueTypeType.MakeGenericType(typeof(IPAddress), typeof(int));
var p = Expression.Parameter(inetTupleType, "p");
var tupleToInetTypeMapper = Expression.Lambda(
Expression.New(
npgsqlInetType.GetConstructor(new[] { typeof(IPAddress), typeof(int) }) !,
ExpressionHelper.Field(p, "Item1"),
ExpressionHelper.Field(p, "Item2")),
p);
mappingSchema.SetConvertExpression(inetTupleType !, npgsqlInetType, tupleToInetTypeMapper);
}
}
// ranges
AddUdtType(npgsqlRangeTType);
{
void SetRangeConversion <T>(string?fromDbType = null, DataType fromDataType = DataType.Undefined, string?toDbType = null, DataType toDataType = DataType.Undefined)
{
var rangeType = npgsqlRangeTType.MakeGenericType(typeof(T));
var fromType = new DbDataType(rangeType, fromDataType, fromDbType);
var toType = new DbDataType(typeof(DataParameter), toDataType, toDbType);
var rangeParam = Expression.Parameter(rangeType, "p");
mappingSchema.SetConvertExpression(fromType, toType,
Expression.Lambda(
Expression.New(
MemberHelper.ConstructorOf(
() => new DataParameter("", null, DataType.Undefined, toDbType)),
Expression.Constant(""),
Expression.Convert(rangeParam, typeof(object)),
Expression.Constant(toDataType),
Expression.Constant(toDbType, typeof(string))
)
, rangeParam)
);
}
SetRangeConversion <byte>();
SetRangeConversion <int>();
SetRangeConversion <double>();
SetRangeConversion <float>();
SetRangeConversion <decimal>();
SetRangeConversion <DateTime>(fromDbType: "daterange", toDbType: "daterange");
SetRangeConversion <DateTime>(fromDbType: "tsrange", toDbType: "tsrange");
SetRangeConversion <DateTime>(toDbType: "tsrange");
SetRangeConversion <DateTime>(fromDbType: "tstzrange", toDbType: "tstzrange");
SetRangeConversion <DateTimeOffset>("tstzrange");
}
// spatial types
AddUdtType(npgsqlPointType);
AddUdtType(npgsqlLSegType);
AddUdtType(npgsqlBoxType);
AddUdtType(npgsqlPathType);
AddUdtType(npgsqlCircleType);
AddUdtType(npgsqlPolygonType);
AddUdtType(npgsqlLineType);
_instance = new NpgsqlProviderAdapter(
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
dbType,
mappingSchema,
npgsqlDateType,
npgsqlPointType,
npgsqlLSegType,
npgsqlBoxType,
npgsqlCircleType,
npgsqlPathType,
npgsqlPolygonType,
npgsqlLineType,
npgsqlInetType,
npgsqlTimeSpanType,
npgsqlDateTimeType,
npgsqlRangeTType,
typeMapper.BuildWrappedFactory((string connectionString) => new NpgsqlConnection(connectionString)),
dbTypeBuilder.BuildSetter <IDbDataParameter>(),
dbTypeBuilder.BuildGetter <IDbDataParameter>(),
beginBinaryImport);
void AddUdtType(Type type)
{
if (!type.IsValueType)
{
mappingSchema.AddScalarType(type, null, true, DataType.Udt);
}
else
{
mappingSchema.AddScalarType(type, DataType.Udt);
mappingSchema.AddScalarType(type.AsNullable(), null, true, DataType.Udt);
}
}
}
}
return(_instance);
}
private string GetTypeLiteral(TypeScriptTypeModel typeModel)
{
return(typeModel.IsNamedType
? typeModel.Name
: TypeMapper.MapTypeScriptTypeToLiteral(typeModel.PredefinedType));
}
protected virtual RelationalTypeMapping GetTypeMapping([NotNull] ColumnModel column)
{
Check.NotNull(column, nameof(column));
return(column.DataType == null ? null : TypeMapper.FindMapping(column.DataType));
}
protected override Expression VisitMember(MemberExpression node)
{
// This will get filled with the "actual" value from our child
// ConstantExpression if happen to have a child ConstantExpression.
// see: http://stackoverflow.com/questions/6998523
object value = null;
// Recurse down to see if we can simplify...
this.blockWriting = true;
var expression = this.Visit(node.Expression);
this.blockWriting = false;
// If we've ended up with a constant, and it's a property
// or a field, we can simplify ourselves to a constant.
if (expression is ConstantExpression)
{
MemberInfo member = node.Member;
object container = ((ConstantExpression)expression).Value;
if (member is FieldInfo)
{
value = ((FieldInfo)member).GetValue(container);
}
else if (member is PropertyInfo)
{
value = ((PropertyInfo)member).GetValue(container, null);
}
// If we managed to actually get a value, lets now create a
// ConstantExpression with the expected value and Vist it.
if (value != null)
{
if (TypeMapper.IsClrType(value))
{
this.Visit(Expression.Constant(value));
}
else
{
// So if we get to here, what has happened is that
// the value returned by the FieldInfo GetValue call
// is actually the container, so we save it for later.
this.value = value;
}
}
}
else if (expression is MemberExpression)
{
// Now we can use the value we saved earlier to actually grab
// the constant value that we expected. I guess this sort of
// recursion could go on for ages and hence why the accepted
// answer used DyanmicInvoke. Anyway we will hope that this
// does the job for our needs.
MemberInfo member = node.Member;
object container = this.value;
if (member is FieldInfo)
{
value = ((FieldInfo)member).GetValue(container);
}
else if (member is PropertyInfo)
{
value = ((PropertyInfo)member).GetValue(container, null);
}
this.value = null;
if (TypeMapper.IsClrType(value))
{
this.Visit(Expression.Constant(value));
}
else
{
throw new ExpressionTooComplexException();
}
}
// We only need to do this if we did not
// have a child ConstantExpression
if (value == null)
{
this.sql.Append(new SqlId(node.Member.Name).Value);
this.sql.Append(" ");
}
return(node);
}
public static T CreateAs <T>(this Item item, bool isLazyLoad = true)
{
return((T)TypeMapper.CreateObject(item, typeof(T), isLazyLoad));
}
public bool VirtualMethodExistsInInheritedBoundType(FunctionDeclaration func, TypeMapper typeMapper)
{
// virtual methods are only in classes
if (!(this is ClassDeclaration))
{
return(false);
}
var classInheritance = Inheritance.FirstOrDefault(inh => inh.InheritanceKind == InheritanceKind.Class);
if (classInheritance == null)
{
return(false);
}
var inheritedEntity = typeMapper.GetEntityForTypeSpec(classInheritance.InheritedTypeSpec);
if (inheritedEntity == null)
{
throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 18, $"Unable to find type database entry for class {classInheritance.InheritedTypeName} while searching inheritance.");
}
// if we get here, the Type has to be a ClassDeclaration
var inheritedClass = inheritedEntity.Type as ClassDeclaration;
var methods = inheritedClass.AllVirtualMethods().FindAll(fn => fn.Name == func.Name &&
fn.ParameterLists.Last().Count == func.ParameterLists.Last().Count).ToList();
foreach (var method in methods)
{
if (ParmsMatchWithNames(method.ParameterLists.Last(), func.ParameterLists.Last()) &&
method.ReturnTypeSpec.Equals(func.ReturnTypeSpec))
{
return(true);
}
}
return(inheritedClass.VirtualMethodExistsInInheritedBoundType(func, typeMapper));
}
public void SetUp()
{
TypeMapper = new TypeMapper(new CritterPomonaConfiguration());
Repository = new CritterRepository(TypeMapper);
FirstCritter = Repository.List <Critter>().First();
}
public void Initialize()
{
Database.Initialize();
TypeMapper.Add(typeof(Continent), System.Data.DbType.Int16, true);
Cleanup();
}
public void ThrowExceptionOnTypeMapperViaFieldWithNullTargetColumnName()
{
// Setup
TypeMapper.Add <TypeMapperTestClass>(new Field("ColumnString"), null);
}
public void Setup()
{
SqlServerBootstrap.Initialize();
TypeMapper.Add(typeof(DateTime), DbType.DateTime2, true);
BaseSetup();
}
public static IServiceProvider Build(this IServiceCollection services,
IConfiguration configuration, IHostingEnvironment hostingEnvironment, bool IsCustomizedMvc = true)
{
GlobalConfiguration.Load(configuration);
services.LoadInstalledModules(hostingEnvironment.ContentRootPath);
if (IsCustomizedMvc)
{
services.AddCustomizedMvc(GlobalConfiguration.Modules);
}
services.AddSession(options =>
{
// Set a short timeout for easy testing.
options.IdleTimeout = TimeSpan.FromMinutes(30);
options.Cookie.HttpOnly = true;
});
//Config logger log4net:
var logRepository = log4net.LogManager.GetRepository(System.Reflection.Assembly.GetEntryAssembly());
log4net.Config.XmlConfigurator.Configure(logRepository, new System.IO.FileInfo(GlobalConfiguration.Log4netFilePath));
services.Configure <RazorViewEngineOptions>(options =>
{
options.ViewLocationExpanders.Add(new ViewLocationExpander());
});
services.BuildIntergration(hostingEnvironment);
TypeMapper.Initialize(GlobalConfiguration.Modules.Where(m => m.Name.EndsWith(".UI")).Select(m => m.Assembly));
TypeMapper.Initialize(Assembly.GetAssembly(typeof(GlobalConfiguration)));
var builder = new ContainerBuilder();
foreach (var module in GlobalConfiguration.Modules)
{
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Service")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Handler")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Provider")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Context")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Helper")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).Where(t => t.Name.EndsWith("Queries")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module.Assembly).AsClosedTypesOf(typeof(IRequestHandler <,>));
}
foreach (var module in AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("Common")))
{
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Service")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Handler")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Provider")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Context")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Helper")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).Where(t => t.Name.EndsWith("Queries")).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(module).AsClosedTypesOf(typeof(IRequestHandler <,>));
}
// MediatR
builder.RegisterAssemblyTypes(typeof(IMediator).GetTypeInfo().Assembly).AsImplementedInterfaces();
// Required by MediatR - for Command/CommandHandler
builder.Register <SingleInstanceFactory>(context =>
{
var componentContext = context.Resolve <IComponentContext>();
return(t => componentContext.TryResolve(t, out var o) ? o : null);
});
// Required by MediatR - for DomainEvent/DomainEventHandler
builder.Register <MultiInstanceFactory>(context =>
{
var componentContext = context.Resolve <IComponentContext>();
return(t =>
{
var resolved = (IEnumerable <object>)componentContext.Resolve(typeof(IEnumerable <>).MakeGenericType(t));
return resolved;
});
});
builder.RegisterInstance(configuration);
builder.RegisterInstance(hostingEnvironment);
builder.Populate(services);
var container = builder.Build();
GlobalConfiguration.Container = container;
return(container.Resolve <IServiceProvider>());
}
private NpgsqlProviderAdapter(
TypeMapper typeMapper,
Type connectionType,
Type dataReaderType,
Type parameterType,
Type commandType,
Type transactionType,
Type dbTypeType,
MappingSchema mappingSchema,
Type npgsqlDateType,
Type npgsqlPointType,
Type npgsqlLSegType,
Type npgsqlBoxType,
Type npgsqlCircleType,
Type npgsqlPathType,
Type npgsqlPolygonType,
Type npgsqlLineType,
Type npgsqlInetType,
Type npgsqlTimeSpanType,
Type npgsqlDateTimeType,
Type npgsqlRangeTType,
Func <string, NpgsqlConnection> connectionCreator,
Action <IDbDataParameter, NpgsqlDbType> dbTypeSetter,
Func <IDbDataParameter, NpgsqlDbType> dbTypeGetter,
bool binaryImporterHasCompleteMethod,
Type npgsqlBinaryImporterType,
Func <IDbConnection, string, NpgsqlBinaryImporter> beginBinaryImport)
{
_typeMapper = typeMapper;
ConnectionType = connectionType;
DataReaderType = dataReaderType;
ParameterType = parameterType;
CommandType = commandType;
TransactionType = transactionType;
_dbTypeType = dbTypeType;
NpgsqlDateType = npgsqlDateType;
NpgsqlPointType = npgsqlPointType;
NpgsqlLSegType = npgsqlLSegType;
NpgsqlBoxType = npgsqlBoxType;
NpgsqlCircleType = npgsqlCircleType;
NpgsqlPathType = npgsqlPathType;
NpgsqlPolygonType = npgsqlPolygonType;
NpgsqlLineType = npgsqlLineType;
NpgsqlInetType = npgsqlInetType;
NpgsqlTimeSpanType = npgsqlTimeSpanType;
NpgsqlDateTimeType = npgsqlDateTimeType;
NpgsqlRangeTType = npgsqlRangeTType;
MappingSchema = mappingSchema;
_connectionCreator = connectionCreator;
SetDbType = dbTypeSetter;
GetDbType = dbTypeGetter;
BinaryImporterHasComplete = binaryImporterHasCompleteMethod;
_npgsqlBinaryImporterType = npgsqlBinaryImporterType;
BeginBinaryImport = beginBinaryImport;
// because NpgsqlDbType enumeration changes often (compared to other providers)
// we should create lookup list of mapped fields, defined in used npgsql version
var dbTypeKnownNames = Enum.GetNames(dbTypeType);
var dbMappedDbTypeNames = Enum.GetNames(typeof(NpgsqlDbType));
foreach (var knownTypeName in from nType in dbTypeKnownNames
join mType in dbMappedDbTypeNames on nType equals mType
select nType)
{
// use setter([]) instead of Add() because enum contains duplicate fields with same values
_knownDbTypes[(NpgsqlDbType)Enum.Parse(typeof(NpgsqlDbType), knownTypeName)] = (int)Enum.Parse(dbTypeType, knownTypeName);
}
}
public void MapComplexType_should_not_map_invalid_structural_type()
{
var model = new EdmModel(DataSpace.CSpace);
var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));
Assert.Null(typeMapper.MapComplexType(typeof(string)));
}
