protected override void Arrange()
{
AssemblyLoader.EnsureLoaded <Marker_EdFi_Ods_Test_TestExtension>();
_registrarStub = mocks.DynamicMock <IEntityExtensionRegistrar>();
_assembliesProviderStub = Stub <IAssembliesProvider>();
_assembliesProviderStub.Stub(x => x.GetAssemblies())
.Return(
new Assembly[]
{
new FakeExtensionAssembly(typeof(Marker_EdFi_Ods_Test_TestExtension))
});
_container = new WindsorContainer();
_domainModelProvider = new DomainModelProvider(
new IDomainModelDefinitionsProvider[]
{
new EdFiDomainModelDefinitionsProvider(), new DomainModelDefinitionsProvider()
});
_container.Register(
Component.For <IDomainModelProvider>()
.Instance(_domainModelProvider));
_configValueStub = Stub <IConfigValueProvider>();
_configValueStub.Stub(x => x.GetValue(ExcludedExtensionSources))
.Return(default(string));
_container.Register(
Component.For <IConfigValueProvider>()
.Instance(_configValueStub));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityExtensionsFactory"/> class, protected so as to implement the Singleton pattern.
/// </summary>
public EntityExtensionsFactory(IEntityExtensionRegistrar entityExtensionRegistrar)
{
_entityExtensionRegistrar = entityExtensionRegistrar;
}
private void RegisterExtensions(Assembly assembly, IEntityExtensionRegistrar registrar, IWindsorContainer container)
{
string extensionAssemblyName = assembly.GetName()
.Name;
var extensionSchemaProperCaseName = ExtensionsConventions.GetProperCaseNameFromAssemblyName(extensionAssemblyName);
var domainModel = container.Resolve <IDomainModelProvider>()
.GetDomainModel();
string schemaPhysicalName = domainModel.SchemaNameMapProvider
.GetSchemaMapByProperCaseName(extensionSchemaProperCaseName)
.PhysicalName;
var extensionsByStandardEntity = domainModel
.Entities
.Where(e => e.Schema.Equals(schemaPhysicalName) && (e.IsEntityExtension || e.IsAggregateExtensionTopLevelEntity))
.Select(
e => new
{
Parent = e.Parent, Entity = e, IsAggregateExtension = e.IsAggregateExtension,
IsEntityExtension = e.IsEntityExtension
})
.GroupBy(x => x.Parent, x => x)
.ToList();
var aggregateExtensionEntities = extensionsByStandardEntity
.SelectMany(x => x)
.Where(x => x.IsAggregateExtension)
.Select(x => x.Entity);
var entityExtensions = extensionsByStandardEntity
.SelectMany(x => x)
.Where(x => x.IsEntityExtension)
.Select(
x => new
{
Entity = x.Entity,
IsRequired = x.Entity.ParentAssociation.Association.Cardinality == Cardinality.OneToOneExtension
});
// Register aggregate extensions
foreach (var aggregateExtensionEntity in aggregateExtensionEntities)
{
string standardTypeName = aggregateExtensionEntity.Parent.EntityTypeFullName(EdFiConventions.ProperCaseName);
var standardType = Type.GetType($"{standardTypeName}, {Namespaces.Standard.BaseNamespace}");
registrar.RegisterAggregateExtensionEntity(standardType, aggregateExtensionEntity);
}
// Register explicit entity extensions
foreach (var entityExtension in entityExtensions)
{
string standardTypeName = entityExtension.Entity.EdFiStandardEntity.EntityTypeFullName(EdFiConventions.ProperCaseName);
var standardType = Type.GetType($"{standardTypeName}, {Namespaces.Standard.BaseNamespace}");
string extensionTypeName = entityExtension.Entity.EntityTypeFullName(extensionSchemaProperCaseName);
var extensionType = Type.GetType($"{extensionTypeName}, {extensionAssemblyName}");
registrar.RegisterEntityExtensionType(standardType, extensionSchemaProperCaseName, extensionType, entityExtension.IsRequired);
}
// Register implicit entity extensions
// Filter down to just the standard entities that have aggregate extensions, but no entity extensions (need implicit extension classes registered)
var implicitlyExtendedEntities = extensionsByStandardEntity
.Where(p => p.Any(x => x.IsAggregateExtension) && !p.Any(x => x.IsEntityExtension));
foreach (var implicitlyExtendedEntity in implicitlyExtendedEntities)
{
string standardTypeName = implicitlyExtendedEntity.Key.EntityTypeFullName(EdFiConventions.ProperCaseName);
var standardType = Type.GetType($"{standardTypeName}, {Namespaces.Standard.BaseNamespace}");
string extensionClassAssemblyQualifiedName =
ExtensionsConventions.GetExtensionClassAssemblyQualifiedName(standardType, extensionSchemaProperCaseName);
var extensionType = Type.GetType(extensionClassAssemblyQualifiedName);
registrar.RegisterEntityExtensionType(standardType, extensionSchemaProperCaseName, extensionType, isRequired: true);
}
}
public EdFiExtensionsInstaller(IAssembliesProvider assembliesProvider, IEntityExtensionRegistrar registrar)
{
_registrar = registrar;
Assemblies = assembliesProvider.GetAssemblies();
}
