/* three condistions to use this function:
* 1. singleApiName is null, then generate one master template for the multipleAPIs in multipleApiNams
* 2. multipleApiNams is null, then generate separate folder and master template for each API
* 3. when both singleApiName and multipleApiNams is null, then generate one master template to link all apis in the sourceapim
*/
public static async Task GenerateTemplates(
Extractor exc,
string singleApiName,
List <string> multipleAPINames,
FileNameGenerator fileNameGenerator,
FileNames fileNames,
FileWriter fileWriter,
Template apiTemplate)
{
if (singleApiName != null && multipleAPINames != null)
{
throw new Exception("can't specify single API and multiple APIs to extract at the same time");
}
// initialize entity extractor classes
APIExtractor apiExtractor = new APIExtractor(fileWriter);
APIVersionSetExtractor apiVersionSetExtractor = new APIVersionSetExtractor();
AuthorizationServerExtractor authorizationServerExtractor = new AuthorizationServerExtractor();
BackendExtractor backendExtractor = new BackendExtractor();
LoggerExtractor loggerExtractor = new LoggerExtractor();
PolicyExtractor policyExtractor = new PolicyExtractor(fileWriter);
PropertyExtractor propertyExtractor = new PropertyExtractor();
TagExtractor tagExtractor = new TagExtractor();
ProductExtractor productExtractor = new ProductExtractor(fileWriter);
MasterTemplateExtractor masterTemplateExtractor = new MasterTemplateExtractor();
// read parameters
string sourceApim = exc.sourceApimName;
string resourceGroup = exc.resourceGroup;
string destinationApim = exc.destinationApimName;
string linkedBaseUrl = exc.linkedTemplatesBaseUrl;
string policyXMLBaseUrl = exc.policyXMLBaseUrl;
string dirName = exc.fileFolder;
List <string> multipleApiNames = multipleAPINames;
string linkedUrlQueryString = exc.linkedTemplatesUrlQueryString;
// extract templates from apim service
Template globalServicePolicyTemplate = await policyExtractor.GenerateGlobalServicePolicyTemplateAsync(sourceApim, resourceGroup, policyXMLBaseUrl, dirName);
if (apiTemplate == null)
{
apiTemplate = await apiExtractor.GenerateAPIsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, multipleApiNames, policyXMLBaseUrl, dirName);
}
List <TemplateResource> apiTemplateResources = apiTemplate.resources.ToList();
Template apiVersionSetTemplate = await apiVersionSetExtractor.GenerateAPIVersionSetsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template authorizationServerTemplate = await authorizationServerExtractor.GenerateAuthorizationServersARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template loggerTemplate = await loggerExtractor.GenerateLoggerTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template productTemplate = await productExtractor.GenerateProductsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl, dirName);
List <TemplateResource> productTemplateResources = productTemplate.resources.ToList();
Template namedValueTemplate = await propertyExtractor.GenerateNamedValuesTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template tagTemplate = await tagExtractor.GenerateTagsTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, productTemplateResources, policyXMLBaseUrl);
List <TemplateResource> namedValueResources = namedValueTemplate.resources.ToList();
Template backendTemplate = await backendExtractor.GenerateBackendsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, namedValueResources, policyXMLBaseUrl);
// create parameters file
Template templateParameters = masterTemplateExtractor.CreateMasterTemplateParameterValues(destinationApim, linkedBaseUrl, linkedUrlQueryString, policyXMLBaseUrl);
// write templates to output file location
string apiFileName = fileNameGenerator.GenerateExtractorAPIFileName(singleApiName, sourceApim);
fileWriter.WriteJSONToFile(apiTemplate, String.Concat(@dirName, apiFileName));
// won't generate template when there is no resources
if (apiVersionSetTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(apiVersionSetTemplate, String.Concat(@dirName, fileNames.apiVersionSets));
}
if (backendTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(backendTemplate, String.Concat(@dirName, fileNames.backends));
}
if (loggerTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(loggerTemplate, String.Concat(@dirName, fileNames.loggers));
}
if (authorizationServerTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(authorizationServerTemplate, String.Concat(@dirName, fileNames.authorizationServers));
}
if (productTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(productTemplate, String.Concat(@dirName, fileNames.products));
}
if (tagTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(tagTemplate, String.Concat(@dirName, fileNames.tags));
}
if (namedValueTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(namedValueTemplate, String.Concat(@dirName, fileNames.namedValues));
}
if (globalServicePolicyTemplate.resources.Count() != 0)
{
fileWriter.WriteJSONToFile(globalServicePolicyTemplate, String.Concat(@dirName, fileNames.globalServicePolicy));
}
if (linkedBaseUrl != null)
{
// create a master template that links to all other templates
Template masterTemplate = masterTemplateExtractor.GenerateLinkedMasterTemplate(
apiTemplate, globalServicePolicyTemplate, apiVersionSetTemplate, productTemplate,
loggerTemplate, backendTemplate, authorizationServerTemplate, namedValueTemplate,
tagTemplate, fileNames, apiFileName, linkedUrlQueryString, policyXMLBaseUrl);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(@dirName, fileNames.linkedMaster));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(templateParameters, String.Concat(dirName, fileNames.parameters));
}
public ExtractCommand()
{
this.Name = GlobalConstants.ExtractName;
this.Description = GlobalConstants.ExtractDescription;
var sourceApimName = this.Option("--sourceApimName <sourceApimName>", "Source API Management name", CommandOptionType.SingleValue);
var destinationAPIManagementName = this.Option("--destinationApimName <destinationApimName>", "Destination API Management name", CommandOptionType.SingleValue);
var resourceGroupName = this.Option("--resourceGroup <resourceGroup>", "Resource Group name", CommandOptionType.SingleValue);
var fileFolderName = this.Option("--fileFolder <filefolder>", "ARM Template files folder", CommandOptionType.SingleValue);
var apiName = this.Option("--apiName <apiName>", "API name", CommandOptionType.SingleValue);
var linkedTemplatesBaseUrlName = this.Option("--linkedTemplatesBaseUrl <linkedTemplatesBaseUrl>", "Creates a master template with links", CommandOptionType.SingleValue);
var linkedTemplatesUrlQueryString = this.Option("--linkedTemplatesUrlQueryString <linkedTemplatesUrlQueryString>", "Query string appended to linked templates uris that enables retrieval from private storage", CommandOptionType.SingleValue);
var policyXMLBaseUrlName = this.Option("--policyXMLBaseUrl <policyXMLBaseUrl>", "Writes policies to local XML files that require deployment to remote folder", CommandOptionType.SingleValue);
this.HelpOption();
this.OnExecute(async() =>
{
try
{
if (!sourceApimName.HasValue())
{
throw new Exception("Missing parameter <sourceApimName>.");
}
if (!destinationAPIManagementName.HasValue())
{
throw new Exception("Missing parameter <destinationApimName>.");
}
if (!resourceGroupName.HasValue())
{
throw new Exception("Missing parameter <resourceGroup>.");
}
if (!fileFolderName.HasValue())
{
throw new Exception("Missing parameter <filefolder>.");
}
// isolate cli parameters
string resourceGroup = resourceGroupName.Value().ToString();
string sourceApim = sourceApimName.Value().ToString();
string destinationApim = destinationAPIManagementName.Value().ToString();
string fileFolder = fileFolderName.Value().ToString();
string linkedBaseUrl = linkedTemplatesBaseUrlName.HasValue() ? linkedTemplatesBaseUrlName.Value().ToString() : null;
string linkedUrlQueryString = linkedTemplatesUrlQueryString.HasValue() ? linkedTemplatesUrlQueryString.Value().ToString() : null;
string policyXMLBaseUrl = policyXMLBaseUrlName.HasValue() ? policyXMLBaseUrlName.Value().ToString() : null;
string singleApiName = null;
if (apiName.Values.Count > 0)
{
singleApiName = apiName.Value().ToString();
}
Console.WriteLine("API Management Template");
Console.WriteLine();
Console.WriteLine("Connecting to {0} API Management Service on {1} Resource Group ...", sourceApim, resourceGroup);
if (singleApiName != null)
{
Console.WriteLine("Executing extraction for {0} API ...", singleApiName);
}
else
{
Console.WriteLine("Executing full extraction ...", singleApiName);
}
// initialize file helper classes
FileWriter fileWriter = new FileWriter();
FileNameGenerator fileNameGenerator = new FileNameGenerator();
FileNames fileNames = fileNameGenerator.GenerateFileNames(sourceApim);
// initialize entity extractor classes
APIExtractor apiExtractor = new APIExtractor(fileWriter);
APIVersionSetExtractor apiVersionSetExtractor = new APIVersionSetExtractor();
AuthorizationServerExtractor authorizationServerExtractor = new AuthorizationServerExtractor();
BackendExtractor backendExtractor = new BackendExtractor();
LoggerExtractor loggerExtractor = new LoggerExtractor();
PolicyExtractor policyExtractor = new PolicyExtractor(fileWriter);
PropertyExtractor propertyExtractor = new PropertyExtractor();
ProductExtractor productExtractor = new ProductExtractor(fileWriter);
MasterTemplateExtractor masterTemplateExtractor = new MasterTemplateExtractor();
// extract templates from apim service
Template globalServicePolicyTemplate = await policyExtractor.GenerateGlobalServicePolicyTemplateAsync(sourceApim, resourceGroup, policyXMLBaseUrl, fileFolder);
Template apiTemplate = await apiExtractor.GenerateAPIsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, policyXMLBaseUrl, fileFolder);
List <TemplateResource> apiTemplateResources = apiTemplate.resources.ToList();
Template apiVersionSetTemplate = await apiVersionSetExtractor.GenerateAPIVersionSetsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template authorizationServerTemplate = await authorizationServerExtractor.GenerateAuthorizationServersARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template loggerTemplate = await loggerExtractor.GenerateLoggerTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
Template productTemplate = await productExtractor.GenerateProductsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl, fileFolder);
Template namedValueTemplate = await propertyExtractor.GenerateNamedValuesTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl);
List <TemplateResource> namedValueResources = namedValueTemplate.resources.ToList();
Template backendTemplate = await backendExtractor.GenerateBackendsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, namedValueResources, policyXMLBaseUrl);
// create parameters file
Template templateParameters = masterTemplateExtractor.CreateMasterTemplateParameterValues(destinationApim, linkedBaseUrl, linkedUrlQueryString, policyXMLBaseUrl);
// write templates to output file location
string apiFileName = fileNameGenerator.GenerateExtractorAPIFileName(singleApiName, sourceApim);
fileWriter.WriteJSONToFile(apiTemplate, String.Concat(@fileFolder, apiFileName));
fileWriter.WriteJSONToFile(apiVersionSetTemplate, String.Concat(@fileFolder, fileNames.apiVersionSets));
fileWriter.WriteJSONToFile(authorizationServerTemplate, String.Concat(@fileFolder, fileNames.authorizationServers));
fileWriter.WriteJSONToFile(backendTemplate, String.Concat(@fileFolder, fileNames.backends));
fileWriter.WriteJSONToFile(loggerTemplate, String.Concat(@fileFolder, fileNames.loggers));
fileWriter.WriteJSONToFile(namedValueTemplate, String.Concat(@fileFolder, fileNames.namedValues));
fileWriter.WriteJSONToFile(productTemplate, String.Concat(@fileFolder, fileNames.products));
fileWriter.WriteJSONToFile(globalServicePolicyTemplate, String.Concat(@fileFolder, fileNames.globalServicePolicy));
if (linkedBaseUrl != null)
{
// create a master template that links to all other templates
Template masterTemplate = masterTemplateExtractor.GenerateLinkedMasterTemplate(apiTemplate, globalServicePolicyTemplate, apiVersionSetTemplate, productTemplate, loggerTemplate, backendTemplate, authorizationServerTemplate, namedValueTemplate, fileNames, apiFileName, linkedUrlQueryString, policyXMLBaseUrl);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(@fileFolder, fileNames.linkedMaster));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(templateParameters, String.Concat(fileFolder, fileNames.parameters));
Console.WriteLine("Templates written to output location");
Console.WriteLine("Press any key to exit process:");
#if DEBUG
Console.ReadKey();
#endif
}
catch (Exception ex)
{
Console.WriteLine("Error occured: " + ex.Message);
throw;
}
});
}
private void GenerateARMTemplate(string apimname, string resourceGroup, string fileFolder, string singleApiName)
{
#region API's
FileWriter fileWriter;
APIExtractor apiExtractor = new APIExtractor();
string apis = apiExtractor.GetAPIs(apimname, resourceGroup).Result;
Template armTemplate = GenerateEmptyTemplateWithParameters();
JObject oApi = JObject.Parse(apis);
oApi = FormatoApi(singleApiName, oApi);
Console.WriteLine("{0} API's found ...", ((JContainer)oApi["value"]).Count.ToString());
if (singleApiName == null)
{
GenerateNamedValuesTemplate(resourceGroup, apimname, fileFolder);
GenerateLoggerTemplate(resourceGroup, apimname, fileFolder);
}
List <TemplateResource> templateResources = new List <TemplateResource>();
for (int i = 0; i < ((JContainer)oApi["value"]).Count; i++)
{
string apiName = ((JValue)oApi["value"][i]["name"]).Value.ToString();
string apiDetails = apiExtractor.GetAPIDetails(apimname, resourceGroup, apiName).Result;
Console.WriteLine("------------------------------------------");
Console.WriteLine("Getting operations from {0} API:", apiName);
JObject oApiDetails = JObject.Parse(apiDetails);
APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails);
string oApiName = ((JValue)oApiDetails["name"]).Value.ToString();
apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString();
apiResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}')]";
apiResource.apiVersion = "2018-06-01-preview";
apiResource.scale = null;
if (apiResource.properties.apiVersionSetId != null)
{
apiResource.dependsOn = new string[] { };
string versionSetName = apiResource.properties.apiVersionSetId;
int versionSetPosition = versionSetName.IndexOf("api-version-sets/");
versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition));
apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('ApimServiceName')), '/{versionSetName}')]";
GenerateVersionSetARMTemplate(apimname, resourceGroup, versionSetName, fileFolder);
}
else
{
apiResource.dependsOn = new string[] { };
}
templateResources.Add(apiResource);
#region Schemas
List <TemplateResource> schemaResources = GenerateSchemasARMTemplate(apimname, apiName, resourceGroup, fileFolder);
templateResources.AddRange(schemaResources);
#endregion
#region Operations
string operations = apiExtractor.GetAPIOperations(apimname, resourceGroup, apiName).Result;
JObject oOperations = JObject.Parse(operations);
foreach (var item in oOperations["value"])
{
string operationName = ((JValue)item["name"]).Value.ToString();
string operationDetails = apiExtractor.GetAPIOperationDetail(apimname, resourceGroup, apiName, operationName).Result;
Console.WriteLine("'{0}' Operation found", operationName);
OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails);
string operationResourceName = operationResource.name;
operationResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}')]";
operationResource.apiVersion = "2018-06-01-preview";
operationResource.scale = null;
// depend on api and schemas if necessary
List <string> operationDependsOn = new List <string>()
{
$"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]"
};
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationResource.properties.request.representations)
{
if (operationTemplateRepresentation.schemaId != null)
{
string dependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/schemas', parameters('ApimServiceName'), '{oApiName}', '{operationTemplateRepresentation.schemaId}')]";
// add value to list if schema has not already been added
if (!operationDependsOn.Exists(o => o == dependsOn))
{
operationDependsOn.Add(dependsOn);
}
}
}
foreach (OperationsTemplateResponse operationTemplateResponse in operationResource.properties.responses)
{
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationTemplateResponse.representations)
{
if (operationTemplateRepresentation.schemaId != null)
{
string dependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/schemas', parameters('ApimServiceName'), '{oApiName}', '{operationTemplateRepresentation.schemaId}')]";
// add value to list if schema has not already been added
if (!operationDependsOn.Exists(o => o == dependsOn))
{
operationDependsOn.Add(dependsOn);
}
}
}
}
operationResource.dependsOn = operationDependsOn.ToArray();
templateResources.Add(operationResource);
try
{
string operationPolicy = apiExtractor.GetOperationPolicy(apimname, resourceGroup, oApiName, operationName).Result;
Console.WriteLine($" - Policy found to {operationName} operation");
PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy);
operationPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = "2018-06-01-preview";
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{oApiName}', '{operationResourceName}')]" };
templateResources.Add(operationPolicyResource);
}
catch (Exception)
{
Console.WriteLine($" - No policy found for {operationName} operation");
}
}
#endregion
#region API Policies
try
{
Console.WriteLine("Getting API Policy from {0} API: ", apiName);
string apiPolicies = apiExtractor.GetAPIPolicies(apimname, resourceGroup, apiName).Result;
Console.WriteLine("API Policy found!");
PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies);
apiPoliciesResource.apiVersion = "2018-06-01-preview";
apiPoliciesResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{apiPoliciesResource.name}')]";
apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
templateResources.Add(apiPoliciesResource);
}
catch (Exception)
{
Console.WriteLine("No API policy!");
}
#endregion
#region API Products
try
{
Console.WriteLine("Getting API Products from {0} API: ", apiName);
string apiProducts = apiExtractor.GetApiProducts(apimname, resourceGroup, apiName).Result;
JObject oApiProducts = JObject.Parse(apiProducts);
foreach (var item in oApiProducts["value"])
{
string apiProductName = ((JValue)item["name"]).Value.ToString();
Console.WriteLine($" -- {apiProductName} Product found to {oApiName} API");
ApiProductsTemplateResource apiProductsResource = JsonConvert.DeserializeObject <ApiProductsTemplateResource>(apiProducts);
apiProductsResource.type = "Microsoft.ApiManagement/service/products/apis";
apiProductsResource.name = $"[concat(parameters('ApimServiceName'), '/{apiProductName}/{oApiName}')]";
apiProductsResource.apiVersion = "2018-06-01-preview";
apiProductsResource.scale = null;
apiProductsResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
templateResources.Add(apiProductsResource);
}
}
catch (Exception)
{
Console.WriteLine("No API products!");
}
#endregion
#region Diagnostics
Console.WriteLine("------------------------------------------");
Console.WriteLine("Getting diagnostics from {0} API:", apiName);
string diagnostics = apiExtractor.GetAPIDiagnostics(apimname, resourceGroup, apiName).Result;
JObject oDiagnostics = JObject.Parse(diagnostics);
foreach (var diagnostic in oDiagnostics["value"])
{
string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString();
Console.WriteLine("'{0}' Diagnostic found", diagnosticName);
DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>();
diagnosticResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{diagnosticName}')]";
diagnosticResource.type = "Microsoft.ApiManagement/service/apis/diagnostics";
diagnosticResource.apiVersion = "2018-06-01-preview";
diagnosticResource.scale = null;
diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
if (!diagnosticName.Contains("applicationinsights"))
{
// enableHttpCorrelationHeaders only works for application insights, causes errors otherwise
diagnosticResource.properties.enableHttpCorrelationHeaders = null;
}
templateResources.Add(diagnosticResource);
}
#endregion
armTemplate.resources = templateResources.ToArray();
if (singleApiName != null)
{
fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-" + oApiName + "-template.json");
templateResources = new List <TemplateResource>();
}
}
if (singleApiName == null)
{
fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-apis-template.json");
}
#endregion
}
private async void GenerateLoggerTemplate(string resourceGroup, string apimname, string fileFolder)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Geting loggers from service");
LoggerExtractor loggerExtractor = new LoggerExtractor();
PropertyExtractor propertyExtractor = new PropertyExtractor();
Template armTemplate = new Template()
{
schema = "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
contentVersion = "1.0.0.0",
parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
},
variables = { },
resources = { },
outputs = { }
};
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull named values for later credential reference
string properties = propertyExtractor.GetProperties(apimname, resourceGroup).Result;
JObject oProperties = JObject.Parse(properties);
List <PropertyTemplateResource> propertyResources = oProperties["value"].ToObject <List <PropertyTemplateResource> >();
string loggers = loggerExtractor.GetLoggers(apimname, resourceGroup).Result;
JObject oLoggers = JObject.Parse(loggers);
foreach (var extractedLogger in oLoggers["value"])
{
string loggerName = ((JValue)extractedLogger["name"]).Value.ToString();
Console.WriteLine("'{0}' Logger found", loggerName);
string fullLoggerResource = await loggerExtractor.GetLogger(apimname, resourceGroup, loggerName);
LoggerTemplateResource loggerResource = JsonConvert.DeserializeObject <LoggerTemplateResource>(fullLoggerResource);
loggerResource.name = $"[concat(parameters('ApimServiceName'), '/{loggerName}')]";
loggerResource.type = "Microsoft.ApiManagement/service/loggers";
loggerResource.apiVersion = "2018-06-01-preview";
loggerResource.scale = null;
// swap credentials for their hidden values, taken from named values
if (loggerResource.properties.credentials != null)
{
if (loggerResource.properties.credentials.instrumentationKey != null)
{
string hiddenKey = loggerResource.properties.credentials.instrumentationKey.Substring(2, loggerResource.properties.credentials.instrumentationKey.Length - 4);
loggerResource.properties.credentials.instrumentationKey = propertyResources.Find(p => p.properties.displayName == hiddenKey).properties.value;
}
else if (loggerResource.properties.credentials.connectionString != null)
{
string hiddenKey = loggerResource.properties.credentials.connectionString.Substring(2, loggerResource.properties.credentials.connectionString.Length - 4);
loggerResource.properties.credentials.connectionString = propertyResources.Find(p => p.properties.displayName == hiddenKey).properties.value;
}
}
templateResources.Add(loggerResource);
}
armTemplate.resources = templateResources.ToArray();
FileWriter fileWriter = new FileWriter();
string filePath = fileFolder + Path.DirectorySeparatorChar + string.Format("loggers", "/", "-") + ".json";
fileWriter.WriteJSONToFile(armTemplate, filePath);
}