/// <summary>
/// Gets the assembly qualified name of the extension class name to be used for deserialization.
/// </summary>
/// <param name="extensionName">The name of the extension.</param>
/// <returns>The assembly qualified name of the extension class name to be used for deserialization.</returns>
protected virtual string GetExtensionClassAssemblyQualifiedName(string extensionName)
{
return(ExtensionsConventions.GetExtensionResourceClassAssemblyQualifiedName(
extensionName,
_resourceName,
_resourceClassName));
}
/// <summary>
/// Registers an Ed-Fi entity extension type to enable the creation of aggregate extension entries during entity initialization.
/// </summary>
/// <param name="edFiStandardEntityType">The type of the Ed-Fi Standard entity.</param>
/// <param name="aggregateExtensionEntity">The <see cref="Entity" /> representing the Ed-Fi extension entity added to an Ed-Fi standard aggregate.</param>
public void RegisterAggregateExtensionEntity(Type edFiStandardEntityType, Entity aggregateExtensionEntity)
{
if (!edFiStandardEntityType.IsSubclassOf(typeof(EntityWithCompositeKey)))
{
throw new ArgumentException($"{nameof(edFiStandardEntityType)} is not an entity Type.", nameof(edFiStandardEntityType));
}
if (!aggregateExtensionEntity.IsAggregateExtension)
{
throw new Exception($"{nameof(aggregateExtensionEntity)} is not an aggregate extension entity.");
}
_aggregateExtensionEntityNamesByType.AddOrUpdate(
edFiStandardEntityType,
t => new List <string>
{
ExtensionsConventions.GetAggregateExtensionMemberName(aggregateExtensionEntity)
},
(t, n) =>
{
string extensionCollectionName = ExtensionsConventions.GetAggregateExtensionMemberName(aggregateExtensionEntity);
n.Add(extensionCollectionName);
return(n);
});
}
public AssemblyData CreateAssemblyData(string assemblyMetadataPath)
{
var assemblyMetadata = _jsonFileProvider.Load <AssemblyMetadata>(assemblyMetadataPath);
bool isExtension = assemblyMetadata.AssemblyModelType.EqualsIgnoreCase(TemplateSetConventions.Extension);
string assemblyName = GetAssemblyName(assemblyMetadataPath);
var schemaName = isExtension
? ExtensionsConventions.GetProperCaseNameForLogicalName(
_domainModelsDefinitionsProvidersByProjectName[assemblyName]
.GetDomainModelDefinitions()
.SchemaDefinition.LogicalName)
: EdFiConventions.ProperCaseName;
var assemblyData = new AssemblyData
{
AssemblyName = assemblyName,
Path = Path.GetDirectoryName(assemblyMetadataPath),
TemplateSet = assemblyMetadata.AssemblyModelType,
IsProfile = assemblyMetadata.AssemblyModelType.EqualsIgnoreCase(TemplateSetConventions.Profile),
SchemaName = schemaName,
IsExtension = isExtension
};
return(assemblyData);
}
public virtual void Install(IWindsorContainer container, IConfigurationStore store)
{
// Register extension assemblies based on naming convention
var extensionAssemblies = Assemblies.Where(ExtensionsConventions.IsExtensionAssembly)
.ToList();
// Exclude any extension assemblies specified by configuration
var excludedExtensionSourcesValue = container.Resolve <IConfigValueProvider>()
.GetValue(ExcludedExtensionSourcesKey);
if (!string.IsNullOrWhiteSpace(excludedExtensionSourcesValue))
{
extensionAssemblies = extensionAssemblies
.Where(
a => !excludedExtensionSourcesValue.Split(',')
.Contains(
ExtensionsConventions.GetProperCaseNameFromAssemblyName(
a.GetName()
.Name)))
.ToList();
}
// Ensure all the domain model definitions are registered before handling any other extension concerns
extensionAssemblies.ForEach(a => RegisterIDomainModelDefinitionsProvider(a, container));
extensionAssemblies.ForEach(
a =>
{
RegisterExtensions(a, _registrar, container);
RegisterExtensionNHibernateConfigurationProvider(a, container);
RegisterControllers(a, container);
}
);
}
private Common.Models.Resource.Resource GetDomainResourceFor(Resource resource)
{
string schemaProperCaseNameOrDefault =
ExtensionsConventions.GetProperCaseNameForLogicalName(resource.logicalSchema ?? EdFiConventions.ProperCaseName);
bool IsSchemaMatch(ResourceClassBase r) => r.SchemaProperCaseName.EqualsIgnoreCase(schemaProperCaseNameOrDefault);
bool IsNameMatch(ResourceClassBase r) => r.Name.EqualsIgnoreCase(resource.name);
bool IsFullNameMatch(ResourceClassBase r) => IsSchemaMatch(r) && IsNameMatch(r);
return(ResourceModel.GetAllResources()
.FirstOrDefault(IsFullNameMatch));
}
protected override void Act()
{
var domainModel =
new DomainModelProvider(
new IDomainModelDefinitionsProvider[]
{
new DomainModelDefinitionsProvider(), new EdFiDomainModelDefinitionsProvider()
}).GetDomainModel();
ExtensionsConventions.GetAggregateExtensionMemberName(
domainModel.Entities.FirstOrDefault(e => e.Name == "StaffLeaveExtension"));
}
protected override void Act()
{
_expectedResult = "TestExtension_StaffLeaveReasons";
var domainModel =
new DomainModelProvider(
new IDomainModelDefinitionsProvider[]
{
new DomainModelDefinitionsProvider(), new EdFiDomainModelDefinitionsProvider()
}).GetDomainModel();
_actualResult = ExtensionsConventions.GetAggregateExtensionMemberName(
domainModel.Entities.FirstOrDefault(e => e.Name == "StaffLeaveReason"));
}
private List <IDomainModelDefinitionsProvider> GetDomainModelDefinitionProviders(string schemaName)
{
return(_domainModelDefinitionProviders
.Value
.Where(
x => schemaName
.EqualsIgnoreCase(
ExtensionsConventions.GetProperCaseNameForLogicalName(
x.GetDomainModelDefinitions()
.SchemaDefinition.LogicalName)) ||
x.GetDomainModelDefinitions()
.SchemaDefinition.LogicalName.EqualsIgnoreCase(EdFiConventions.LogicalName))
.ToList());
}
public virtual void Should_return_correctly_constructed_aggregate_extension_dictionary_when_CreateAggregateExtensions_is_called()
{
var expectedAggregateExtensionMemberName =
ExtensionsConventions.GetAggregateExtensionMemberName(_aggregateExtensionEntity);
AssertHelper.All(
() =>
Assert.That(
_aggregateExtensionInstances.Keys.First(),
Is.EqualTo(expectedAggregateExtensionMemberName),
$"Aggregate extension dictionary key does not match expected value: {expectedAggregateExtensionMemberName}"),
() =>
Assert.That(
(IList)_aggregateExtensionInstances[expectedAggregateExtensionMemberName],
Is.EquivalentTo(new List <object>()),
"Aggregate extension dictionary does not contain empty List<object>."));
}
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);
}
private SchemaNameMap CreateNameMap(string logicalName, string physicalName)
{
if (string.IsNullOrWhiteSpace(logicalName))
{
throw new ArgumentException($"{nameof(logicalName)} must contain a non-zero length string.", nameof(logicalName));
}
if (string.IsNullOrWhiteSpace(physicalName))
{
throw new ArgumentException($"{nameof(physicalName)} must contain a non-zero length string.", nameof(physicalName));
}
return(new SchemaNameMap(
logicalName,
physicalName,
CreateUriSegment(logicalName),
ExtensionsConventions.GetProperCaseNameForLogicalName(logicalName)));
}
public IEnumerable <AssemblyData> Get()
{
// Convention based location of extensions (backwards compatibility)
var legacyExtensionPath = _codeRepositoryProvider.GetResolvedCodeRepositoryByName(
CodeRepositoryConventions.Implementation,
CodeRepositoryConventions.Application);
var assemblyData = Directory.GetFiles(
legacyExtensionPath,
ExtensionsSearchString,
SearchOption.AllDirectories)
.Select(
x =>
{
string assemblyName = _assemblyDataHelper.GetAssemblyName(x);
string schemaName = ExtensionsConventions.GetProperCaseNameForLogicalName(
_domainModelsDefinitionsProvidersByProjectName[assemblyName]
.GetDomainModelDefinitions()
.SchemaDefinition
.LogicalName);
return(new AssemblyData
{
Path = Path.GetDirectoryName(x),
TemplateSet = TemplateSetConventions.Extension,
AssemblyName = assemblyName,
IsExtension = true,
IsProfile = false,
SchemaName = schemaName
});
}).ToList();
assemblyData.ForEach(x => _logger.Debug($"Found file matching '{ExtensionsSearchString}' at '{x.Path}'"));
return(assemblyData);
}
protected override void Act()
{
string logicalName = "Ed-Fi";
_actualResult = ExtensionsConventions.GetProperCaseNameForLogicalName(logicalName);
}
protected override void Act()
{
string extensionName = "GrandBend";
_actualResult = ExtensionsConventions.GetProperCaseNameForLogicalName(extensionName);
}
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);
}
}
protected override void Act()
{
string extensionAssemblyName = $"{Namespaces.Extensions.BaseNamespace}.GrandBend";
_actualResult = ExtensionsConventions.GetProperCaseNameFromAssemblyName(extensionAssemblyName);
}
/// <summary>
/// Gets the name, by convention, that would be used for an entity extension of the entity.
/// </summary>
/// <param name="entity">The Entity whose entity extension class name is to be constructed, by convention.</param>
/// <returns>The entity extension class name.</returns>
public static string GetExtensionClassName(this Entity entity)
{
return(ExtensionsConventions.GetExtensionClassName(entity.Name));
}
protected override void Act()
{
_expectedResult = "StaffExtension";
_actualResult = ExtensionsConventions.GetExtensionClassName("Staff");
}
public override void ApplyConfigurationSpecificRegistrations(ContainerBuilder builder)
{
var installedExtensionAssemblies =
AssemblyLoadContext.Default.Assemblies
.Where(
a => a.IsExtensionAssembly() &&
!ApiSettings.ExcludedExtensions.Contains(
ExtensionsConventions.GetProperCaseNameFromAssemblyName(a.GetName().Name), StringComparer.InvariantCultureIgnoreCase))
.Distinct(new AssemblyComparer())
.ToList();
builder.RegisterType <EntityExtensionsFactory>()
.As <IEntityExtensionsFactory>()
.SingleInstance();
builder.RegisterType <EntityExtensionRegistrar>()
.WithParameter(new TypedParameter(typeof(IEnumerable <Assembly>), installedExtensionAssemblies))
.As <IEntityExtensionRegistrar>()
.SingleInstance();
installedExtensionAssemblies.ForEach(
assembly =>
{
var assemblyName = assembly.GetName().Name;
builder.RegisterType <DomainModelDefinitionsJsonEmbeddedResourceProvider>()
.WithParameter("sourceAssembly", assembly)
.As <IDomainModelDefinitionsProvider>()
.SingleInstance();
builder.RegisterType <ExtensionNHibernateConfigurationProvider>()
.WithParameter("assemblyName", assemblyName)
.As <IExtensionNHibernateConfigurationProvider>()
.SingleInstance();
var relationshipContextDataProviderTypes = assembly.GetTypes()
.Where(
t => !t.IsAbstract && typeof(IRelationshipsAuthorizationContextDataProvider <,>).IsAssignableFromGeneric(t))
.ToList();
var contextDataType = typeof(RelationshipsAuthorizationContextData);
foreach (var providerType in relationshipContextDataProviderTypes)
{
var partiallyClosedInterfaceType =
providerType.GetInterfaces()
.SingleOrDefault(i => i.Name == typeof(IRelationshipsAuthorizationContextDataProvider <,>).Name);
var modelType = partiallyClosedInterfaceType?.GetGenericArguments()[0];
var closedInterfaceType =
typeof(IRelationshipsAuthorizationContextDataProvider <,>)
.MakeGenericType(modelType, contextDataType);
var closedServiceType =
providerType
.MakeGenericType(contextDataType);
builder.RegisterType(closedServiceType).As(closedInterfaceType)
.SingleInstance();
}
});
}
protected override void Act()
{
string extensionName = "Staff";
_actualResult = ExtensionsConventions.GetExtensionResourceClassAssemblyQualifiedName(extensionName, "TalentMgmt", "TestStaff");
}
