protected override void Arrange()
{
_compositesMetadataProvider = Stub <ICompositesMetadataProvider>();
var routes = new List <XElement>(OpenApiCompositeHelper.Routes).ToReadOnlyList();
var definitions = new List <XElement>(OpenApiCompositeHelper.CompositeDefinitions).ToReadOnlyList();
A.CallTo(() => _compositesMetadataProvider.TryGetRoutes(
A <string> ._,
A <string> ._,
out routes))
.Returns(true);
A.CallTo(() => _compositesMetadataProvider.TryGetCompositeDefinitions(
A <string> ._,
A <string> ._,
out definitions))
.Returns(true);
_openApiMetadataDocumentContext = new OpenApiMetadataDocumentContext(
_resourceModelProvider.GetResourceModel())
{
CompositeContext = new OpenApiMetadataCompositeContext
{
CategoryName = OpenApiCompositeHelper.CategoryName
}
};
}
public IEnumerable <OpenApiMetadataResource> GetFilteredResources(OpenApiMetadataDocumentContext openApiMetadataDocumentContext)
{
return(openApiMetadataDocumentContext.ResourceModel
.GetAllResources()
.Where(r => r.IsEdFiStandardResource && !r.Entity.IsAbstract)
.Select(r => new OpenApiMetadataResource(r)));
}
protected override void Arrange()
{
_testProfileResourceNamesProvider = new TestProfileResourceNamesProvider();
var studentProgramAssociation = _resourceModelProvider.GetResourceModel()
.GetResourceByFullName(
new FullName(
EdFiConventions
.PhysicalSchemaName,
"StudentProgramAssociation"));
var studentSpecialEducationProgramAssociation = _resourceModelProvider
.GetResourceModel()
.GetResourceByFullName(
new FullName(
EdFiConventions
.PhysicalSchemaName,
"StudentSpecialEducationProgramAssociation"));
_expectedFilteredResources = new[]
{
new OpenApiMetadataResource(studentProgramAssociation)
{
Name = "studentProgramAssociation", Readable = true
},
new OpenApiMetadataResource(studentProgramAssociation)
{
Name = "studentProgramAssociation", Readable = true,
ContextualResource = studentSpecialEducationProgramAssociation
},
new OpenApiMetadataResource(studentProgramAssociation)
{
Name = "studentProgramAssociation_StudentSpecialEducationProgramAssociation", Readable = true,
Writable = true
},
new OpenApiMetadataResource(studentSpecialEducationProgramAssociation)
{
Name = "studentSpecialEducationProgramAssociation", Readable = true, Writable = true
}
};
_schemaNameMapProviderStub = Stub <ISchemaNameMapProvider>();
var profileResourceModel =
new ProfileResourceModel(
_resourceModelProvider.GetResourceModel(),
_testProfileResourceNamesProvider.GetProfileDefinition("ProfileName"));
_openApiMetadataDocumentContext =
new OpenApiMetadataDocumentContext(
_resourceModelProvider.GetResourceModel())
{
ProfileContext =
new OpenApiMetadataProfileContext
{
ProfileName = "ProfileName",
ProfileResourceModel = profileResourceModel
}
};
}
public IEnumerable <OpenApiMetadataResource> GetFilteredResources(OpenApiMetadataDocumentContext openApiMetadataDocumentContext) => openApiMetadataDocumentContext
.ResourceModel
.GetAllResources()
.Where(
x => !x.Entity.IsLookup &&
!x.Entity.IsAbstract)
.Select(
r => new OpenApiMetadataResource(r));
public static OpenApiMetadataTagsFactory CreateOpenApiMetadataTagsFactory(OpenApiMetadataDocumentContext documentContext)
{
var filter = documentContext.RenderType == RenderType.ExtensionArtifactsOnly
? new OpenApiMetadataFactoryResourceFilterSchemaStrategy(documentContext) as
IOpenApiMetadataFactoryResourceFilterStrategy
: new OpenApiMetadataFactoryResourceFilterDefaultStrategy();
return(new OpenApiMetadataTagsFactory(filter));
}
public OpenApiMetadataDefinitionsFactoryDefaultEntityExtensionStrategy(
OpenApiMetadataDocumentContext documentContext,
IOpenApiMetadataDefinitionsFactoryEdFiExtensionBridgeStrategy bridgeStrategy,
IOpenApiMetadataDefinitionsFactoryNamingStrategy namingStrategy)
{
_documentContext = documentContext;
_bridgeStrategy = bridgeStrategy;
_namingStrategy = namingStrategy;
}
protected override void Arrange()
{
_openApiMetadataDocumentContext =
new OpenApiMetadataDocumentContext(
ResourceModelProvider.GetResourceModel())
{
ProfileContext = new OpenApiMetadataProfileContext
{
ProfileName = "Test-ParentNonAbstractBaseClass-ExcludeOnly"
},
RenderType = RenderType.GeneralizedExtensions
};
string profileDefinition = @"<Profile name='Test-ParentNonAbstractBaseClass-ExcludeOnly'>
<Resource name='StudentSpecialEducationProgramAssociation'>
<ReadContentType memberSelection='ExcludeOnly'>
<Property name='SpecialEducationHoursPerWeek'/>
</ReadContentType>
<WriteContentType memberSelection='IncludeAll'/>
</Resource>
<Resource name='StudentProgramAssociation'>
<ReadContentType memberSelection='IncludeOnly'/>
</Resource>
</Profile>";
var profileResourceModel =
new ProfileResourceModel(
ResourceModelProvider.GetResourceModel(),
XElement.Parse(profileDefinition));
var readableResourceModel =
profileResourceModel.ResourceByName.Values.Where(r => r.Readable != null);
var writableResourceModel =
profileResourceModel.ResourceByName.Values.Where(r => r.Writable != null);
_openApiMetadataResources = readableResourceModel
.Select(
r => new OpenApiMetadataResource(r.Readable)
{
Name =
$"{CompositeTermInflector.MakeSingular(r.Readable.Name)}_{ContentTypeUsage.Readable}"
.ToCamelCase(),
Readable = true, IsProfileResource = true
})
.Concat(
writableResourceModel.Select(
r => new OpenApiMetadataResource(r.Writable)
{
Name =
$"{CompositeTermInflector.MakeSingular(r.Writable.Name)}_{ContentTypeUsage.Writable}"
.ToCamelCase(),
Writable = true, IsProfileResource = true
}
))
.ToList();
}
private static IOpenApiMetadataDefinitionsFactoryNamingStrategy GetOpenApiMetadataDefinitionsFactoryNamingStrategy(
OpenApiMetadataDocumentContext openApiMetadataDocumentContext)
{
if (openApiMetadataDocumentContext.IsCompositeContext)
{
return(new OpenApiMetadataDefinitionsFactoryCompositeNamingStrategy());
}
return(openApiMetadataDocumentContext.IsProfileContext
? (IOpenApiMetadataDefinitionsFactoryNamingStrategy) new OpenApiMetadataDefinitionsFactoryProfileNamingStrategy()
: new OpenApiMetadataDefinitionsFactoryDefaultNamingStrategy());
}
// Consider reviewing the conditionals in this file for similarities, that could be used
// to create methods for construction of the underlying strategies for that conditional function segment.
// This would allow for methods like "GetCompositeOpenApiMetadataDefinitionsFactory" or "GetExtensionOnlyOpenApiMetadataDocumentFactory"
// that would create the entire OpenApiMetadataDocumentFactory with the correct strategies for that use case rather
// than using conditional checks on the context.
public static OpenApiMetadataDefinitionsFactory CreateOpenApiMetadataDefinitionsFactory(
OpenApiMetadataDocumentContext openApiMetadataDocumentContext)
{
switch (openApiMetadataDocumentContext.RenderType)
{
case RenderType.GeneralizedExtensions:
var genericStrategy =
new OpenApiMetadataDefinitionsFactoryGenericEdFiExtensionBridgeStrategy(openApiMetadataDocumentContext);
return(new OpenApiMetadataDefinitionsFactory(
new OpenApiMetadataDefinitionsFactoryEmptyEntityExtensionStrategy(),
genericStrategy,
new OpenApiMetadataDefinitionsFactoryDefaultNamingStrategy(),
new OpenApiMetadataFactoryResourceFilterSchemaStrategy(openApiMetadataDocumentContext)));
case RenderType.ExtensionArtifactsOnly:
var genericBridgeStrategy =
new OpenApiMetadataDefinitionsFactoryGenericEdFiExtensionBridgeStrategy(openApiMetadataDocumentContext);
return(new OpenApiMetadataDefinitionsFactory(
new OpenApiMetadataDefinitionsFactoryDefaultEntityExtensionStrategy(
openApiMetadataDocumentContext,
genericBridgeStrategy,
new OpenApiMetadataDefinitionsFactoryDefaultNamingStrategy()),
genericBridgeStrategy,
new OpenApiMetadataDefinitionsFactoryDefaultNamingStrategy(),
new OpenApiMetadataFactoryResourceFilterSchemaStrategy(openApiMetadataDocumentContext)));
default:
var bridgeStrategy =
new OpenApiMetadataDefinitionsFactoryDefaultEdFiExtensionBridgeStrategy(openApiMetadataDocumentContext);
var filterStrategy = new OpenApiMetadataFactoryResourceFilterDefaultStrategy();
var namingStrategy = GetOpenApiMetadataDefinitionsFactoryNamingStrategy(openApiMetadataDocumentContext);
var extensionStrategy = new OpenApiMetadataDefinitionsFactoryDefaultEntityExtensionStrategy(
openApiMetadataDocumentContext,
bridgeStrategy,
namingStrategy);
return(new OpenApiMetadataDefinitionsFactory(
extensionStrategy,
bridgeStrategy,
namingStrategy,
filterStrategy));
}
}
protected override void Arrange()
{
_openApiMetadataDocumentContext = new OpenApiMetadataDocumentContext(
DomainModelDefinitionsProviderHelper
.ResourceModelProvider
.GetResourceModel())
{
RenderType = RenderType.GeneralizedExtensions,
IsIncludedExtension = x => x.FullName.Schema.Equals(EdFiConventions.PhysicalSchemaName)
};
_genericOpenApiMetadataDefinitionFactory =
OpenApiMetadataDocumentFactoryHelper.CreateOpenApiMetadataDefinitionsFactory(
_openApiMetadataDocumentContext);
}
protected override void Arrange()
{
_openApiMetadataDocumentContext = new OpenApiMetadataDocumentContext(
DomainModelDefinitionsProviderHelper
.ResourceModelProvider
.GetResourceModel());
_genericOpenApiMetadataDefinitionFactory =
OpenApiMetadataDocumentFactoryHelper.CreateOpenApiMetadataDefinitionsFactory(
_openApiMetadataDocumentContext);
_domainModelProvider = DomainModelDefinitionsProviderHelper.DomainModelProvider;
_schemaNameMapProvider = _domainModelProvider.GetDomainModel()
.SchemaNameMapProvider;
}
public IEnumerable <OpenApiMetadataResource> GetFilteredResources(OpenApiMetadataDocumentContext openApiMetadataDocumentContext) =>
// Only included extensions or EdFi resources that have one of the included extensions
openApiMetadataDocumentContext.ResourceModel
.GetAllResources()
.Where(
r =>
openApiMetadataDocumentContext.IsIncludedExtension(r) ||
r.IsEdFiStandardResource &&
(r.AllContainedItemTypes.Any(
i =>
i.Extensions.Any(
x => openApiMetadataDocumentContext.IsIncludedExtension(
x.ObjectType))) ||
r.Extensions.Any(
x => openApiMetadataDocumentContext.IsIncludedExtension(x.ObjectType))))
.Select(r => new OpenApiMetadataResource(r));
protected override void Arrange()
{
_openApiMetadataDocumentContext = DomainModelDefinitionsProviderHelper.DefaultopenApiMetadataDocumentContext;
var openApiMetadataResources = _openApiMetadataDocumentContext.ResourceModel.GetAllResources()
.Select(r => new OpenApiMetadataResource(r))
.ToList();
_stubbedOpenApiMetadataResourceStrategy = Stub <IOpenApiMetadataResourceStrategy>();
A.CallTo(() => _stubbedOpenApiMetadataResourceStrategy.GetFilteredResources(A <OpenApiMetadataDocumentContext> ._))
.Returns(openApiMetadataResources);
var defaultPageSizeLimitProvider = new DefaultPageSizeLimitProvider(GetConfiguration());
_openApiMetadataDocumentFactory = new OpenApiMetadataDocumentFactory(
CreateApiSettings(), defaultPageSizeLimitProvider);
}
public static OpenApiMetadataPathsFactory CreateOpenApiMetadataPathsFactory(
OpenApiMetadataDocumentContext openApiMetadataDocumentContext, ApiSettings apiSettings)
{
if (openApiMetadataDocumentContext.IsProfileContext)
{
var profileStrategy = new OpenApiMetadataPathsFactoryProfileStrategy(openApiMetadataDocumentContext);
//Profile strategy implements each of the interfaces in the signature of the paths factory constructor
//Hence the odd parameter repetition.
return(new OpenApiMetadataPathsFactory(profileStrategy, profileStrategy, profileStrategy, apiSettings));
}
IOpenApiMetadataPathsFactorySelectorStrategy selectorStrategy = null;
IOpenApiMetadataPathsFactoryNamingStrategy resourceNamingStrategy = null;
if (openApiMetadataDocumentContext.RenderType == RenderType.ExtensionArtifactsOnly)
{
selectorStrategy = new OpenApiMetadataPathsFactorySchemaSelectorStrategy(openApiMetadataDocumentContext);
}
if (openApiMetadataDocumentContext.IsCompositeContext)
{
selectorStrategy = new OpenApiMetadataCompositePathsFactoryStrategy(openApiMetadataDocumentContext);
resourceNamingStrategy = new OpenApiMetadataPathsFactoryCompositeStrategy();
}
var defaultStrategy = new DefaultOpenApiMetadataPathsFactoryStrategy();
var defaultResourceDefinitionNamingStrategy = new OpenApiMetadataPathsFactoryDefaultStrategy();
IOpenApiMetadataPathsFactoryContentTypeStrategy contentTypeStrategy = defaultStrategy;
selectorStrategy = selectorStrategy ?? defaultStrategy;
resourceNamingStrategy = resourceNamingStrategy ?? defaultResourceDefinitionNamingStrategy;
return(new OpenApiMetadataPathsFactory(selectorStrategy, contentTypeStrategy, resourceNamingStrategy, apiSettings));
}
public OpenApiMetadataCompositePathsFactoryStrategy(OpenApiMetadataDocumentContext openApiMetadataDocumentContext)
{
_openApiMetadataDocumentContext = openApiMetadataDocumentContext;
}
public OpenApiMetadataDefinitionsFactoryGenericEdFiExtensionBridgeStrategy(OpenApiMetadataDocumentContext documentContext)
{
_documentContext = documentContext;
}
public IEnumerable <OpenApiMetadataResource> GetFilteredResources(OpenApiMetadataDocumentContext openApiMetadataDocumentContext)
{
var profileResources =
openApiMetadataDocumentContext.ProfileContext.ProfileResourceModel.ResourceByName.Values
.ToList();
var allResources = profileResources.Where(r => r.Readable != null)
.Select(r => r.Readable)
.Concat(
profileResources.Where(r => r.Writable != null)
.Select(r => r.Writable))
.ToList();
var readableOpenApiMetadataResources =
profileResources.Where(r => r.Readable != null)
.Select(
r => new OpenApiMetadataResource(r.Readable)
{
Name = GetResourceName(r.Readable, ContentTypeUsage.Readable),
Readable = true,
IsProfileResource = true
})
.ToList();
var writableOpenApiMetadataResources =
profileResources.Where(r => r.Writable != null)
.Select(
r => new OpenApiMetadataResource(r.Writable)
{
Name = GetResourceName(r.Writable, ContentTypeUsage.Writable),
Writable = true,
IsProfileResource = true
})
.ToList();
return(readableOpenApiMetadataResources.Concat(writableOpenApiMetadataResources)
.Concat(
readableOpenApiMetadataResources.Select(
r => GetBaseResourceInProfile(
allResources,
r,
ContentTypeUsage.Readable)))
.Concat(
readableOpenApiMetadataResources.Select(
r => GetGenerationContextForSwaggerResource(
allResources,
r,
ContentTypeUsage.Readable)))
.Concat(
writableOpenApiMetadataResources.Select(
r => GetBaseResourceInProfile(
allResources,
r,
ContentTypeUsage.Writable)))
.Concat(
writableOpenApiMetadataResources.Select(
r => GetGenerationContextForSwaggerResource(
allResources,
r,
ContentTypeUsage.Writable)))
.Where(r => r != null));
}
public IEnumerable <OpenApiMetadataResource> GetFilteredResources(OpenApiMetadataDocumentContext openApiMetadataDocumentContext)
{
var compositeContext = openApiMetadataDocumentContext.CompositeContext;
var definitionProcessor =
new CompositeDefinitionProcessor <CompositeResourceModelBuilderContext, Resource>(
new CompositeResourceModelBuilder());
IReadOnlyList <XElement> compositeDefinitions;
if (!_compositesMetadataProvider.TryGetCompositeDefinitions(
compositeContext.OrganizationCode,
compositeContext.CategoryName,
out compositeDefinitions))
{
return(null);
}
var compositeResources = new List <OpenApiMetadataResource>();
foreach (var compositeDefinition in compositeDefinitions)
{
// Enable this for composite xml validation.
definitionProcessor.UseCompositeValidation();
var compositeResource = definitionProcessor.Process(
compositeDefinition,
openApiMetadataDocumentContext.ResourceModel,
new CompositeResourceModelBuilderContext());
compositeResources.Add(
new OpenApiMetadataResource(compositeResource)
{
Readable = true,
CompositeResourceContext = new CompositeResourceContext
{
OrganizationCode = openApiMetadataDocumentContext.CompositeContext.OrganizationCode,
Specification = compositeDefinition.Element("Specification"),
BaseResource = compositeDefinition.Element("BaseResource").AttributeValue("name")
}
});
}
var defaultCompositeRoutes = new List <XElement>
{
XElement.Parse(
"<Route relativeRouteTemplate='/{compositeName}' />"),
XElement.Parse(
"<Route relativeRouteTemplate='/{compositeName}/{id}' />")
};
// Get all route definitions for the category
IReadOnlyList <XElement> routes;
if (!_compositesMetadataProvider.TryGetRoutes(compositeContext.OrganizationCode, compositeContext.CategoryName, out routes))
{
throw new Exception($"Composite category '{compositeContext.CategoryName}' does not have any routes defined.");
}
compositeContext.RouteElements = defaultCompositeRoutes.Concat(routes)
.ToList();
return(compositeResources.ToList());
}
public string Create(IOpenApiMetadataResourceStrategy resourceStrategy, OpenApiMetadataDocumentContext documentContext)
{
try
{
var parametersFactory = new OpenApiMetadataParametersFactory(_defaultPageSizeLimitProvider);
var definitionsFactory =
OpenApiMetadataDocumentFactoryHelper.CreateOpenApiMetadataDefinitionsFactory(documentContext);
var responsesFactory = new OpenApiMetadataResponsesFactory();
var pathsFactory =
OpenApiMetadataDocumentFactoryHelper.CreateOpenApiMetadataPathsFactory(
documentContext, _apiSettings);
var tagsFactory =
OpenApiMetadataDocumentFactoryHelper.CreateOpenApiMetadataTagsFactory(documentContext);
var resources = resourceStrategy.GetFilteredResources(documentContext)
.ToList();
var openApiMetadataDocument = new OpenApiMetadataDocument
{
info = new Info
{
title = "Ed-Fi Operational Data Store API",
version = $"{ApiVersionConstants.Ods}",
description =
"The Ed-Fi ODS / API enables applications to read and write education data stored in an Ed-Fi ODS through a secure REST interface. \n***\n > *Note: Consumers of ODS / API information should sanitize all data for display and storage. The ODS / API provides reasonable safeguards against cross-site scripting attacks and other malicious content, but the platform does not and cannot guarantee that the data it contains is free of all potentially harmful content.* \n***\n"
},
host = "%HOST%",
basePath = "%BASE_PATH%",
securityDefinitions =
new Dictionary <string, SecurityScheme>
{
{
"oauth2_client_credentials", new SecurityScheme
{
type = "oauth2",
description =
"Ed-Fi ODS/API OAuth 2.0 Client Credentials Grant Type authorization",
flow = "application",
tokenUrl = "%TOKEN_URL%",
scopes = new Dictionary <string, string>()
}
}
},
security =
new List <IDictionary <string, IEnumerable <string> > >
{
new Dictionary <string, IEnumerable <string> > {
{ "oauth2_client_credentials", new string[0] }
}
},
consumes = documentContext.IsCompositeContext
? null
: OpenApiMetadataDocumentHelper.GetConsumes(),
produces = OpenApiMetadataDocumentHelper.GetProduces(),
tags = tagsFactory.Create(resources),
paths = pathsFactory.Create(resources, documentContext.IsCompositeContext),
definitions = definitionsFactory.Create(resources),
parameters = parametersFactory.Create(documentContext.IsCompositeContext),
responses = responsesFactory.Create()
};
return(JsonConvert.SerializeObject(
openApiMetadataDocument,
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}));
}
catch (Exception ex)
{
_logger.Error(ex);
throw;
}
}
public OpenApiMetadataPathsFactorySchemaSelectorStrategy(OpenApiMetadataDocumentContext documentContext)
{
_documentContext = documentContext;
}
public OpenApiMetadataFactoryResourceFilterSchemaStrategy(OpenApiMetadataDocumentContext documentContext)
{
_documentContext = documentContext;
}
public OpenApiMetadataPathsFactoryProfileStrategy(OpenApiMetadataDocumentContext documentContext)
{
_documentContext = documentContext;
}
protected override void Arrange()
{
_compositesMetadataProvider = Stub <ICompositesMetadataProvider>();
var definitions = new List <XElement>(OpenApiCompositeHelper.CompositeDefinitions).ToReadOnlyList();
var routes = new List <XElement>(OpenApiCompositeHelper.Routes).ToReadOnlyList();
A.CallTo(
() => _compositesMetadataProvider.TryGetCompositeDefinitions(
A <string> ._,
A <string> ._,
out definitions))
.Returns(true);
A.CallTo(
() => _compositesMetadataProvider.TryGetRoutes(
A <string> ._,
A <string> ._,
out routes))
.Returns(true);
_openApiMetadataDocumentContext = new OpenApiMetadataDocumentContext(
_resourceModelProvider.GetResourceModel())
{
CompositeContext = new OpenApiMetadataCompositeContext
{
CategoryName =
OpenApiCompositeHelper
.CategoryName
}
};
_filteredResources =
new OpenApiCompositeStrategy(_compositesMetadataProvider)
.GetFilteredResources(_openApiMetadataDocumentContext);
var assessmentResource = _resourceModelProvider
.GetResourceModel()
.GetResourceByFullName(new FullName(EdFiConventions.PhysicalSchemaName, "Assessment"));
_expectedStrategyAppliedResources =
OpenApiCompositeHelper.Routes
.Where(r => !IsBaseResourceRoute(r))
.Select(
r => new OpenApiMetadataPathsResource(assessmentResource)
{
CompositeResourceContext =
new CompositeResourceContext(),
Path =
GetCompositeResourcePath(
assessmentResource,
r)
.ToCamelCase(),
OperationId =
GetCompositeResourceOperationId(
assessmentResource,
r),
Readable = true, Writable = false
})
.Concat(
new[]
{
new OpenApiMetadataPathsResource(assessmentResource)
{
CompositeResourceContext = new CompositeResourceContext(), Path =
$"{_openApiMetadataDocumentContext.CompositeContext.CategoryName}/{assessmentResource.PluralName}",
OperationId = "getAssessments", Readable = true, Writable = false
}
});
}
