public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(CreatorConfig creatorConfig)
{
// used to create the parameter metatadata, etc (not value) for use in file with resources
// add parameters with metadata properties
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
Metadata = new TemplateParameterMetadata()
{
Description = "Name of the API Management"
},
Type = "string"
};
parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties);
// add remote location of template files for linked option
if (creatorConfig.linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
Metadata = new TemplateParameterMetadata()
{
Description = "Base URL of the repository"
},
Type = "string"
};
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties);
if (creatorConfig.linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
Metadata = new TemplateParameterMetadata()
{
Description = "Query string for the URL of the repository"
},
Type = "string"
};
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties);
}
}
// add serviceUrl parameter for linked option
if (creatorConfig.serviceUrlParameters != null && creatorConfig.serviceUrlParameters.Count > 0)
{
foreach (var serviceUrlProperty in creatorConfig.serviceUrlParameters)
{
TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties()
{
Metadata = new TemplateParameterMetadata()
{
Description = "ServiceUrl parameter for API: " + serviceUrlProperty.ApiName
},
Type = "string"
};
parameters.Add(serviceUrlProperty.ApiName + "-ServiceUrl", serviceUrlParamProperty);
}
}
return(parameters);
}
public Template CreateMasterTemplateParameterValues(string apimServiceName, string linkedTemplatesBaseUrl, string policyXMLBaseUrl)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = GenerateEmptyTemplate();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = apimServiceName
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
if (linkedTemplatesBaseUrl != null)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = linkedTemplatesBaseUrl
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
}
if (policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
value = policyXMLBaseUrl
};
parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlProperties);
}
masterTemplate.parameters = parameters;
return(masterTemplate);
}
public Template CreateMasterTemplateParameterValues(CreatorConfig creatorConfig)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = CreateEmptyParameters();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = creatorConfig.apimServiceName
};
parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties);
if (creatorConfig.linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = creatorConfig.linkedTemplatesBaseUrl
};
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties);
if (creatorConfig.linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
value = creatorConfig.linkedTemplatesUrlQueryString
};
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties);
}
}
masterTemplate.parameters = parameters;
return(masterTemplate);
}
public Template GenerateEmptyTemplateWithParameters(string policyXMLBaseUrl, string policyXMLSasToken)
{
Template armTemplate = GenerateEmptyTemplate();
armTemplate.parameters = new Dictionary <string, TemplateParameterProperties> {
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
if (policyXMLBaseUrl != null && policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add("PolicyXMLSasToken", policyTemplateSasTokenParameterProperties);
}
if (policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlParameterProperties);
}
return(armTemplate);
}
public Template CreateMasterTemplateParameterValues(string apimServiceName, string linkedTemplatesBaseUrl, string linkedTemplatesSasToken, string linkedTemplatesUrlQueryString, string policyXMLBaseUrl, string policyXMLSasToken)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = GenerateEmptyTemplate();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = apimServiceName
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
if (linkedTemplatesBaseUrl != null)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = linkedTemplatesBaseUrl
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
// add linkedTemplatesSasToken parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (linkedTemplatesSasToken != null)
{
TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties()
{
value = linkedTemplatesSasToken
};
parameters.Add("LinkedTemplatesSasToken", linkedTemplatesSasTokenProperties);
}
// add linkedTemplatesUrlQueryString parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
value = linkedTemplatesUrlQueryString
};
parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties);
}
}
if (policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
value = policyXMLBaseUrl
};
parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlProperties);
// add policyXMLSasToken parameter if provided and if the user has provided a policyXMLBaseUrl
if (policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenProperties = new TemplateParameterProperties()
{
value = policyXMLSasToken
};
parameters.Add("PolicyXMLSasToken", policyTemplateSasTokenProperties);
}
}
masterTemplate.parameters = parameters;
return(masterTemplate);
}
public Template CreateMasterTemplateParameterValues(DeploymentDefinition creatorConfig)
{
var masterTemplate = EmptyTemplate;
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = creatorConfig.ApimServiceName
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = creatorConfig.LinkedTemplatesBaseUrl
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
if (creatorConfig.LinkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
value = creatorConfig.LinkedTemplatesUrlQueryString
};
parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties);
}
masterTemplate.Parameters = parameters;
return(masterTemplate);
}
public Template CreateMasterTemplateParameterValues(CreatorConfig creatorConfig)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = creatorConfig.apimServiceName
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
if (creatorConfig.linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = creatorConfig.linkedTemplatesBaseUrl
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
}
masterTemplate.parameters = parameters;
return(masterTemplate);
}
public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(bool linked)
{
// used to create the parameter metatadata, etc (not value) for use in file with resources
// add parameters with metatdata properties
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Name of the API Management"
},
type = "string"
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
if (linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Base URL of the repository"
},
type = "string"
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
}
return(parameters);
}
public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(bool linked, string linkedTemplatesUrlQueryString, string policyXMLBaseUrl)
{
// used to create the parameter metatadata, etc (not value) for use in file with resources
// add parameters with metatdata properties
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Name of the API Management"
},
type = "string"
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
// add remote location of template files for linked option
if (linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Base URL of the repository that contains the generated templates"
},
type = "string"
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
// add linkedTemplatesUrlQueryString parameter if provided and if the templates are linked
if (linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Query string for the URL of the repository"
},
type = "string"
};
parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties);
}
}
if (policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Base URL of the repository that contains the generated policy files"
},
type = "string"
};
parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlProperties);
}
return(parameters);
}
public TemplateBuilder AddParameterizeBackendProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeBackend)
{
TemplateParameterProperties extractBackendParametersProperties = new TemplateParameterProperties()
{
Type = "object"
};
this.template.Parameters.Add(ParameterNames.BackendSettings, extractBackendParametersProperties);
}
return(this);
}
public TemplateBuilder AddParameterizeLogResourceIdProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeLogResourceId)
{
TemplateParameterProperties loggerResourceIdParameterProperties = new TemplateParameterProperties()
{
Type = "object"
};
this.template.Parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdParameterProperties);
}
return(this);
}
public TemplateBuilder AddParameterizeNamedValuesKeyVaultSecretParameters(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParamNamedValuesKeyVaultSecrets)
{
TemplateParameterProperties keyVaultNamedValueParameterProperties = new TemplateParameterProperties()
{
Type = "object"
};
this.template.Parameters.Add(ParameterNames.NamedValueKeyVaultSecrets, keyVaultNamedValueParameterProperties);
}
return(this);
}
public TemplateBuilder AddParameterizeNamedValueParameters(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeNamedValue)
{
TemplateParameterProperties namedValueParameterProperties = new TemplateParameterProperties()
{
Type = "object"
};
this.template.Parameters.Add(ParameterNames.NamedValues, namedValueParameterProperties);
}
return(this);
}
public TemplateBuilder AddParameterizeApiLoggerIdProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeApiLoggerId)
{
TemplateParameterProperties apiLoggerProperty = new TemplateParameterProperties()
{
type = "object"
};
this.template.Parameters.Add(ParameterNames.ApiLoggerId, apiLoggerProperty);
}
return(this);
}
public TemplateBuilder AddParameterizeServiceUrlProperty(ExtractorParameters extractorParameters)
{
if (extractorParameters.ParameterizeServiceUrl || extractorParameters.ServiceUrlParameters != null && extractorParameters.ServiceUrlParameters.Length > 0)
{
TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties()
{
type = "object"
};
this.template.Parameters.Add(ParameterNames.ServiceUrl, serviceUrlParamProperty);
}
return(this);
}
public Template CreateMasterTemplateParameterValues(CreatorConfig creatorConfig)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = this.templateBuilder.GenerateEmptyTemplate().Build();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
Value = creatorConfig.apimServiceName
};
parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties);
if (creatorConfig.linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
Value = creatorConfig.linkedTemplatesBaseUrl
};
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties);
if (creatorConfig.linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
Value = creatorConfig.linkedTemplatesUrlQueryString
};
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties);
}
}
if (creatorConfig.serviceUrlParameters != null && creatorConfig.serviceUrlParameters.Count > 0)
{
foreach (var serviceUrlProperty in creatorConfig.serviceUrlParameters)
{
TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties()
{
Value = serviceUrlProperty.ServiceUrl
};
parameters.Add(serviceUrlProperty.ApiName + "-ServiceUrl", serviceUrlParamProperty);
}
}
masterTemplate.Parameters = parameters;
return(masterTemplate);
}
public Template GenerateEmptyApiTemplateWithParameters(Extractor exc)
{
Template armTemplate = GenerateEmptyTemplate();
armTemplate.parameters = new Dictionary <string, TemplateParameterProperties> {
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} }
};
if (exc.policyXMLBaseUrl != null && exc.policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties);
}
if (exc.policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties);
}
if (exc.paramServiceUrl || (exc.serviceUrlParameters != null && exc.serviceUrlParameters.Length > 0))
{
TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.parameters.Add(ParameterNames.ServiceUrl, serviceUrlParamProperty);
}
if (exc.paramApiLoggerId)
{
TemplateParameterProperties apiLoggerProperty = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.parameters.Add(ParameterNames.ApiLoggerId, apiLoggerProperty);
}
return(armTemplate);
}
private Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(DeploymentDefinition creatorConfig)
{
// used to create the parameter metatadata, etc (not value) for use in file with resources
// add parameters with metatdata properties
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Name of the API Management"
},
type = "string"
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
// add remote location of template files for linked option
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Base URL of the repository"
},
type = "string"
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
if (creatorConfig.LinkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Query string for the URL of the repository"
},
type = "string"
};
parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties);
}
return(parameters);
}
public MasterTemplateResource CreateLinkedMasterTemplateResource(string name, string uriLink, string[] dependsOn, string apiName, bool isServiceUrlParameterizeInApi)
{
// create deployment resource with provided arguments
MasterTemplateResource masterTemplateResource = new MasterTemplateResource()
{
Name = name,
Type = "Microsoft.Resources/deployments",
ApiVersion = GlobalConstants.ArmApiVersion,
Properties = new MasterTemplateProperties()
{
Mode = "Incremental",
TemplateLink = new MasterTemplateLink()
{
Uri = uriLink,
ContentVersion = "1.0.0.0"
},
Parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.ApimServiceName}')]"
} }
}
},
DependsOn = dependsOn
};
if (name.IndexOf("APITemplate") > 0 && isServiceUrlParameterizeInApi)
{
TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties()
{
Value = $"[parameters('{apiName}-ServiceUrl')]"
};
masterTemplateResource.Properties.Parameters.Add(apiName + "-ServiceUrl", serviceUrlParamProperty);
}
return(masterTemplateResource);
}
public TemplateBuilder AddPolicyProperties(ExtractorParameters extractorParameters)
{
if (extractorParameters.PolicyXMLBaseUrl != null && extractorParameters.PolicyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
this.template.Parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties);
}
if (extractorParameters.PolicyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
this.template.Parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties);
}
return(this);
}
public Template GenerateEmptyPropertyTemplateWithParameters(Extractor exc)
{
Template armTemplate = GenerateEmptyTemplate();
armTemplate.parameters = new Dictionary <string, TemplateParameterProperties> {
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} }
};
if (exc.policyXMLBaseUrl != null && exc.policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties);
}
if (exc.policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties);
}
if (exc.paramNamedValue)
{
TemplateParameterProperties namedValueParameterProperties = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.parameters.Add(ParameterNames.NamedValues, namedValueParameterProperties);
}
return(armTemplate);
}
public async Task <Template> GenerateLoggerTemplateAsync(ExtractorParameters extractorParameters, string singleApiName, List <TemplateResource> apiTemplateResources, Dictionary <string, object> apiLoggerId)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting loggers from service");
Template armTemplate = this.templateBuilder.GenerateTemplateWithApimServiceNameProperty().Build();
if (extractorParameters.ParameterizeLogResourceId)
{
TemplateParameterProperties loggerResourceIdParameterProperties = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.Parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdParameterProperties);
}
// isolate product api associations in the case of a single api extraction
var policyResources = apiTemplateResources.Where(resource => resource.Type == ResourceTypeConstants.APIPolicy || resource.Type == ResourceTypeConstants.APIOperationPolicy || resource.Type == ResourceTypeConstants.ProductPolicy);
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull all loggers for service
string loggers = await this.GetLoggersAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup);
JObject oLoggers = JObject.Parse(loggers);
foreach (var extractedLogger in oLoggers["value"])
{
string loggerName = ((JValue)extractedLogger["name"]).Value.ToString();
string fullLoggerResource = await this.GetLoggerDetailsAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup, loggerName);
// convert returned logger to template resource class
LoggerTemplateResource loggerResource = fullLoggerResource.Deserialize <LoggerTemplateResource>();
loggerResource.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{loggerName}')]";
loggerResource.Type = ResourceTypeConstants.Logger;
loggerResource.ApiVersion = GlobalConstants.ApiVersion;
loggerResource.Scale = null;
if (singleApiName == null)
{
// if the user is extracting all apis, extract all the loggers
Console.WriteLine("'{0}' Logger found", loggerName);
templateResources.Add(loggerResource);
}
else
{
// if the user is extracting a single api, extract the loggers referenced by its diagnostics and api policies
bool isReferencedInPolicy = false;
bool isReferencedInDiagnostic = false;
foreach (PolicyTemplateResource policyTemplateResource in policyResources)
{
if (policyTemplateResource.Properties.PolicyContent.Contains(loggerName))
{
isReferencedInPolicy = true;
}
}
string validApiName = ParameterNamingHelper.GenerateValidParameterName(singleApiName, ParameterPrefix.Api);
if (extractorParameters.ParameterizeApiLoggerId && apiLoggerId.ContainsKey(validApiName))
{
object diagnosticObj = apiLoggerId[validApiName];
if (diagnosticObj is Dictionary <string, string> )
{
Dictionary <string, string> curDiagnostic = (Dictionary <string, string>)diagnosticObj;
string validDName = ParameterNamingHelper.GenerateValidParameterName(loggerResource.Properties.loggerType, ParameterPrefix.Diagnostic).ToLower();
if (curDiagnostic.ContainsKey(validDName) && curDiagnostic[validDName].Contains(loggerName))
{
isReferencedInDiagnostic = true;
}
}
}
if (isReferencedInPolicy == true || isReferencedInDiagnostic == true)
{
// logger was used in policy or diagnostic, extract it
Console.WriteLine("'{0}' Logger found", loggerName);
templateResources.Add(loggerResource);
}
};
}
armTemplate.Resources = templateResources.ToArray();
return(armTemplate);
}
public async Task <Template> CreateMasterTemplateParameterValues(List <string> apisToExtract, ExtractorParameters extractorParameters,
Dictionary <string, object> apiLoggerId,
Dictionary <string, string> loggerResourceIds,
Dictionary <string, BackendApiParameters> backendParams,
List <TemplateResource> propertyResources)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = this.templateBuilder.GenerateEmptyTemplate().Build();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = extractorParameters.DestinationApimName
};
parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties);
if (extractorParameters.LinkedTemplatesBaseUrl != null)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = extractorParameters.LinkedTemplatesBaseUrl
};
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties);
// add linkedTemplatesSasToken parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (extractorParameters.LinkedTemplatesSasToken != null)
{
TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties()
{
value = extractorParameters.LinkedTemplatesSasToken
};
parameters.Add(ParameterNames.LinkedTemplatesSasToken, linkedTemplatesSasTokenProperties);
}
// add linkedTemplatesUrlQueryString parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (extractorParameters.LinkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
value = extractorParameters.LinkedTemplatesUrlQueryString
};
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties);
}
}
if (extractorParameters.PolicyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
value = extractorParameters.PolicyXMLBaseUrl
};
parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlProperties);
// add policyXMLSasToken parameter if provided and if the user has provided a policyXMLBaseUrl
if (extractorParameters.PolicyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenProperties = new TemplateParameterProperties()
{
value = extractorParameters.PolicyXMLSasToken
};
parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenProperties);
}
}
if (extractorParameters.ParameterizeServiceUrl)
{
Dictionary <string, string> serviceUrls = new Dictionary <string, string>();
foreach (string apiName in apisToExtract)
{
string validApiName = ParameterNamingHelper.GenerateValidParameterName(apiName, ParameterPrefix.Api);
string serviceUrl = extractorParameters.ServiceUrlParameters != null?this.GetApiServiceUrlFromParameters(apiName, extractorParameters.ServiceUrlParameters) :
await this.GetAPIServiceUrl(extractorParameters.SourceApimName, extractorParameters.ResourceGroup, apiName);
serviceUrls.Add(validApiName, serviceUrl);
}
TemplateObjectParameterProperties serviceUrlProperties = new TemplateObjectParameterProperties()
{
value = serviceUrls
};
parameters.Add(ParameterNames.ServiceUrl, serviceUrlProperties);
}
if (extractorParameters.ParameterizeNamedValue)
{
Dictionary <string, string> namedValues = new Dictionary <string, string>();
PropertyExtractor pExc = new PropertyExtractor(this.templateBuilder);
string[] properties = await pExc.GetPropertiesAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup);
foreach (var extractedProperty in properties)
{
JToken oProperty = JObject.Parse(extractedProperty);
string propertyName = ((JValue)oProperty["name"]).Value.ToString();
// check if the property has been extracted as it is being used in a policy or backend
if (propertyResources.Count(item => item.Name.Contains(propertyName)) > 0)
{
string fullPropertyResource = await pExc.GetPropertyDetailsAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup, propertyName);
PropertyTemplateResource propertyTemplateResource = fullPropertyResource.Deserialize <PropertyTemplateResource>();
//Only add the property if it is not controlled by keyvault
if (propertyTemplateResource?.Properties.keyVault == null)
{
string propertyValue = propertyTemplateResource.Properties.value;
string validPName = ParameterNamingHelper.GenerateValidParameterName(propertyName, ParameterPrefix.Property);
namedValues.Add(validPName, propertyValue);
}
}
}
TemplateObjectParameterProperties namedValueProperties = new TemplateObjectParameterProperties()
{
value = namedValues
};
parameters.Add(ParameterNames.NamedValues, namedValueProperties);
}
if (extractorParameters.ParamNamedValuesKeyVaultSecrets)
{
Dictionary <string, string> keyVaultNamedValues = new Dictionary <string, string>();
PropertyExtractor pExc = new PropertyExtractor(this.templateBuilder);
string[] properties = await pExc.GetPropertiesAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup);
foreach (var extractedProperty in properties)
{
JToken oProperty = JObject.Parse(extractedProperty);
string propertyName = ((JValue)oProperty["name"]).Value.ToString();
// check if the property has been extracted as it is being used in a policy or backend
if (propertyResources.Count(item => item.Name.Contains(propertyName)) > 0)
{
string fullPropertyResource = await pExc.GetPropertyDetailsAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup, propertyName);
PropertyTemplateResource propertyTemplateResource = fullPropertyResource.Deserialize <PropertyTemplateResource>();
if (propertyTemplateResource?.Properties.keyVault != null)
{
string propertyValue = propertyTemplateResource.Properties.keyVault.secretIdentifier;
string validPName = ParameterNamingHelper.GenerateValidParameterName(propertyName, ParameterPrefix.Property);
keyVaultNamedValues.Add(validPName, propertyValue);
}
}
}
TemplateObjectParameterProperties keyVaultNamedValueProperties = new TemplateObjectParameterProperties()
{
value = keyVaultNamedValues
};
parameters.Add(ParameterNames.NamedValueKeyVaultSecrets, keyVaultNamedValueProperties);
}
if (extractorParameters.ParameterizeApiLoggerId)
{
TemplateObjectParameterProperties loggerIdProperties = new TemplateObjectParameterProperties()
{
value = apiLoggerId
};
parameters.Add(ParameterNames.ApiLoggerId, loggerIdProperties);
}
if (extractorParameters.ParameterizeLogResourceId)
{
TemplateObjectParameterProperties loggerResourceIdProperties = new TemplateObjectParameterProperties()
{
value = loggerResourceIds
};
parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdProperties);
}
if (extractorParameters.ParameterizeBackend)
{
TemplateObjectParameterProperties backendProperties = new TemplateObjectParameterProperties()
{
value = backendParams
};
parameters.Add(ParameterNames.BackendSettings, backendProperties);
}
masterTemplate.Parameters = parameters;
return(masterTemplate);
}
public async Task <Template> GenerateGlobalServicePolicyTemplateAsync(string apimname, string resourceGroup, string policyXMLBaseUrl, string policyXMLSasToken, string fileFolder)
{
// extract global service policy in both full and single api extraction cases
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting global service policy from service");
Template armTemplate = GenerateEmptyPropertyTemplateWithParameters();
if (policyXMLBaseUrl != null && policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties);
}
if (policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties);
}
List <TemplateResource> templateResources = new List <TemplateResource>();
// add global service policy resource to template
try
{
string globalServicePolicy = await GetGlobalServicePolicyAsync(apimname, resourceGroup);
Console.WriteLine($" - Global policy found for {apimname} API Management service");
PolicyTemplateResource globalServicePolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(globalServicePolicy);
// REST API will return format property as rawxml and value property as the xml by default
globalServicePolicyResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/policy')]";
globalServicePolicyResource.apiVersion = GlobalConstants.APIVersion;
globalServicePolicyResource.scale = null;
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (policyXMLBaseUrl != null)
{
string policyXMLContent = globalServicePolicyResource.properties.value;
string policyFolder = String.Concat(fileFolder, $@"/policies");
string globalServicePolicyFileName = $@"/globalServicePolicy.xml";
this.fileWriter.CreateFolderIfNotExists(policyFolder);
this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, globalServicePolicyFileName));
globalServicePolicyResource.properties.format = "rawxml-link";
if (policyXMLSasToken != null)
{
globalServicePolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{globalServicePolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]";
}
else
{
globalServicePolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{globalServicePolicyFileName}')]";
}
}
templateResources.Add(globalServicePolicyResource);
}
catch (Exception) { }
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
public async Task <Template> GenerateProductsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, string fileFolder, Extractor exc)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting products from service");
Template armTemplate = GenerateEmptyPropertyTemplateWithParameters();
if (exc.policyXMLBaseUrl != null && exc.policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties);
}
if (exc.policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties()
{
type = "string"
};
armTemplate.parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties);
}
// isolate product api associations in the case of a single api extraction
var productAPIResources = apiTemplateResources.Where(resource => resource.type == ResourceTypeConstants.ProductAPI);
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull all products for service
string products = await GetProductsAsync(apimname, resourceGroup);
JObject oProducts = JObject.Parse(products);
foreach (var item in oProducts["value"])
{
string productName = ((JValue)item["name"]).Value.ToString();
string productDetails = await GetProductDetailsAsync(apimname, resourceGroup, productName);
// convert returned product to template resource class
JsonSerializerSettings settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
ProductsTemplateResource productsTemplateResource = JsonConvert.DeserializeObject <ProductsTemplateResource>(productDetails, settings);
productsTemplateResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}')]";
productsTemplateResource.apiVersion = GlobalConstants.APIVersion;
string productGroupDetails = await GetProductGroupsAsync(apimname, resourceGroup, productName);
ProductGroupsTemplateResource productGroupsDetails = JsonConvert.DeserializeObject <ProductGroupsTemplateResource>(productGroupDetails, settings);
// only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api
if (singleApiName == null || productAPIResources.SingleOrDefault(p => p.name.Contains($"/{productName}/")) != null)
{
Console.WriteLine("'{0}' Product found", productName);
templateResources.Add(productsTemplateResource);
// add product policy resource to template
try
{
var productResourceId = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{productName}')]" };
foreach (ProductGroupsValue ProductGroup in productGroupsDetails.value)
{
ProductGroup.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/{ProductGroup.name}')]";
ProductGroup.apiVersion = GlobalConstants.APIVersion;
ProductGroup.dependsOn = productResourceId;
templateResources.Add(ProductGroup);
}
string productPolicy = await GetProductPolicyAsync(apimname, resourceGroup, productName);
Console.WriteLine($" - Product policy found for {productName} product");
PolicyTemplateResource productPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(productPolicy);
productPolicyResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/policy')]";
productPolicyResource.apiVersion = GlobalConstants.APIVersion;
productPolicyResource.scale = null;
productPolicyResource.dependsOn = productResourceId;
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (exc.policyXMLBaseUrl != null)
{
string policyXMLContent = productPolicyResource.properties.value;
string policyFolder = String.Concat(fileFolder, $@"/policies");
string productPolicyFileName = $@"/{productName}-productPolicy.xml";
this.fileWriter.CreateFolderIfNotExists(policyFolder);
this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, productPolicyFileName));
productPolicyResource.properties.format = "rawxml-link";
if (exc.policyXMLSasToken != null)
{
productPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{productPolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]";
}
else
{
productPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{productPolicyFileName}')]";
}
}
templateResources.Add(productPolicyResource);
}
catch (Exception) { }
// add tags associated with the product to template
try
{
// pull tags associated with the product
string productTags = await GetProductTagsAsync(apimname, resourceGroup, productName);
JObject oProductTags = JObject.Parse(productTags);
foreach (var tag in oProductTags["value"])
{
string productTagName = ((JValue)tag["name"]).Value.ToString();
Console.WriteLine(" - '{0}' Tag association found for {1} product", productTagName, productName);
// convert associations between product and tags to template resource class
TagTemplateResource productTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString());
productTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/{productTagName}')]";
productTagResource.apiVersion = GlobalConstants.APIVersion;
productTagResource.scale = null;
productTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{productName}')]" };
templateResources.Add(productTagResource);
}
}
catch (Exception) { }
}
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
/// <summary>
/// Generate the ARM assets for the backend resources
/// </summary>
/// <param name="apimname"></param>
/// <param name="resourceGroup"></param>
/// <param name="singleApiName"></param>
/// <param name="apiTemplateResources"></param>
/// <param name="propertyResources"></param>
/// <param name="policyXMLBaseUrl"></param>
/// <param name="policyXMLSasToken"></param>
/// <param name="extractBackendParameters"></param>
/// <returns>a combination of a Template and the value for the BackendSettings parameter</returns>
public async Task <Tuple <Template, Dictionary <string, BackendApiParameters> > > GenerateBackendsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, List <TemplateResource> propertyResources, ExtractorParameters extractorParameters)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting backends from service");
Template armTemplate = this.templateBuilder.GenerateTemplateWithApimServiceNameProperty().Build();
if (extractorParameters.ParameterizeBackend)
{
TemplateParameterProperties extractBackendParametersProperties = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.Parameters.Add(ParameterNames.BackendSettings, extractBackendParametersProperties);
}
List <TemplateResource> templateResources = new List <TemplateResource>();
// isolate api and operation policy resources in the case of a single api extraction, as they may reference backends
var policyResources = apiTemplateResources.Where(resource => resource.Type == ResourceTypeConstants.APIPolicy || resource.Type == ResourceTypeConstants.APIOperationPolicy || resource.Type == ResourceTypeConstants.ProductPolicy);
var namedValueResources = propertyResources.Where(resource => resource.Type == ResourceTypeConstants.Property);
// pull all backends for service
JObject oBackends = new JObject();
var oBackendParameters = new Dictionary <string, BackendApiParameters>();
int skipNumberOfBackends = 0;
do
{
string backends = await this.GetBackendsAsync(apimname, resourceGroup, skipNumberOfBackends);
oBackends = JObject.Parse(backends);
foreach (var item in oBackends["value"])
{
string backendName = ((JValue)item["name"]).Value.ToString();
string backend = await this.GetBackendDetailsAsync(apimname, resourceGroup, backendName);
// convert returned backend to template resource class
BackendTemplateResource backendTemplateResource = backend.Deserialize <BackendTemplateResource>();
backendTemplateResource.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{backendName}')]";
backendTemplateResource.ApiVersion = GlobalConstants.ApiVersion;
bool includeBackend = false;
////only extract the backend if this is a full extraction, or in the case of a single api, if it is referenced by one of the policies
if (singleApiName == null)
{
// if the user is extracting all apis, extract all the backends
includeBackend = true;
}
else
{
// check extracted policies to see if the backend is referenced.
foreach (PolicyTemplateResource policyTemplateResource in policyResources)
{
string policyContent = PolicyTemplateUtils.GetPolicyContent(extractorParameters, policyTemplateResource);
if (this.DoesPolicyReferenceBackend(policyContent, namedValueResources, backendName, backendTemplateResource))
{
// backend was used in policy, extract it
includeBackend = true;
// dont need to go through all policies if the back end has already been found
break;
}
}
}
if (includeBackend)
{
if (extractorParameters.ParameterizeBackend)
{
var apiToken = new BackendApiParameters();
string validApiParamName = ParameterNamingHelper.GenerateValidParameterName(backendName, ParameterPrefix.Diagnostic).ToLower();
if (!string.IsNullOrEmpty(backendTemplateResource.Properties.resourceId))
{
apiToken.resourceId = backendTemplateResource.Properties.resourceId;
backendTemplateResource.Properties.resourceId = $"[parameters('{ParameterNames.BackendSettings}').{validApiParamName}.resourceId]";
}
if (!string.IsNullOrEmpty(backendTemplateResource.Properties.url))
{
apiToken.url = backendTemplateResource.Properties.url;
backendTemplateResource.Properties.url = $"[parameters('{ParameterNames.BackendSettings}').{validApiParamName}.url]";
}
if (!string.IsNullOrEmpty(backendTemplateResource.Properties.protocol))
{
apiToken.protocol = backendTemplateResource.Properties.protocol;
backendTemplateResource.Properties.protocol = $"[parameters('{ParameterNames.BackendSettings}').{validApiParamName}.protocol]";
}
oBackendParameters.Add(validApiParamName, apiToken);
}
Console.WriteLine("'{0}' Backend found", backendName);
templateResources.Add(backendTemplateResource);
}
}
skipNumberOfBackends += GlobalConstants.NumOfRecords;
}while (oBackends["nextLink"] != null);
armTemplate.Resources = templateResources.ToArray();
return(new Tuple <Template, Dictionary <string, BackendApiParameters> >(armTemplate, oBackendParameters));
}
public async Task <Template> GenerateNamedValuesTemplateAsync(string singleApiName, List <TemplateResource> apiTemplateResources, ExtractorParameters extractorParameters, IBackendExtractor backendExtractor, List <TemplateResource> loggerTemplateResources)
{
Template armTemplate = this.templateBuilder.GenerateTemplateWithApimServiceNameProperty().Build();
if (extractorParameters.ParameterizeNamedValue)
{
TemplateParameterProperties namedValueParameterProperties = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.Parameters.Add(ParameterNames.NamedValues, namedValueParameterProperties);
}
if (extractorParameters.ParamNamedValuesKeyVaultSecrets)
{
TemplateParameterProperties keyVaultNamedValueParameterProperties = new TemplateParameterProperties()
{
type = "object"
};
armTemplate.Parameters.Add(ParameterNames.NamedValueKeyVaultSecrets, keyVaultNamedValueParameterProperties);
}
if (extractorParameters.NotIncludeNamedValue == true)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Skipping extracting named values from service");
return(armTemplate);
}
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting named values from service");
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull all named values (properties) for service
string[] properties = await this.GetPropertiesAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup);
// isolate api and operation policy resources in the case of a single api extraction, as they may reference named value
var policyResources = apiTemplateResources.Where(resource => resource.Type == ResourceTypeConstants.APIPolicy || resource.Type == ResourceTypeConstants.APIOperationPolicy || resource.Type == ResourceTypeConstants.ProductPolicy);
foreach (var extractedProperty in properties)
{
JToken oProperty = JObject.Parse(extractedProperty);
string propertyName = ((JValue)oProperty["name"]).Value.ToString();
string fullPropertyResource = await this.GetPropertyDetailsAsync(extractorParameters.SourceApimName, extractorParameters.ResourceGroup, propertyName);
// convert returned named value to template resource class
PropertyTemplateResource propertyTemplateResource = fullPropertyResource.Deserialize <PropertyTemplateResource>();
propertyTemplateResource.Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{propertyName}')]";
propertyTemplateResource.Type = ResourceTypeConstants.Property;
propertyTemplateResource.ApiVersion = GlobalConstants.ApiVersion;
propertyTemplateResource.Scale = null;
if (extractorParameters.ParameterizeNamedValue)
{
propertyTemplateResource.Properties.value = $"[parameters('{ParameterNames.NamedValues}').{ParameterNamingHelper.GenerateValidParameterName(propertyName, ParameterPrefix.Property)}]";
}
//Hide the value field if it is a keyvault named value
if (propertyTemplateResource.Properties.keyVault != null)
{
propertyTemplateResource.Properties.value = null;
}
if (propertyTemplateResource.Properties.keyVault != null && extractorParameters.ParamNamedValuesKeyVaultSecrets)
{
propertyTemplateResource.Properties.keyVault.secretIdentifier = $"[parameters('{ParameterNames.NamedValueKeyVaultSecrets}').{ParameterNamingHelper.GenerateValidParameterName(propertyName, ParameterPrefix.Property)}]";
}
if (singleApiName == null)
{
// if the user is executing a full extraction, extract all the loggers
Console.WriteLine("'{0}' Named value found", propertyName);
templateResources.Add(propertyTemplateResource);
}
else
{
// if the user is executing a single api, extract all the named values used in the template resources
bool foundInPolicy = this.DoesPolicyReferenceNamedValue(extractorParameters, policyResources, propertyName, propertyTemplateResource);
bool foundInBackEnd = await backendExtractor.IsNamedValueUsedInBackends(extractorParameters.SourceApimName, extractorParameters.ResourceGroup, singleApiName, apiTemplateResources, extractorParameters, propertyName, propertyTemplateResource.Properties.displayName);
bool foundInLogger = this.DoesLoggerReferenceNamedValue(loggerTemplateResources, propertyName, propertyTemplateResource);
// check if named value is referenced in a backend
if (foundInPolicy || foundInBackEnd || foundInLogger)
{
// named value was used in policy, extract it
Console.WriteLine("'{0}' Named value found", propertyName);
templateResources.Add(propertyTemplateResource);
}
}
}
armTemplate.Resources = templateResources.ToArray();
return(armTemplate);
}
public async Task <Template> CreateMasterTemplateParameterValues(string singleApiName, List <string> multipleApiNames, Extractor exc)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = GenerateEmptyTemplate();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = exc.destinationApimName
};
parameters.Add("ApimServiceName", apimServiceNameProperties);
if (exc.linkedTemplatesBaseUrl != null)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = exc.linkedTemplatesBaseUrl
};
parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties);
// add linkedTemplatesSasToken parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (exc.linkedTemplatesSasToken != null)
{
TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties()
{
value = exc.linkedTemplatesSasToken
};
parameters.Add("LinkedTemplatesSasToken", linkedTemplatesSasTokenProperties);
}
// add linkedTemplatesUrlQueryString parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (exc.linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
value = exc.linkedTemplatesUrlQueryString
};
parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties);
}
}
if (exc.policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
value = exc.policyXMLBaseUrl
};
parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlProperties);
// add policyXMLSasToken parameter if provided and if the user has provided a policyXMLBaseUrl
if (exc.policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenProperties = new TemplateParameterProperties()
{
value = exc.policyXMLSasToken
};
parameters.Add("PolicyXMLSasToken", policyTemplateSasTokenProperties);
}
}
if (exc.paramServiceUrl)
{
Dictionary <string, string> serviceUrls = new Dictionary <string, string>();
APIExtractor apiExc = new APIExtractor(new FileWriter());
if (singleApiName != null)
{
string validApiName = ExtractorUtils.GenValidApiParamName(singleApiName);
string serviceUrl = GetApiServiceUrlFromParameters(singleApiName, exc.serviceUrlParameters);
if (serviceUrl == null)
{
serviceUrl = await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, singleApiName);
}
serviceUrls.Add(validApiName, serviceUrl);
}
else if (multipleApiNames != null)
{
foreach (string apiName in multipleApiNames)
{
string validApiName = ExtractorUtils.GenValidApiParamName(apiName);
string serviceUrl = GetApiServiceUrlFromParameters(apiName, exc.serviceUrlParameters);
if (serviceUrl == null)
{
serviceUrl = await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, apiName);
}
serviceUrls.Add(validApiName, serviceUrl);
}
}
else
{
JToken[] oApis = await apiExc.GetAllAPIObjsAsync(exc.sourceApimName, exc.resourceGroup);
foreach (JToken oApi in oApis)
{
string apiName = ((JValue)oApi["name"]).Value.ToString();
string validApiName = ExtractorUtils.GenValidApiParamName(apiName);
string serviceUrl = GetApiServiceUrlFromParameters(apiName, exc.serviceUrlParameters);
if (serviceUrl == null)
{
serviceUrl = await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, apiName);
}
serviceUrls.Add(validApiName, serviceUrl);
}
}
TemplateServiceUrlProperties serviceUrlProperties = new TemplateServiceUrlProperties()
{
value = serviceUrls
};
parameters.Add("serviceUrl", serviceUrlProperties);
}
masterTemplate.parameters = parameters;
return(masterTemplate);
}
public async Task <Template> CreateMasterTemplateParameterValues(List <string> apisToExtract, Extractor exc, Dictionary <string, Dictionary <string, string> > apiLoggerId, Dictionary <string, string> loggerResourceIds)
{
// used to create the parameter values for use in parameters file
// create empty template
Template masterTemplate = GenerateEmptyTemplate();
// add parameters with value property
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
value = exc.destinationApimName
};
parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties);
if (exc.linkedTemplatesBaseUrl != null)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
value = exc.linkedTemplatesBaseUrl
};
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties);
// add linkedTemplatesSasToken parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (exc.linkedTemplatesSasToken != null)
{
TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties()
{
value = exc.linkedTemplatesSasToken
};
parameters.Add(ParameterNames.LinkedTemplatesSasToken, linkedTemplatesSasTokenProperties);
}
// add linkedTemplatesUrlQueryString parameter if provided and if the user has provided a linkedTemplatesBaseUrl
if (exc.linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
value = exc.linkedTemplatesUrlQueryString
};
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties);
}
}
if (exc.policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
value = exc.policyXMLBaseUrl
};
parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlProperties);
// add policyXMLSasToken parameter if provided and if the user has provided a policyXMLBaseUrl
if (exc.policyXMLSasToken != null)
{
TemplateParameterProperties policyTemplateSasTokenProperties = new TemplateParameterProperties()
{
value = exc.policyXMLSasToken
};
parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenProperties);
}
}
if (exc.paramServiceUrl)
{
Dictionary <string, string> serviceUrls = new Dictionary <string, string>();
APIExtractor apiExc = new APIExtractor(new FileWriter());
foreach (string apiName in apisToExtract)
{
string validApiName = ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api);
string serviceUrl = exc.serviceUrlParameters != null?GetApiServiceUrlFromParameters(apiName, exc.serviceUrlParameters) :
await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, apiName);
serviceUrls.Add(validApiName, serviceUrl);
}
TemplateObjectParameterProperties serviceUrlProperties = new TemplateObjectParameterProperties()
{
value = serviceUrls
};
parameters.Add(ParameterNames.ServiceUrl, serviceUrlProperties);
}
if (exc.paramNamedValue)
{
Dictionary <string, string> namedValues = new Dictionary <string, string>();
PropertyExtractor pExc = new PropertyExtractor();
string[] properties = await pExc.GetPropertiesAsync(exc.sourceApimName, exc.resourceGroup);
foreach (var extractedProperty in properties)
{
JToken oProperty = JObject.Parse(extractedProperty);
string propertyName = ((JValue)oProperty["name"]).Value.ToString();
string fullPropertyResource = await pExc.GetPropertyDetailsAsync(exc.sourceApimName, exc.resourceGroup, propertyName);
PropertyTemplateResource propertyTemplateResource = JsonConvert.DeserializeObject <PropertyTemplateResource>(fullPropertyResource);
string propertyValue = propertyTemplateResource.properties.value;
string validPName = ExtractorUtils.GenValidParamName(propertyName, ParameterPrefix.Property);
namedValues.Add(validPName, propertyValue);
}
TemplateObjectParameterProperties namedValueProperties = new TemplateObjectParameterProperties()
{
value = namedValues
};
parameters.Add(ParameterNames.NamedValues, namedValueProperties);
}
if (exc.paramApiLoggerId)
{
TemplateObjectParameterProperties loggerIdProperties = new TemplateObjectParameterProperties()
{
value = apiLoggerId
};
parameters.Add(ParameterNames.ApiLoggerId, loggerIdProperties);
}
if (exc.paramLogResourceId)
{
TemplateObjectParameterProperties loggerResourceIdProperties = new TemplateObjectParameterProperties()
{
value = loggerResourceIds
};
parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdProperties);
}
masterTemplate.parameters = parameters;
return(masterTemplate);
}
public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(bool linked, Extractor exc)
{
// used to create the parameter metatadata, etc (not value) for use in file with resources
// add parameters with metatdata properties
Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>();
TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Name of the API Management"
},
type = "string"
};
parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties);
// add remote location of template files for linked option
if (linked == true)
{
TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Base URL of the repository that contains the generated templates"
},
type = "string"
};
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties);
// add linkedTemplatesSasToken parameter if provided and if the templates are linked
if (exc.linkedTemplatesSasToken != null)
{
TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "The Shared Access Signature for the URL of the repository"
},
type = "string"
};
parameters.Add(ParameterNames.LinkedTemplatesSasToken, linkedTemplatesSasTokenProperties);
}
// add linkedTemplatesUrlQueryString parameter if provided and if the templates are linked
if (exc.linkedTemplatesUrlQueryString != null)
{
TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Query string for the URL of the repository"
},
type = "string"
};
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties);
}
}
if (exc.policyXMLBaseUrl != null)
{
TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Base URL of the repository that contains the generated policy files"
},
type = "string"
};
parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlProperties);
if (exc.policyXMLSasToken != null)
{
TemplateParameterProperties policyXMLSasTokenProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "The SAS token for the URL of the policy container"
},
type = "string"
};
parameters.Add(ParameterNames.PolicyXMLSasToken, policyXMLSasTokenProperties);
}
}
if (exc.paramServiceUrl)
{
TemplateParameterProperties paramServiceUrlProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Service url for each Api"
},
type = "object"
};
parameters.Add(ParameterNames.ServiceUrl, paramServiceUrlProperties);
}
if (exc.paramNamedValue)
{
TemplateParameterProperties namedValueProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "Named values"
},
type = "object"
};
parameters.Add(ParameterNames.NamedValues, namedValueProperties);
}
if (exc.paramApiLoggerId)
{
TemplateParameterProperties loggerIdProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "LoggerId for this api"
},
type = "object"
};
parameters.Add(ParameterNames.ApiLoggerId, loggerIdProperties);
}
if (exc.paramLogResourceId)
{
TemplateParameterProperties loggerResourceIdProperties = new TemplateParameterProperties()
{
metadata = new TemplateParameterMetadata()
{
description = "ResourceId for the logger"
},
type = "object"
};
parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdProperties);
}
return(parameters);
}