public CreateCommand()
{
this.Name = GlobalConstants.CreateName;
this.Description = GlobalConstants.CreateDescription;
// list command options
CommandOption configFile = this.Option("--configFile <configFile>", "Config YAML file location", CommandOptionType.SingleValue).IsRequired();
CommandOption appInsightsInstrumentationKey = this.Option("--appInsightsInstrumentationKey <appInsightsInstrumentationKey>", "AppInsights intrumentationkey", CommandOptionType.SingleValue);
CommandOption appInsightsName = this.Option("--appInsightsName <appInsightsName>", "AppInsights Name", CommandOptionType.SingleValue);
// list command options
CommandOption backendurlconfigFile = this.Option("--backendurlconfigFile <backendurlconfigFile>", "backend url json file location", CommandOptionType.SingleValue);
this.HelpOption();
this.OnExecute(async() =>
{
// convert config file to CreatorConfig class
FileReader fileReader = new FileReader();
CreatorConfig creatorConfig = await fileReader.ConvertConfigYAMLToCreatorConfigAsync(configFile.Value());
AppInsightsUpdater appInsightsUpdater = new AppInsightsUpdater();
appInsightsUpdater.UpdateAppInsightNameAndInstrumentationKey(creatorConfig, appInsightsInstrumentationKey, appInsightsName);
// validate creator config
CreatorConfigurationValidator creatorConfigurationValidator = new CreatorConfigurationValidator(this);
//if backendurlfile passed as parameter
if (backendurlconfigFile != null && !string.IsNullOrEmpty(backendurlconfigFile.Value()))
{
CreatorApiBackendUrlUpdater creatorApiBackendUrlUpdater = new CreatorApiBackendUrlUpdater();
creatorConfig = creatorApiBackendUrlUpdater.UpdateBackendServiceUrl(backendurlconfigFile.Value(), creatorConfig);
}
bool isValidCreatorConfig = creatorConfigurationValidator.ValidateCreatorConfig(creatorConfig);
if (isValidCreatorConfig == true)
{
// required parameters have been supplied
// initialize file helper classes
FileWriter fileWriter = new FileWriter();
FileNameGenerator fileNameGenerator = new FileNameGenerator();
FileNames fileNames = creatorConfig.baseFileName == null ? fileNameGenerator.GenerateFileNames(creatorConfig.apimServiceName) : fileNameGenerator.GenerateFileNames(creatorConfig.baseFileName);
// initialize template creator classes
APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator();
LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator();
BackendTemplateCreator backendTemplateCreator = new BackendTemplateCreator();
AuthorizationServerTemplateCreator authorizationServerTemplateCreator = new AuthorizationServerTemplateCreator();
ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator();
TagAPITemplateCreator tagAPITemplateCreator = new TagAPITemplateCreator();
PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader);
ProductGroupTemplateCreator productGroupTemplateCreator = new ProductGroupTemplateCreator();
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
ReleaseTemplateCreator releaseTemplateCreator = new ReleaseTemplateCreator();
ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator(policyTemplateCreator, productGroupTemplateCreator);
PropertyTemplateCreator propertyTemplateCreator = new PropertyTemplateCreator();
TagTemplateCreator tagTemplateCreator = new TagTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, policyTemplateCreator, productAPITemplateCreator, tagAPITemplateCreator, diagnosticTemplateCreator, releaseTemplateCreator);
MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator();
// create templates from provided configuration
Console.WriteLine("Creating global service policy template");
Console.WriteLine("------------------------------------------");
Template globalServicePolicyTemplate = creatorConfig.policy != null ? policyTemplateCreator.CreateGlobalServicePolicyTemplate(creatorConfig) : null;
Console.WriteLine("Creating API version set template");
Console.WriteLine("------------------------------------------");
Template apiVersionSetsTemplate = creatorConfig.apiVersionSets != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null;
Console.WriteLine("Creating product template");
Console.WriteLine("------------------------------------------");
Template productsTemplate = creatorConfig.products != null ? productTemplateCreator.CreateProductTemplate(creatorConfig) : null;
Console.WriteLine("Creating named values template");
Console.WriteLine("------------------------------------------");
Template propertyTemplate = creatorConfig.namedValues != null ? propertyTemplateCreator.CreatePropertyTemplate(creatorConfig) : null;
Console.WriteLine("Creating logger template");
Console.WriteLine("------------------------------------------");
Template loggersTemplate = creatorConfig.loggers != null ? loggerTemplateCreator.CreateLoggerTemplate(creatorConfig) : null;
Console.WriteLine("Creating backend template");
Console.WriteLine("------------------------------------------");
Template backendsTemplate = creatorConfig.backends != null ? backendTemplateCreator.CreateBackendTemplate(creatorConfig) : null;
Console.WriteLine("Creating authorization server template");
Console.WriteLine("------------------------------------------");
Template authorizationServersTemplate = creatorConfig.authorizationServers != null ? authorizationServerTemplateCreator.CreateAuthorizationServerTemplate(creatorConfig) : null;
// store name and whether the api will depend on the version set template each api necessary to build linked templates
List <LinkedMasterTemplateAPIInformation> apiInformation = new List <LinkedMasterTemplateAPIInformation>();
List <Template> apiTemplates = new List <Template>();
Console.WriteLine("Creating API templates");
Console.WriteLine("------------------------------------------");
foreach (APIConfig api in creatorConfig.apis)
{
// create api templates from provided api config - if the api config contains a supplied apiVersion, split the templates into 2 for metadata and swagger content, otherwise create a unified template
List <Template> apiTemplateSet = await apiTemplateCreator.CreateAPITemplatesAsync(api);
apiTemplates.AddRange(apiTemplateSet);
// create the relevant info that will be needed to properly link to the api template(s) from the master template
apiInformation.Add(new LinkedMasterTemplateAPIInformation()
{
name = api.name,
isSplit = apiTemplateCreator.isSplitAPI(api),
dependsOnGlobalServicePolicies = creatorConfig.policy != null,
dependsOnVersionSets = api.apiVersionSetId != null,
dependsOnProducts = api.products != null,
dependsOnTags = api.tags != null,
dependsOnLoggers = await masterTemplateCreator.DetermineIfAPIDependsOnLoggerAsync(api, fileReader),
dependsOnAuthorizationServers = api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null,
dependsOnBackends = await masterTemplateCreator.DetermineIfAPIDependsOnBackendAsync(api, fileReader)
});
}
Console.WriteLine("Creating tag template");
Console.WriteLine("------------------------------------------");
Template tagTemplate = creatorConfig.tags != null ? tagTemplateCreator.CreateTagTemplate(creatorConfig) : null;
// create parameters file
Template templateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig);
// write templates to outputLocation
if (creatorConfig.linked == true)
{
// create linked master template
Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(creatorConfig, globalServicePolicyTemplate, apiVersionSetsTemplate, productsTemplate, propertyTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, tagTemplate, apiInformation, fileNames, creatorConfig.apimServiceName, fileNameGenerator);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, fileNames.linkedMaster));
}
foreach (Template apiTemplate in apiTemplates)
{
APITemplateResource apiResource = apiTemplate.resources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as APITemplateResource;
APIConfig providedAPIConfiguration = creatorConfig.apis.FirstOrDefault(api => string.Compare(apiResource.name, APITemplateCreator.MakeResourceName(api), true) == 0);
// if the api version is not null the api is split into multiple templates. If the template is split and the content value has been set, then the template is for a subsequent api
string apiFileName = fileNameGenerator.GenerateCreatorAPIFileName(providedAPIConfiguration.name, apiTemplateCreator.isSplitAPI(providedAPIConfiguration), apiResource.properties.value != null);
fileWriter.WriteJSONToFile(apiTemplate, String.Concat(creatorConfig.outputLocation, apiFileName));
}
if (globalServicePolicyTemplate != null)
{
fileWriter.WriteJSONToFile(globalServicePolicyTemplate, String.Concat(creatorConfig.outputLocation, fileNames.globalServicePolicy));
}
if (apiVersionSetsTemplate != null)
{
fileWriter.WriteJSONToFile(apiVersionSetsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.apiVersionSets));
}
if (productsTemplate != null)
{
fileWriter.WriteJSONToFile(productsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.products));
}
if (propertyTemplate != null)
{
fileWriter.WriteJSONToFile(propertyTemplate, String.Concat(creatorConfig.outputLocation, fileNames.namedValues));
}
if (loggersTemplate != null)
{
fileWriter.WriteJSONToFile(loggersTemplate, String.Concat(creatorConfig.outputLocation, fileNames.loggers));
}
if (backendsTemplate != null)
{
fileWriter.WriteJSONToFile(backendsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.backends));
}
if (authorizationServersTemplate != null)
{
fileWriter.WriteJSONToFile(authorizationServersTemplate, String.Concat(creatorConfig.outputLocation, fileNames.authorizationServers));
}
if (tagTemplate != null)
{
fileWriter.WriteJSONToFile(tagTemplate, String.Concat(creatorConfig.outputLocation, fileNames.tags));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(templateParameters, String.Concat(creatorConfig.outputLocation, fileNames.parameters));
Console.WriteLine("Templates written to output location");
}
return(0);
});
}
public string GenerateLinkedTemplateUri(CreatorConfig creatorConfig, string fileName)
{
return(creatorConfig.linkedTemplatesUrlQueryString != null ? $"[concat(parameters('LinkedTemplatesBaseUrl'), '{fileName}', parameters('LinkedTemplatesUrlQueryString'))]" : $"[concat(parameters('LinkedTemplatesBaseUrl'), '{fileName}')]");
}
public Template CreateLinkedMasterTemplate(CreatorConfig creatorConfig,
Template globalServicePolicyTemplate,
Template apiVersionSetTemplate,
Template productsTemplate,
Template loggersTemplate,
Template backendsTemplate,
Template authorizationServersTemplate,
Template tagTemplate,
List <LinkedMasterTemplateAPIInformation> apiInformation,
FileNames fileNames,
string apimServiceName,
FileNameGenerator fileNameGenerator)
{
// create empty template
Template masterTemplate = CreateEmptyTemplate();
// add parameters
masterTemplate.parameters = this.CreateMasterTemplateParameters(creatorConfig);
// add deployment resources that links to all resource files
List <TemplateResource> resources = new List <TemplateResource>();
// globalServicePolicy
if (globalServicePolicyTemplate != null)
{
string globalServicePolicyUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.globalServicePolicy);
resources.Add(this.CreateLinkedMasterTemplateResource("globalServicePolicyTemplate", globalServicePolicyUri, new string[] { }));
}
// apiVersionSet
if (apiVersionSetTemplate != null)
{
string apiVersionSetUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.apiVersionSets);
resources.Add(this.CreateLinkedMasterTemplateResource("versionSetTemplate", apiVersionSetUri, new string[] { }));
}
// product
if (productsTemplate != null)
{
string productsUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.products);
resources.Add(this.CreateLinkedMasterTemplateResource("productsTemplate", productsUri, new string[] { }));
}
// logger
if (loggersTemplate != null)
{
string loggersUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.loggers);
resources.Add(this.CreateLinkedMasterTemplateResource("loggersTemplate", loggersUri, new string[] { }));
}
// backend
if (backendsTemplate != null)
{
string backendsUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.backends);
resources.Add(this.CreateLinkedMasterTemplateResource("backendsTemplate", backendsUri, new string[] { }));
}
// authorizationServer
if (authorizationServersTemplate != null)
{
string authorizationServersUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.authorizationServers);
resources.Add(this.CreateLinkedMasterTemplateResource("authorizationServersTemplate", authorizationServersUri, new string[] { }));
}
// tag
if (tagTemplate != null)
{
string tagUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.tags);
resources.Add(this.CreateLinkedMasterTemplateResource("tagTemplate", tagUri, new string[] { }));
}
// each api has an associated api info class that determines whether the api is split and its dependencies on other resources
foreach (LinkedMasterTemplateAPIInformation apiInfo in apiInformation)
{
if (apiInfo.isSplit == true)
{
// add a deployment resource for both api template files
string originalAPIName = fileNameGenerator.GenerateOriginalAPIName(apiInfo.name);
string initialAPIDeploymentResourceName = $"{originalAPIName}-InitialAPITemplate";
string subsequentAPIDeploymentResourceName = $"{originalAPIName}-SubsequentAPITemplate";
string initialAPIFileName = fileNameGenerator.GenerateCreatorAPIFileName(apiInfo.name, apiInfo.isSplit, true, apimServiceName);
string initialAPIUri = GenerateLinkedTemplateUri(creatorConfig, initialAPIFileName);
string[] initialAPIDependsOn = CreateAPIResourceDependencies(globalServicePolicyTemplate, apiVersionSetTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, tagTemplate, apiInfo);
resources.Add(this.CreateLinkedMasterTemplateResource(initialAPIDeploymentResourceName, initialAPIUri, initialAPIDependsOn));
string subsequentAPIFileName = fileNameGenerator.GenerateCreatorAPIFileName(apiInfo.name, apiInfo.isSplit, false, apimServiceName);
string subsequentAPIUri = GenerateLinkedTemplateUri(creatorConfig, subsequentAPIFileName);
string[] subsequentAPIDependsOn = new string[] { $"[resourceId('Microsoft.Resources/deployments', '{initialAPIDeploymentResourceName}')]" };
resources.Add(this.CreateLinkedMasterTemplateResource(subsequentAPIDeploymentResourceName, subsequentAPIUri, subsequentAPIDependsOn));
}
else
{
// add a deployment resource for the unified api template file
string originalAPIName = fileNameGenerator.GenerateOriginalAPIName(apiInfo.name);
string unifiedAPIDeploymentResourceName = $"{originalAPIName}-APITemplate";
string unifiedAPIFileName = fileNameGenerator.GenerateCreatorAPIFileName(apiInfo.name, apiInfo.isSplit, true, apimServiceName);
string unifiedAPIUri = GenerateLinkedTemplateUri(creatorConfig, unifiedAPIFileName);
string[] unifiedAPIDependsOn = CreateAPIResourceDependencies(globalServicePolicyTemplate, apiVersionSetTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, tagTemplate, apiInfo);
resources.Add(this.CreateLinkedMasterTemplateResource(unifiedAPIDeploymentResourceName, unifiedAPIUri, unifiedAPIDependsOn));
}
}
masterTemplate.resources = resources.ToArray();
return(masterTemplate);
}
public Template CreateProductTemplate(CreatorConfig creatorConfig)
{
// create empty template
Template productTemplate = CreateEmptyTemplate();
// add parameters
productTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
foreach (ProductConfig product in creatorConfig.products)
{
if (string.IsNullOrEmpty(product.name))
{
product.name = product.displayName;
}
// create product resource with properties
ProductsTemplateResource productsTemplateResource = new ProductsTemplateResource()
{
name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.name}')]",
type = ResourceTypeConstants.Product,
apiVersion = GlobalConstants.APIVersion,
properties = new ProductsTemplateProperties()
{
description = product.description,
terms = product.terms,
subscriptionRequired = product.subscriptionRequired,
approvalRequired = product.subscriptionRequired ? product.approvalRequired : null,
subscriptionsLimit = product.subscriptionRequired ? product.subscriptionsLimit : null,
state = product.state,
displayName = product.displayName
},
dependsOn = new string[] { }
};
resources.Add(productsTemplateResource);
// create product policy resource that depends on the product, if provided
if (product.policy != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.name}')]" };
PolicyTemplateResource productPolicy = this.policyTemplateCreator.CreateProductPolicyTemplateResource(product, dependsOn);
resources.Add(productPolicy);
}
// create product group resources if provided
if (product.groups != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.name}')]" };
List <ProductGroupsValue> productGroups = this.productGroupTemplateCreator.CreateProductGroupTemplateResources(product, dependsOn);
resources.AddRange(productGroups);
}
}
productTemplate.resources = resources.ToArray();
return(productTemplate);
}
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 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 (creatorConfig.linked == true)
{
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 CreateCommand()
{
this.Name = GlobalConstants.CreateName;
this.Description = GlobalConstants.CreateDescription;
// list command options
CommandOption configFile = this.Option("--configFile <configFile>", "Config YAML file location", CommandOptionType.SingleValue).IsRequired();
this.HelpOption();
this.OnExecute(async() =>
{
// convert config file to CreatorConfig class
FileReader fileReader = new FileReader();
CreatorConfig creatorConfig = await fileReader.ConvertConfigYAMLToCreatorConfigAsync(configFile.Value());
// validate creator config
CreatorConfigurationValidator creatorConfigurationValidator = new CreatorConfigurationValidator(this);
bool isValidCreatorConfig = creatorConfigurationValidator.ValidateCreatorConfig(creatorConfig);
if (isValidCreatorConfig == true)
{
// required parameters have been supplied
// initialize file helper classes
FileWriter fileWriter = new FileWriter();
FileNameGenerator fileNameGenerator = new FileNameGenerator();
CreatorFileNames creatorFileNames = fileNameGenerator.GenerateCreatorLinkedFileNames();
// initialize template creator classes
APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator();
LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator();
ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator();
BackendTemplateCreator backendTemplateCreator = new BackendTemplateCreator();
AuthorizationServerTemplateCreator authorizationServerTemplateCreator = new AuthorizationServerTemplateCreator();
ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator();
PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader);
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, policyTemplateCreator, productAPITemplateCreator, diagnosticTemplateCreator);
MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator();
// create templates from provided configuration
Console.WriteLine("Creating API version set template");
Console.WriteLine("------------------------------------------");
Template apiVersionSetsTemplate = creatorConfig.apiVersionSets != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null;
Console.WriteLine("Creating product template");
Console.WriteLine("------------------------------------------");
Template productsTemplate = creatorConfig.products != null ? productTemplateCreator.CreateProductTemplate(creatorConfig) : null;
Console.WriteLine("Creating logger template");
Console.WriteLine("------------------------------------------");
Template loggersTemplate = creatorConfig.loggers != null ? loggerTemplateCreator.CreateLoggerTemplate(creatorConfig) : null;
Console.WriteLine("Creating backend template");
Console.WriteLine("------------------------------------------");
Template backendsTemplate = creatorConfig.backends != null ? backendTemplateCreator.CreateBackendTemplate(creatorConfig) : null;
Console.WriteLine("Creating authorization server template");
Console.WriteLine("------------------------------------------");
Template authorizationServersTemplate = creatorConfig.authorizationServers != null ? authorizationServerTemplateCreator.CreateAuthorizationServerTemplate(creatorConfig) : null;
// store name and whether the api will depend on the version set template each api necessary to build linked templates
List <LinkedMasterTemplateAPIInformation> apiInformation = new List <LinkedMasterTemplateAPIInformation>();
List <Template> apiTemplates = new List <Template>();
Console.WriteLine("Creating API templates");
Console.WriteLine("------------------------------------------");
foreach (APIConfig api in creatorConfig.apis)
{
// create api templates from provided api config - if the api config contains a supplied apiVersion, split the templates into 2 for metadata and swagger content, otherwise create a unified template
List <Template> apiTemplateSet = await apiTemplateCreator.CreateAPITemplatesAsync(creatorConfig, api);
apiTemplates.AddRange(apiTemplateSet);
// create the relevant info that will be needed to properly link to the api template(s) from the master template
apiInformation.Add(new LinkedMasterTemplateAPIInformation()
{
name = api.name,
isSplit = apiTemplateCreator.isSplitAPI(api),
dependsOnVersionSets = api.apiVersionSetId != null,
dependsOnProducts = api.products != null,
dependsOnLoggers = await masterTemplateCreator.DetermineIfAPIDependsOnLogger(api, fileReader),
dependsOnAuthorizationServers = api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null,
dependsOnBackends = await masterTemplateCreator.DetermineIfAPIDependsOnBackend(api, fileReader)
});
}
// create parameters file
Template masterTemplateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig);
// write templates to outputLocation
if (creatorConfig.linked == true)
{
// create linked master template
Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(apiVersionSetsTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, apiInformation, creatorFileNames, fileNameGenerator);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.linkedMaster));
}
foreach (Template apiTemplate in apiTemplates)
{
APITemplateResource apiResource = apiTemplate.resources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as APITemplateResource;
APIConfig providedAPIConfiguration = creatorConfig.apis.FirstOrDefault(api => apiResource.name.Contains(api.name));
// if the api version is not null the api is split into multiple templates. If the template is split and the content value has been set, then the template is for a subsequent api
string apiFileName = fileNameGenerator.GenerateAPIFileName(providedAPIConfiguration.name, apiTemplateCreator.isSplitAPI(providedAPIConfiguration), apiResource.properties.value == null);
fileWriter.WriteJSONToFile(apiTemplate, String.Concat(creatorConfig.outputLocation, apiFileName));
}
if (apiVersionSetsTemplate != null)
{
fileWriter.WriteJSONToFile(apiVersionSetsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.apiVersionSets));
}
if (productsTemplate != null)
{
fileWriter.WriteJSONToFile(productsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.products));
}
if (loggersTemplate != null)
{
fileWriter.WriteJSONToFile(loggersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.loggers));
}
if (backendsTemplate != null)
{
fileWriter.WriteJSONToFile(backendsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.backends));
}
if (authorizationServersTemplate != null)
{
fileWriter.WriteJSONToFile(authorizationServersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.authorizationServers));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(masterTemplateParameters, String.Concat(creatorConfig.outputLocation, creatorConfig.linked == true ? creatorFileNames.linkedParameters : creatorFileNames.unlinkedParameters));
Console.WriteLine("Templates written to output location");
Console.WriteLine("Press any key to exit process:");
#if DEBUG
Console.ReadKey();
#endif
}
return(0);
});
}
public void ShouldCreateDiagnosticTemplateResourceFromCreatorConfig()
{
// arrange
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
api = new APIConfig()
{
name = "name"
},
diagnostic = new DiagnosticTemplateProperties()
{
alwaysLog = "alwaysLog",
loggerId = "loggerId",
sampling = new DiagnosticTemplateSampling()
{
samplingType = "samplingType",
percentage = 100
},
frontend = new DiagnosticTemplateFrontendBackend()
{
request = new DiagnosticTemplateRequestResponse()
{
headers = new string[] { "frontendrequestheader" },
body = new DiagnosticTemplateRequestResponseBody()
{
bytes = 512
}
},
response = new DiagnosticTemplateRequestResponse()
{
headers = new string[] { "frontendresponseheader" },
body = new DiagnosticTemplateRequestResponseBody()
{
bytes = 512
}
}
},
backend = new DiagnosticTemplateFrontendBackend()
{
request = new DiagnosticTemplateRequestResponse()
{
headers = new string[] { "backendrequestheader" },
body = new DiagnosticTemplateRequestResponseBody()
{
bytes = 512
}
},
response = new DiagnosticTemplateRequestResponse()
{
headers = new string[] { "backendresponseheader" },
body = new DiagnosticTemplateRequestResponseBody()
{
bytes = 512
}
}
},
enableHttpCorrelationHeaders = true
}
};
// act
string[] dependsOn = new string[] { "dependsOn" };
DiagnosticTemplateResource diagnosticTemplateResource = diagnosticTemplateCreator.CreateAPIDiagnosticTemplateResource(creatorConfig, dependsOn);
// assert
Assert.Equal($"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}/diagnostic')]", diagnosticTemplateResource.name);
Assert.Equal(dependsOn, diagnosticTemplateResource.dependsOn);
Assert.Equal(creatorConfig.diagnostic.alwaysLog, diagnosticTemplateResource.properties.alwaysLog);
Assert.Equal(creatorConfig.diagnostic.loggerId, diagnosticTemplateResource.properties.loggerId);
Assert.Equal(creatorConfig.diagnostic.enableHttpCorrelationHeaders, diagnosticTemplateResource.properties.enableHttpCorrelationHeaders);
Assert.Equal(creatorConfig.diagnostic.sampling.samplingType, diagnosticTemplateResource.properties.sampling.samplingType);
Assert.Equal(creatorConfig.diagnostic.sampling.percentage, diagnosticTemplateResource.properties.sampling.percentage);
Assert.Equal(creatorConfig.diagnostic.frontend.request.headers, diagnosticTemplateResource.properties.frontend.request.headers);
Assert.Equal(creatorConfig.diagnostic.frontend.request.body.bytes, diagnosticTemplateResource.properties.frontend.request.body.bytes);
Assert.Equal(creatorConfig.diagnostic.frontend.response.headers, diagnosticTemplateResource.properties.frontend.response.headers);
Assert.Equal(creatorConfig.diagnostic.frontend.response.body.bytes, diagnosticTemplateResource.properties.frontend.response.body.bytes);
Assert.Equal(creatorConfig.diagnostic.backend.request.headers, diagnosticTemplateResource.properties.backend.request.headers);
Assert.Equal(creatorConfig.diagnostic.backend.request.body.bytes, diagnosticTemplateResource.properties.backend.request.body.bytes);
Assert.Equal(creatorConfig.diagnostic.backend.response.headers, diagnosticTemplateResource.properties.backend.response.headers);
Assert.Equal(creatorConfig.diagnostic.backend.response.body.bytes, diagnosticTemplateResource.properties.backend.response.body.bytes);
}
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 (ServiceUrlProperty 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 async Task <APITemplateResource> CreateInitialAPITemplateResourceAsync(CreatorConfig creatorConfig)
{
// protocols can be pulled by converting the OpenApiSpec into the OpenApiDocument class
OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader();
OpenApiDocument doc = await openAPISpecReader.ConvertOpenAPISpecToDoc(creatorConfig.api.openApiSpec);
// create api resource with properties
APITemplateResource apiTemplateResource = new APITemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}')]",
type = "Microsoft.ApiManagement/service/apis",
apiVersion = "2018-01-01",
properties = new APITemplateProperties()
{
// supplied via optional arguments
apiVersion = creatorConfig.api.apiVersion,
apiRevision = creatorConfig.api.revision,
apiRevisionDescription = creatorConfig.api.revisionDescription,
apiVersionDescription = creatorConfig.api.apiVersionDescription,
authenticationSettings = creatorConfig.api.authenticationSettings,
path = creatorConfig.api.suffix,
displayName = creatorConfig.api.name,
protocols = this.CreateProtocols(doc)
},
// if the template is not linked the depends on for the apiVersionSet needs to be inlined here
dependsOn = new string[] { }
};
string versionSetId = (creatorConfig.apiVersionSet != null && creatorConfig.apiVersionSet.id != null) ? creatorConfig.apiVersionSet.id : "versionset";
// if the template is linked and a version set was created, the initial api depends on it
if (creatorConfig.linked == false && creatorConfig.apiVersionSet != null)
{
apiTemplateResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{versionSetId}')]" };
}
// set the version set id
if (creatorConfig.apiVersionSet != null)
{
apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{versionSetId}')]";
}
else if (creatorConfig.api.apiVersionSetId != null)
{
apiTemplateResource.properties.apiVersionSetId = $"{creatorConfig.api.apiVersionSetId}";
}
return(apiTemplateResource);
}
public async Task <APITemplateResource> CreateInitialAPITemplateResourceAsync(CreatorConfig creatorConfig, APIConfig api)
{
// protocols can be pulled by converting the OpenApiSpec into the OpenApiDocument class
OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader();
OpenApiDocument doc = await openAPISpecReader.ConvertOpenAPISpecToDoc(api.openApiSpec);
// create api resource with properties
APITemplateResource apiTemplateResource = new APITemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{api.name}')]",
type = ResourceTypeConstants.API,
apiVersion = "2018-06-01-preview",
properties = new APITemplateProperties()
{
// supplied via optional arguments
apiVersion = api.apiVersion,
subscriptionRequired = api.subscriptionRequired,
apiRevision = api.revision,
apiRevisionDescription = api.revisionDescription,
apiVersionDescription = api.apiVersionDescription,
authenticationSettings = api.authenticationSettings,
path = api.suffix,
displayName = api.name,
protocols = this.CreateProtocols(doc)
},
// if the template is not linked the depends on for the apiVersionSet needs to be inlined here
dependsOn = new string[] { }
};
// set the version set id
if (api.apiVersionSetId != null)
{
apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{api.apiVersionSetId}')]";
}
return(apiTemplateResource);
}
