/// <summary>
/// Generates tag templates in the desired folder
/// </summary>
/// <param name="singleApiName">name of API to load tag from</param>
/// <param name="multipleApiNames">multiple API names to load tag from</param>
/// <param name="baseFilesGenerationDirectory">name of base folder where to save output files</param>
/// <returns>generated tag template</returns>
public async Task <Template <TagTemplateResources> > GenerateTagTemplateAsync(
string singleApiName,
ApiTemplateResources apiTemplateResources,
ProductTemplateResources productTemplateResources,
string baseFilesGenerationDirectory)
{
this.logger.LogInformation("Started generation of tag template...");
var tagTemplate = await this.tagExtractor.GenerateTagsTemplateAsync(
singleApiName,
apiTemplateResources,
productTemplateResources,
this.extractorParameters);
if (tagTemplate?.HasResources() == true)
{
await FileWriter.SaveAsJsonAsync(
tagTemplate,
directory : baseFilesGenerationDirectory,
fileName : this.extractorParameters.FileNames.Tags);
}
this.logger.LogInformation("Finished generation of tag template...");
return(tagTemplate);
}
async Task <ApiTemplateResources> GenerateMultipleApisTemplateAsync(List <string> multipleApiNames, string baseFilesGenerationDirectory, ExtractorParameters extractorParameters)
{
var generalApiTemplateResourcesStorage = new ApiTemplateResources();
foreach (var apiName in multipleApiNames)
{
var specificApiTemplateResources = await this.GenerateSingleApiTemplateResourcesAsync(apiName, baseFilesGenerationDirectory, extractorParameters);
generalApiTemplateResourcesStorage.AddResourcesData(specificApiTemplateResources);
}
return(generalApiTemplateResourcesStorage);
}
async Task <ApiTemplateResources> GenerateCurrentRevisionApiTemplateResourcesAsync(string apiName, string baseFilesGenerationDirectory, ExtractorParameters extractorParameters)
{
var apiTemplateResources = new ApiTemplateResources();
// gets the current revision of this api and will remove "isCurrent" paramter
var versionedApiResource = await this.GenerateApiTemplateResourceAsVersioned(apiName, extractorParameters);
apiTemplateResources.Apis.Add(versionedApiResource);
var relatedTemplateResources = await this.apiExtractor.GetApiRelatedTemplateResourcesAsync(apiName, baseFilesGenerationDirectory, extractorParameters);
apiTemplateResources.AddResourcesData(relatedTemplateResources);
return(apiTemplateResources);
}
public async Task <Template <TagTemplateResources> > GenerateTagsTemplateAsync(
string singleApiName,
ApiTemplateResources apiTemplateResources,
ProductTemplateResources productTemplateResources,
ExtractorParameters extractorParameters)
{
var tagTemplate = this.templateBuilder
.GenerateTemplateWithApimServiceNameProperty()
.Build <TagTemplateResources>();
// isolate tag and api operation associations in the case of a single api extraction
var apiOperationTagResources = apiTemplateResources.ApiOperationsTags;
// isolate product api associations in the case of a single api extraction
var productAPIResources = apiTemplateResources.ApiProducts;
// isolate tag and product associations in the case of a single api extraction
var productTagResources = productTemplateResources.Tags;
var tags = await this.tagClient.GetAllAsync(extractorParameters);
foreach (var tag in tags)
{
var tagOriginalName = tag.Name;
tag.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{tagOriginalName}')]";
tag.Type = ResourceTypeConstants.Tag;
tag.ApiVersion = GlobalConstants.ApiVersion;
tag.Scale = null;
// only extract the tag if this is a full extraction,
// or in the case of a single api, if it is found in tags associated with the api operations
// or if it is found in tags associated with the api
// or if it is found in tags associated with the products associated with the api
if (string.IsNullOrEmpty(singleApiName) ||
apiOperationTagResources.Any(t => t.Name.Contains($"/{tag}'")) ||
productAPIResources.Any(t => t.Name.Contains($"/{singleApiName}")) &&
productTagResources.Any(t => t.Name.Contains($"/{tagOriginalName}'")))
{
tagTemplate.TypedResources.Tags.Add(tag);
}
}
return(tagTemplate);
}
public async Task <Template <MasterTemplateResources> > GenerateMasterTemplateAsync(
string baseFilesGenerationDirectory,
ApiTemplateResources apiTemplateResources = null,
PolicyTemplateResources policyTemplateResources = null,
ApiVersionSetTemplateResources apiVersionSetTemplateResources = null,
ProductTemplateResources productsTemplateResources = null,
ProductApiTemplateResources productApisTemplateResources = null,
TagApiTemplateResources apiTagsTemplateResources = null,
LoggerTemplateResources loggersTemplateResources = null,
BackendTemplateResources backendsTemplateResources = null,
AuthorizationServerTemplateResources authorizationServersTemplateResources = null,
NamedValuesResources namedValuesTemplateResources = null,
TagTemplateResources tagTemplateResources = null)
{
if (string.IsNullOrEmpty(this.extractorParameters.LinkedTemplatesBaseUrl))
{
this.logger.LogInformation("'{0}' is not passed. Skipping master-template generation.", nameof(this.extractorParameters.LinkedTemplatesBaseUrl));
return(null);
}
this.logger.LogInformation("Started generation of master template...");
var masterTemplate = this.masterTemplateExtractor.GenerateLinkedMasterTemplate(
this.extractorParameters, apiTemplateResources, policyTemplateResources, apiVersionSetTemplateResources,
productsTemplateResources, productApisTemplateResources, apiTagsTemplateResources, loggersTemplateResources,
backendsTemplateResources, authorizationServersTemplateResources, namedValuesTemplateResources, tagTemplateResources);
if (masterTemplate?.HasResources() == true)
{
await FileWriter.SaveAsJsonAsync(
masterTemplate,
directory : baseFilesGenerationDirectory,
fileName : this.extractorParameters.FileNames.LinkedMaster);
}
this.logger.LogInformation("Finished generation of master template...");
return(masterTemplate);
}
public Template <MasterTemplateResources> GenerateLinkedMasterTemplate(
ExtractorParameters extractorParameters,
ApiTemplateResources apiTemplateResources = null,
PolicyTemplateResources policyTemplateResources = null,
ApiVersionSetTemplateResources apiVersionSetTemplateResources = null,
ProductTemplateResources productsTemplateResources = null,
ProductApiTemplateResources productAPIsTemplateResources = null,
TagApiTemplateResources apiTagsTemplateResources = null,
LoggerTemplateResources loggersTemplateResources = null,
BackendTemplateResources backendsTemplateResources = null,
AuthorizationServerTemplateResources authorizationServersTemplateResources = null,
NamedValuesResources namedValuesTemplateResources = null,
TagTemplateResources tagTemplateResources = null)
{
var masterTemplate = this.templateBuilder
.GenerateEmptyTemplate()
.Build <MasterTemplateResources>();
masterTemplate.Parameters = this.CreateMasterTemplateParameters(extractorParameters);
var masterResources = masterTemplate.TypedResources;
var fileNames = extractorParameters.FileNames;
// all other deployment resources will depend on named values
var dependsOnNamedValues = Array.Empty <string>();
// api dependsOn
var apiDependsOn = new List <string>();
var productApiDependsOn = new List <string>();
var apiTagDependsOn = new List <string>();
if (namedValuesTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding named-values to master template");
const string NamedValuesTemplateName = "namedValuesTemplate";
dependsOnNamedValues = new string[] { $"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{NamedValuesTemplateName}')]" };
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{NamedValuesTemplateName}')]");
var namedValuesUri = this.GenerateLinkedTemplateUri(fileNames.NamedValues, extractorParameters);
var namedValuesDeployment = CreateLinkedMasterTemplateResourceForPropertyTemplate(
NamedValuesTemplateName,
namedValuesUri,
Array.Empty <string>(),
extractorParameters);
masterResources.DeploymentResources.Add(namedValuesDeployment);
}
if (policyTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding policy to master template");
const string GlobalServicePolicyTemplate = "globalServicePolicyTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{GlobalServicePolicyTemplate}')]");
var globalServicePolicyUri = this.GenerateLinkedTemplateUri(fileNames.GlobalServicePolicy, extractorParameters);
var policyDeployment = CreateLinkedMasterTemplateResourceWithPolicyToken(
GlobalServicePolicyTemplate,
globalServicePolicyUri,
dependsOnNamedValues,
extractorParameters);
masterResources.DeploymentResources.Add(policyDeployment);
}
if (apiVersionSetTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding api-version-set to master template");
const string VersionSetTemplate = "versionSetTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{VersionSetTemplate}')]");
string apiVersionSetUri = this.GenerateLinkedTemplateUri(fileNames.ApiVersionSets, extractorParameters);
var apiVersionSetDeployment = CreateLinkedMasterTemplateResource(VersionSetTemplate, apiVersionSetUri, dependsOnNamedValues);
masterResources.DeploymentResources.Add(apiVersionSetDeployment);
}
if (productsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding products to master template");
const string ProductsTemplate = "productsTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ProductsTemplate}')]");
productApiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ProductsTemplate}')]");
var productsUri = this.GenerateLinkedTemplateUri(fileNames.Products, extractorParameters);
var productDeployment = CreateLinkedMasterTemplateResource(ProductsTemplate, productsUri, dependsOnNamedValues);
if (!string.IsNullOrEmpty(extractorParameters.PolicyXMLBaseUrl))
{
productDeployment.Properties.Parameters.Add(ParameterNames.PolicyXMLBaseUrl, new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.PolicyXMLBaseUrl}')]"
});
}
if (!string.IsNullOrEmpty(extractorParameters.PolicyXMLSasToken))
{
productDeployment.Properties.Parameters.Add(ParameterNames.PolicyXMLSasToken, new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.PolicyXMLSasToken}')]"
});
}
masterResources.DeploymentResources.Add(productDeployment);
}
if (tagTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding tags to master template");
const string TagTemplate = "tagTemplate";
apiTagDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{TagTemplate}')]");
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{TagTemplate}')]");
var tagUri = this.GenerateLinkedTemplateUri(fileNames.Tags, extractorParameters);
var tagDeployment = CreateLinkedMasterTemplateResource(TagTemplate, tagUri, dependsOnNamedValues);
masterResources.DeploymentResources.Add(tagDeployment);
}
if (loggersTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding loggers to master template");
const string LoggersTemplate = "loggersTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{LoggersTemplate}')]");
string loggersUri = this.GenerateLinkedTemplateUri(fileNames.Loggers, extractorParameters);
var loggersDeployment = CreateLinkedMasterTemplateResourceForLoggerTemplate(LoggersTemplate, loggersUri, dependsOnNamedValues, extractorParameters);
masterResources.DeploymentResources.Add(loggersDeployment);
}
if (backendsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding backends to master template");
const string BackendsTemplate = "backendsTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{BackendsTemplate}')]");
string backendsUri = this.GenerateLinkedTemplateUri(fileNames.Backends, extractorParameters);
var backendsDeployment = CreateLinkedMasterTemplateResource(BackendsTemplate, backendsUri, dependsOnNamedValues);
if (extractorParameters.ParameterizeBackend)
{
backendsDeployment.Properties.Parameters.Add(ParameterNames.BackendSettings,
new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.BackendSettings}')]"
});
}
masterResources.DeploymentResources.Add(backendsDeployment);
}
if (authorizationServersTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding authorizationServers to master template");
const string AuthorizationServersTemplate = "authorizationServersTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{AuthorizationServersTemplate}')]");
var authorizationServersUri = this.GenerateLinkedTemplateUri(fileNames.AuthorizationServers, extractorParameters);
var authorizationServersDeployment = CreateLinkedMasterTemplateResource(AuthorizationServersTemplate, authorizationServersUri, dependsOnNamedValues);
masterResources.DeploymentResources.Add(authorizationServersDeployment);
}
if (apiTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding apis to master template");
const string ApisTemplate = "apisTemplate";
apiTagDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ApisTemplate}')]");
productApiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ApisTemplate}')]");
var apisUri = this.GenerateLinkedTemplateUri(apiTemplateResources.FileName, extractorParameters);
var apisDeployment = CreateLinkedMasterTemplateResourceForApiTemplate(ApisTemplate, apisUri, apiDependsOn.ToArray(), extractorParameters);
masterResources.DeploymentResources.Add(apisDeployment);
}
if (productAPIsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding productApis to master template");
const string ProductApisTemplate = "productAPIsTemplate";
var productApisUri = this.GenerateLinkedTemplateUri(fileNames.ProductAPIs, extractorParameters);
var productApisDeployment = CreateLinkedMasterTemplateResource(ProductApisTemplate, productApisUri, productApiDependsOn.ToArray());
masterResources.DeploymentResources.Add(productApisDeployment);
}
if (apiTagsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding apiTags to master template");
const string ApiTagsTemplate = "apiTagsTemplate";
var apiTagsUri = this.GenerateLinkedTemplateUri(fileNames.TagApi, extractorParameters);
var apiTagsDeployment = CreateLinkedMasterTemplateResource(ApiTagsTemplate, apiTagsUri, apiTagDependsOn.ToArray());
masterResources.DeploymentResources.Add(apiTagsDeployment);
}
return(masterTemplate);
}
/// <summary>
/// Adds related API Template resources like schemas, operations, products, tags etc.
/// </summary>
/// <param name="apiName">The name of the API.</param>
/// <param name="extractorParameters">The extractor.</param>
/// <returns></returns>
public async Task <ApiTemplateResources> GetApiRelatedTemplateResourcesAsync(string apiName, string baseFilesGenerationDirectory, ExtractorParameters extractorParameters)
{
var apiTemplateResources = new ApiTemplateResources();
var apiSchemaResources = await this.apiSchemaExtractor.GenerateApiSchemaResourcesAsync(apiName, extractorParameters);
if (apiSchemaResources?.ApiSchemas.IsNullOrEmpty() == false)
{
apiTemplateResources.ApiSchemas = apiSchemaResources.ApiSchemas;
}
var apiDiagnosticResources = await this.diagnosticExtractor.GetApiDiagnosticsResourcesAsync(apiName, extractorParameters);
if (!apiDiagnosticResources.IsNullOrEmpty())
{
apiTemplateResources.Diagnostics = apiDiagnosticResources;
}
var apiPolicyResource = await this.policyExtractor.GenerateApiPolicyResourceAsync(apiName, baseFilesGenerationDirectory, extractorParameters);
if (apiPolicyResource is not null)
{
apiTemplateResources.ApiPolicies.Add(apiPolicyResource);
}
var apiProducts = await this.productApisExtractor.GenerateSingleApiTemplateAsync(apiName, extractorParameters, addDependsOnParameter : true);
if (!apiProducts.IsNullOrEmpty())
{
apiTemplateResources.ApiProducts = apiProducts;
}
var apiTags = await this.tagExtractor.GenerateTagResourcesLinkedToApiAsync(apiName, extractorParameters);
if (!apiTags.IsNullOrEmpty())
{
apiTemplateResources.Tags = apiTags;
}
var apiOperations = await this.apiOperationExtractor.GenerateApiOperationsResourcesAsync(apiName, extractorParameters);
if (!apiOperations.IsNullOrEmpty())
{
apiTemplateResources.ApiOperations = apiOperations;
}
foreach (var apiOperation in apiOperations)
{
var apiOperationPolicy = await this.policyExtractor.GenerateApiOperationPolicyResourceAsync(apiName, apiOperation.OriginalName, baseFilesGenerationDirectory, extractorParameters);
if (apiOperationPolicy is not null)
{
apiTemplateResources.ApiOperationsPolicies.Add(apiOperationPolicy);
}
var apiOperationTags = await this.tagExtractor.GenerateTagResourcesLinkedToApiOperationAsync(apiName, apiOperation.OriginalName, extractorParameters);
if (!apiOperationTags.IsNullOrEmpty())
{
apiTemplateResources.ApiOperationsTags.AddRange(apiOperationTags);
}
}
return(apiTemplateResources);
}
