private static object DoCreateTargetExtensionObject(Type targetType, string extensionName)
{
// Get target extension type
var targetExtensionType = _extensionTypeByExtensionKey.GetOrAdd(
new ExtensionKey(targetType, extensionName),
key =>
{
string assemblyQualifiedName =
ExtensionsConventions.GetExtensionClassAssemblyQualifiedName(key.EdFiStandardType, key.ExtensionName);
return(Type.GetType(assemblyQualifiedName));
});
// Create the target extension object
return(targetExtensionType != null
? Activator.CreateInstance(targetExtensionType)
: null);
}
protected override void Act()
{
_actualResult = ExtensionsConventions.GetExtensionClassAssemblyQualifiedName(typeof(StaffResource), "GrandBend");
}
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);
}
}