public async void ShouldCreateAPITemplateResourceFromCreatorConfigWithoutServiceUrlParameter()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
openApiSpec = "https://petstore.swagger.io/v2/swagger.json",
serviceUrl = "https://petstore.swagger.io"
};
creatorConfig.apis.Add(api);
// act
// the above api config will create a unified api template with a single resource
List <Template> apiTemplates = await apiTemplateCreator.CreateAPITemplatesAsync(api);
APITemplateResource apiTemplateResource = apiTemplates.FirstOrDefault().resources[0] as APITemplateResource;
// assert
Assert.Single(apiTemplates.First().parameters);
Assert.False(apiTemplates.First().parameters.ContainsKey(ParameterNames.ServiceUrl));
Assert.Equal("https://petstore.swagger.io", apiTemplateResource.properties.serviceUrl);
}
public async void ShouldCreateSubsequentlAPITemplateResourceFromCreatorConfigWithAlternateTitle()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
displayName = "Swagger Petstore (alternate title)",
openApiSpec = "https://petstore.swagger.io/v2/swagger.json",
};
creatorConfig.apis.Add(api);
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, true, true);
// assert
Assert.Equal($"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{api.name}')]", apiTemplateResource.Name);
Assert.Equal("swagger-json", apiTemplateResource.Properties.Format);
// check alternate title has been specified in the embedded YAML or JSON definition
var yaml = apiTemplateResource.Properties.Value;
var deserializer = new YamlDotNet.Serialization.Deserializer();
var definition = deserializer.Deserialize <Dictionary <string, object> >(yaml);
var info = (Dictionary <object, object>)definition["info"];
Assert.Equal("Swagger Petstore (alternate title)", info["title"]);
}
public async Task <Template> CreateAPITemplateAsync(APIConfig api, bool isSplit, bool isInitial)
{
// create empty template
Template apiTemplate = CreateEmptyTemplate();
// add parameters
apiTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource
APITemplateResource apiTemplateResource = await this.CreateAPITemplateResourceAsync(api, isSplit, isInitial);
resources.Add(apiTemplateResource);
// add the api child resources (api policies, diagnostics, etc) if this is the unified or subsequent template
if (!isSplit || !isInitial)
{
resources.AddRange(CreateChildResourceTemplates(api));
}
apiTemplate.resources = resources.ToArray();
return(apiTemplate);
}
public async void ShouldAppendRevisionToAPIName()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
apiRevision = "2",
isCurrent = false,
suffix = "suffix",
subscriptionRequired = true,
openApiSpec = "https://petstore.swagger.io/v2/swagger.json",
};
creatorConfig.apis.Add(api);
// act
// the above api config will create a unified api template with a single resource
List <Template> apiTemplates = await apiTemplateCreator.CreateAPITemplatesAsync(api);
APITemplateResource apiTemplateResource = apiTemplates.FirstOrDefault().Resources[0] as APITemplateResource;
// assert
Assert.Contains(";rev", apiTemplateResource.Name);
}
public APITemplateResource CreateSubsequentAPITemplateResource(CreatorConfig creatorConfig)
{
// create api resource with properties
string subsequentAPIName = $"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}')]";
string subsequentAPIType = "Microsoft.ApiManagement/service/apis";
Uri uriResult;
bool isUrl = Uri.TryCreate(creatorConfig.api.openApiSpec, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// used to escape sequences in local swagger json
object deserializedFileContents = isUrl ? null : JsonConvert.DeserializeObject <object>(this.fileReader.RetrieveLocalFileContents(creatorConfig.api.openApiSpec));
APITemplateResource apiTemplateResource = new APITemplateResource()
{
name = subsequentAPIName,
type = subsequentAPIType,
apiVersion = "2018-06-01-preview",
properties = new APITemplateProperties()
{
contentFormat = isUrl ? "swagger-link-json" : "swagger-json",
contentValue = isUrl ? creatorConfig.api.openApiSpec : JsonConvert.SerializeObject(deserializedFileContents),
// supplied via optional arguments
path = creatorConfig.api.suffix
},
dependsOn = new string[] { }
};
return(apiTemplateResource);
}
public void ShouldWriteJSONToFile()
{
// arrange
string location = string.Concat("..", Path.DirectorySeparatorChar,
"..", Path.DirectorySeparatorChar,
"..", Path.DirectorySeparatorChar,
"Creator", Path.DirectorySeparatorChar,
"example.json");
APITemplateResource testObject = new APITemplateResource()
{
ApiVersion = ""
};
JObject testJSON = JObject.FromObject(testObject);
// delete existing file if exists
if (File.Exists(location))
{
File.Delete(location);
}
// write new
FileWriter.WriteJSONToFile(testJSON, location);
// assert
Assert.True(File.Exists(location));
File.Delete(location);
}
public async Task <APITemplateResource> CreateAPITemplateResourceAsync(APIConfig api, bool isSplit, bool isInitial)
{
// create api resource
APITemplateResource apiTemplateResource = new APITemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{api.name}')]",
type = ResourceTypeConstants.API,
apiVersion = GlobalConstants.APIVersion,
properties = new APITemplateProperties(),
dependsOn = new string[] { }
};
// add properties depending on whether the template is the initial, subsequent, or unified
if (!isSplit || isInitial)
{
// add metadata properties for initial and unified templates
// protocols can be pulled by converting the OpenApiSpec into the OpenApiDocument class
OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader();
OpenApiDocument doc = await openAPISpecReader.ConvertOpenAPISpecToDoc(api.openApiSpec);
// supplied via optional arguments
apiTemplateResource.properties.apiVersion = api.apiVersion;
apiTemplateResource.properties.subscriptionRequired = api.subscriptionRequired;
apiTemplateResource.properties.apiRevision = api.revision;
apiTemplateResource.properties.apiRevisionDescription = api.revisionDescription;
apiTemplateResource.properties.apiVersionDescription = api.apiVersionDescription;
apiTemplateResource.properties.authenticationSettings = api.authenticationSettings;
apiTemplateResource.properties.path = api.suffix;
apiTemplateResource.properties.isCurrent = api.isCurrent;
apiTemplateResource.properties.displayName = api.name;
apiTemplateResource.properties.protocols = this.CreateProtocols(doc);
// set the version set id
if (api.apiVersionSetId != null)
{
// point to the supplied version set if the apiVersionSetId is provided
apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/apiVersionSets', parameters('ApimServiceName'), '{api.apiVersionSetId}')]";
}
// set the authorization server id
if (api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null &&
apiTemplateResource.properties.authenticationSettings != null && apiTemplateResource.properties.authenticationSettings.oAuth2 != null && apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId != null)
{
apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId = $"[resourceId('Microsoft.ApiManagement/service/authorizationServers', parameters('ApimServiceName'), '{api.authenticationSettings.oAuth2.authorizationServerId}')]";
}
}
if (!isSplit || !isInitial)
{
// add swagger properties for subsequent and unified templates
Uri uriResult;
bool isUrl = Uri.TryCreate(api.openApiSpec, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// used to escape sequences in local swagger json
object deserializedFileContents = isUrl ? null : JsonConvert.DeserializeObject <object>(this.fileReader.RetrieveLocalFileContents(api.openApiSpec));
// if openApiSpec is a url inline the url, if it is a local file inline the file contents
apiTemplateResource.properties.format = isUrl ? "swagger-link-json" : "swagger-json";
apiTemplateResource.properties.value = isUrl ? api.openApiSpec : JsonConvert.SerializeObject(deserializedFileContents);
// supplied via optional arguments
apiTemplateResource.properties.path = api.suffix;
}
return(apiTemplateResource);
}
public async void ShouldCreateUnifiedAPITemplateResourceFromCreatorConfig()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
apiVersion = "apiVersion",
apiVersionDescription = "apiVersionDescription",
apiVersionSetId = "apiVersionSetId",
revision = "revision",
revisionDescription = "revisionDescription",
suffix = "suffix",
subscriptionRequired = true,
authenticationSettings = new APITemplateAuthenticationSettings()
{
oAuth2 = new APITemplateOAuth2()
{
authorizationServerId = "",
scope = ""
},
openid = new APITemplateOpenID()
{
openidProviderId = "",
bearerTokenSendingMethods = new string[] { }
},
subscriptionKeyRequired = true
},
openApiSpec = "https://petstore.swagger.io/v2/swagger.json",
};
creatorConfig.apis.Add(api);
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, false, true);
// assert
Assert.Equal($"[concat(parameters('ApimServiceName'), '/{api.name}')]", apiTemplateResource.name);
Assert.Equal(api.name, apiTemplateResource.properties.displayName);
Assert.Equal(api.apiVersion, apiTemplateResource.properties.apiVersion);
Assert.Equal(api.apiVersionDescription, apiTemplateResource.properties.apiVersionDescription);
Assert.Equal($"[resourceId('Microsoft.ApiManagement/service/apiVersionSets', parameters('ApimServiceName'), '{api.apiVersionSetId}')]", apiTemplateResource.properties.apiVersionSetId);
Assert.Equal(api.revision, apiTemplateResource.properties.apiRevision);
Assert.Equal(api.revisionDescription, apiTemplateResource.properties.apiRevisionDescription);
Assert.Equal(api.suffix, apiTemplateResource.properties.path);
Assert.Equal(api.subscriptionRequired, apiTemplateResource.properties.subscriptionRequired);
Assert.Equal(api.authenticationSettings.oAuth2.authorizationServerId, apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId);
Assert.Equal(api.authenticationSettings.oAuth2.scope, apiTemplateResource.properties.authenticationSettings.oAuth2.scope);
Assert.Equal(api.authenticationSettings.openid.openidProviderId, apiTemplateResource.properties.authenticationSettings.openid.openidProviderId);
Assert.Equal(api.authenticationSettings.openid.bearerTokenSendingMethods, apiTemplateResource.properties.authenticationSettings.openid.bearerTokenSendingMethods);
Assert.Equal(api.authenticationSettings.subscriptionKeyRequired, apiTemplateResource.properties.authenticationSettings.subscriptionKeyRequired);
Assert.Equal("swagger-link-json", apiTemplateResource.properties.format);
Assert.Equal(api.openApiSpec, apiTemplateResource.properties.value);
}
public async void ShouldCreateInitialAPITemplateResourceFromCreatorConfig()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
api = new APIConfig()
{
name = "name",
apiVersion = "apiVersion",
apiVersionDescription = "apiVersionDescription",
apiVersionSetId = "apiVersionSetId",
revision = "revision",
revisionDescription = "revisionDescription",
suffix = "suffix",
subscriptionRequired = true,
authenticationSettings = new APITemplateAuthenticationSettings()
{
oAuth2 = new APITemplateOAuth2()
{
authorizationServerId = "",
scope = ""
},
openid = new APITemplateOpenID()
{
openidProviderId = "",
bearerTokenSendingMethods = new string[] { }
},
subscriptionKeyRequired = true
},
openApiSpec = "https://petstore.swagger.io/v2/swagger.json"
}
};
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateInitialAPITemplateResourceAsync(creatorConfig);
// assert
Assert.Equal($"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}')]", apiTemplateResource.name);
Assert.Equal(creatorConfig.api.name, apiTemplateResource.properties.displayName);
Assert.Equal(creatorConfig.api.apiVersion, apiTemplateResource.properties.apiVersion);
Assert.Equal(creatorConfig.api.apiVersionDescription, apiTemplateResource.properties.apiVersionDescription);
Assert.Equal(creatorConfig.api.apiVersionSetId, apiTemplateResource.properties.apiVersionSetId);
Assert.Equal(creatorConfig.api.revision, apiTemplateResource.properties.apiRevision);
Assert.Equal(creatorConfig.api.revisionDescription, apiTemplateResource.properties.apiRevisionDescription);
Assert.Equal(creatorConfig.api.suffix, apiTemplateResource.properties.path);
Assert.Equal(creatorConfig.api.subscriptionRequired, apiTemplateResource.properties.subscriptionRequired);
Assert.Equal(creatorConfig.api.authenticationSettings.oAuth2.authorizationServerId, apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId);
Assert.Equal(creatorConfig.api.authenticationSettings.oAuth2.scope, apiTemplateResource.properties.authenticationSettings.oAuth2.scope);
Assert.Equal(creatorConfig.api.authenticationSettings.openid.openidProviderId, apiTemplateResource.properties.authenticationSettings.openid.openidProviderId);
Assert.Equal(creatorConfig.api.authenticationSettings.openid.bearerTokenSendingMethods, apiTemplateResource.properties.authenticationSettings.openid.bearerTokenSendingMethods);
Assert.Equal(creatorConfig.api.authenticationSettings.subscriptionKeyRequired, apiTemplateResource.properties.authenticationSettings.subscriptionKeyRequired);
}
public async Task <string> GetAPIServiceUrl(string apiManagementName, string resourceGroupName, string apiName)
{
(string azToken, string azSubId) = await this.Auth.GetAccessToken();
string requestUrl = string.Format("{0}/subscriptions/{1}/resourceGroups/{2}/providers/Microsoft.ApiManagement/service/{3}/apis/{4}?api-version={5}",
BaseUrl, azSubId, resourceGroupName, apiManagementName, apiName, GlobalConstants.ApiVersion);
string apiDetails = await this.CallApiManagementAsync(azToken, requestUrl);
APITemplateResource apiResource = apiDetails.Deserialize <APITemplateResource>();
return(apiResource.Properties.ServiceUrl);
}
public Template CreateSubsequentAPITemplate(CreatorConfig creatorConfig)
{
// create empty template
Template apiTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters
apiTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
string apiName = creatorConfig.api.name;
string[] dependsOnSubsequentAPI = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource w/ swagger content and policies
APITemplateResource subsequentAPITemplateResource = this.CreateSubsequentAPITemplateResource(creatorConfig);
PolicyTemplateResource apiPolicyResource = creatorConfig.api.policy != null?this.policyTemplateCreator.CreateAPIPolicyTemplateResource(creatorConfig, dependsOnSubsequentAPI) : null;
List <PolicyTemplateResource> operationPolicyResources = creatorConfig.api.operations != null?this.policyTemplateCreator.CreateOperationPolicyTemplateResources(creatorConfig, dependsOnSubsequentAPI) : null;
List <ProductAPITemplateResource> productAPIResources = creatorConfig.api.products != null?this.productAPITemplateCreator.CreateProductAPITemplateResources(creatorConfig, dependsOnSubsequentAPI) : null;
DiagnosticTemplateResource diagnosticTemplateResource = creatorConfig.api.diagnostic != null?this.diagnosticTemplateCreator.CreateAPIDiagnosticTemplateResource(creatorConfig, dependsOnSubsequentAPI) : null;
resources.Add(subsequentAPITemplateResource);
// add resources if not null
if (apiPolicyResource != null)
{
resources.Add(apiPolicyResource);
}
if (operationPolicyResources != null)
{
resources.AddRange(operationPolicyResources);
}
if (productAPIResources != null)
{
resources.AddRange(productAPIResources);
}
if (diagnosticTemplateResource != null)
{
resources.Add(diagnosticTemplateResource);
}
apiTemplate.resources = resources.ToArray();
return(apiTemplate);
}
public async Task <string> GetAPIServiceUrl(string ApiManagementName, string ResourceGroupName, string ApiName)
{
(string azToken, string azSubId) = await auth.GetAccessToken();
string requestUrl = string.Format("{0}/subscriptions/{1}/resourceGroups/{2}/providers/Microsoft.ApiManagement/service/{3}/apis/{4}?api-version={5}",
baseUrl, azSubId, ResourceGroupName, ApiManagementName, ApiName, GlobalConstants.APIVersion);
string apiDetails = await CallApiManagementAsync(azToken, requestUrl);
JObject oApiDetails = JObject.Parse(apiDetails);
APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails);
return(apiResource.properties.serviceUrl);
}
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-06-01-preview",
properties = new APITemplateProperties()
{
// supplied via optional arguments
apiVersion = creatorConfig.api.apiVersion,
subscriptionRequired = creatorConfig.api.subscriptionRequired,
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 void ShouldCreateSubsequentlAPITemplateResourceFromCreatorConfigWithAlternateTitleInOpenApi()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
// extract swagger as a local file
var openapiPath = Path.GetTempFileName();
using (var stream = new FileStream($"Resources{Path.DirectorySeparatorChar}OpenApiSpecs{Path.DirectorySeparatorChar}swaggerPetstore.yml", FileMode.Open))
using (var reader = new StreamReader(stream))
File.WriteAllText(openapiPath, reader.ReadToEnd());
// create API config with local swagger definition
APIConfig api = new APIConfig()
{
name = "name",
displayName = "Swagger Petstore (alternate title)",
openApiSpec = openapiPath,
};
creatorConfig.apis.Add(api);
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, true, true);
// assert
Assert.Equal($"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{api.name}')]", apiTemplateResource.Name);
Assert.Equal("openapi", apiTemplateResource.Properties.Format);
// check alternate title has been specified in the embedded YAML or JSON definition
var yaml = apiTemplateResource.Properties.Value;
var deserializer = new YamlDotNet.Serialization.Deserializer();
var definition = deserializer.Deserialize <Dictionary <string, object> >(yaml);
var info = (Dictionary <object, object>)definition["info"];
Assert.Equal("Swagger Petstore (alternate title)", info["title"]);
}
// this function will get the current revision of this api and will remove "isCurrent" paramter
public async Task <List <TemplateResource> > GenerateCurrentRevisionAPIResourceAsync(string apiName, Extractor exc)
{
List <TemplateResource> templateResources = new List <TemplateResource>();
string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup, fileFolder = exc.fileFolder, policyXMLBaseUrl = exc.policyXMLBaseUrl, policyXMLSasToken = exc.policyXMLSasToken;
string apiDetails = await GetAPIDetailsAsync(apimname, resourceGroup, apiName);
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting resources from {0} API:", apiName);
// convert returned api to template resource class
JObject oApiDetails = JObject.Parse(apiDetails);
APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails);
apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString();
apiResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}')]";
apiResource.apiVersion = GlobalConstants.APIVersion;
apiResource.scale = null;
apiResource.properties.isCurrent = null;
if (exc.paramServiceUrl)
{
apiResource.properties.serviceUrl = $"[parameters('{ParameterNames.ServiceUrl}').{ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api)}]";
}
if (apiResource.properties.apiVersionSetId != null)
{
apiResource.dependsOn = new string[] { };
string versionSetName = apiResource.properties.apiVersionSetId;
int versionSetPosition = versionSetName.IndexOf("apiVersionSets/");
versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition));
apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('{ParameterNames.ApimServiceName}')), '/{versionSetName}')]";
}
else
{
apiResource.dependsOn = new string[] { };
}
templateResources.Add(apiResource);
templateResources.AddRange(await GetRelatedTemplateResourcesAsync(apiName, exc));
return(templateResources);
}
public async void ShouldCreateSubsequentlAPITemplateResourceFromCreatorConfigWithAlternateTitleInSwagger()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
// extract swagger as a local file
var swaggerPath = Path.GetTempFileName();
using (var stream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("apimtemplate.test.Resources.swaggerPetstorev3.json"))
using (var reader = new StreamReader(stream))
File.WriteAllText(swaggerPath, reader.ReadToEnd());
// create API config with local swagger definition
APIConfig api = new APIConfig()
{
name = "name",
displayName = "Swagger Petstore (alternate title)",
openApiSpec = swaggerPath,
};
creatorConfig.apis.Add(api);
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, true, true);
// assert
Assert.Equal($"[concat(parameters('ApimServiceName'), '/{api.name}')]", apiTemplateResource.name);
Assert.Equal("openapi+json", apiTemplateResource.properties.format);
// check alternate title has been specified in the embedded YAML or JSON definition
var yaml = apiTemplateResource.properties.value;
var deserializer = new YamlDotNet.Serialization.Deserializer();
var definition = deserializer.Deserialize <Dictionary <string, object> >(yaml);
var info = (Dictionary <object, object>)definition["info"];
Assert.Equal("Swagger Petstore (alternate title)", info["title"]);
}
public async Task <Template> CreateAPITemplateAsync(APIConfig api, bool isSplit, bool isInitial)
{
// create empty template
Template apiTemplate = CreateEmptyTemplate();
// add parameters
apiTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource
APITemplateResource apiTemplateResource = await this.CreateAPITemplateResourceAsync(api, isSplit, isInitial);
switch (apiTemplateResource.properties.format)
{
case "openapi-link":
case "swagger-link-json":
apiTemplate.parameters.Add("OpenSpecApiUrl", new TemplateParameterProperties {
type = "string", defaultValue = apiTemplateResource.properties.value
});
apiTemplateResource.properties.value = "[parameters('OpenSpecApiUrl')]";
break;
default: break;
}
resources.Add(apiTemplateResource);
// add the api child resources (api policies, diagnostics, etc) if this is the unified or subsequent template
if (!isSplit || !isInitial)
{
resources.AddRange(CreateChildResourceTemplates(api));
}
apiTemplate.resources = resources.ToArray();
return(apiTemplate);
}
public void ShouldCreateSubsequentlAPITemplateResourceFromCreatorConfigWithCorrectContent()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
api = new APIConfig()
{
name = "name",
openApiSpec = "https://petstore.swagger.io/v2/swagger.json"
}
};
// act
APITemplateResource apiTemplateResource = apiTemplateCreator.CreateSubsequentAPITemplateResource(creatorConfig);
// assert
Assert.Equal($"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}')]", apiTemplateResource.name);
Assert.Equal("swagger-link-json", apiTemplateResource.properties.contentFormat);
Assert.Equal(creatorConfig.api.openApiSpec, apiTemplateResource.properties.contentValue);
}
public async void ShouldUseDefaultVersionSetIdWithoutProvidedVersionSet()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apiVersionSet = new APIVersionSetConfig()
{
},
api = new APIConfig()
{
openApiSpec = "https://petstore.swagger.io/v2/swagger.json"
}
};
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateInitialAPITemplateResourceAsync(creatorConfig);
// assert
Assert.Equal("[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), 'versionset')]", apiTemplateResource.properties.apiVersionSetId);
}
public async Task <Template> CreateAPITemplateAsync(APIConfig api, bool isSplit, bool isInitial, bool mergeTemplates = false)
{
// create empty template
Template apiTemplate = CreateEmptyTemplate();
// add parameters
apiTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} },
{ ParameterNames.ServiceUrl, new TemplateParameterProperties()
{
type = "string", defaultValue = api.serviceUrl
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource
APITemplateResource apiTemplateResource = await this.CreateAPITemplateResourceAsync(api, isSplit, isInitial, mergeTemplates);
resources.Add(apiTemplateResource);
// add the api child resources (api policies, diagnostics, etc) if this is the unified or subsequent template
if (!isSplit || !isInitial)
{
resources.AddRange(CreateChildResourceTemplates(api));
if (api.diagnostic != null)
{
apiTemplate.parameters.Add(ParameterNames.LoggerName, new TemplateParameterProperties {
type = "string", defaultValue = api.diagnostic.loggerId
});
}
}
apiTemplate.resources = resources.ToArray();
return(apiTemplate);
}
public async Task <Template> CreateInitialAPITemplateAsync(CreatorConfig creatorConfig)
{
// create empty template
Template apiTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters
apiTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource w/ metadata
APITemplateResource initialAPITemplateResource = await this.CreateInitialAPITemplateResourceAsync(creatorConfig);
resources.Add(initialAPITemplateResource);
apiTemplate.resources = resources.ToArray();
return(apiTemplate);
}
public async void ShouldCreateSubsequentlAPITemplateResourceFromCreatorConfigWithCorrectContent()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
openApiSpec = "https://petstore.swagger.io/v2/swagger.json"
};
creatorConfig.apis.Add(api);
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, true, true);
// assert
Assert.Equal($"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{api.name}')]", apiTemplateResource.Name);
Assert.Equal("swagger-link-json", apiTemplateResource.Properties.Format);
Assert.Equal(api.openApiSpec, apiTemplateResource.Properties.Value);
}
public async Task <Template> CreateAPITemplateAsync(APIConfig api, bool isSplit, bool isInitial)
{
// create empty template
Template apiTemplate = this.templateBuilder.GenerateEmptyTemplate().Build();
// add parameters
apiTemplate.Parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} }
};
if (!string.IsNullOrEmpty(api.serviceUrl))
{
apiTemplate.Parameters.Add(api.name + "-ServiceUrl", new TemplateParameterProperties()
{
type = "string"
});
}
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource
APITemplateResource apiTemplateResource = await this.CreateAPITemplateResourceAsync(api, isSplit, isInitial);
resources.Add(apiTemplateResource);
// add the api child resources (api policies, diagnostics, etc) if this is the unified or subsequent template
if (!isSplit || !isInitial)
{
resources.AddRange(this.CreateChildResourceTemplates(api));
}
apiTemplate.Resources = resources.ToArray();
return(apiTemplate);
}
public async Task <Template> GenerateAPIsARMTemplate(string apimname, string resourceGroup, string fileFolder, string singleApiName)
{
// pull all apis from service
string apis = await GetAPIs(apimname, resourceGroup);
// initialize arm template
Template armTemplate = GenerateEmptyTemplateWithParameters();
JObject oApi = JObject.Parse(apis);
oApi = FormatoApi(singleApiName, oApi);
Console.WriteLine("{0} API's found ...", ((JContainer)oApi["value"]).Count.ToString());
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 = await GetAPIDetails(apimname, resourceGroup, apiName);
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting resources from {0} API:", apiName);
// convert returned api to template resource class
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 = GlobalConstants.APIVersion;
apiResource.scale = null;
if (apiResource.properties.apiVersionSetId != null)
{
apiResource.dependsOn = new string[] { };
string versionSetName = apiResource.properties.apiVersionSetId;
int versionSetPosition = versionSetName.IndexOf("apiVersionSets/");
versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition));
apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('ApimServiceName')), '/{versionSetName}')]";
}
else
{
apiResource.dependsOn = new string[] { };
}
templateResources.Add(apiResource);
#region Schemas
// add schema resources to api template
List <TemplateResource> schemaResources = await GenerateSchemasARMTemplate(apimname, apiName, resourceGroup, fileFolder);
templateResources.AddRange(schemaResources);
#endregion
#region Operations
// pull api operations for service
string operations = await GetAPIOperations(apimname, resourceGroup, apiName);
JObject oOperations = JObject.Parse(operations);
foreach (var item in oOperations["value"])
{
string operationName = ((JValue)item["name"]).Value.ToString();
string operationDetails = await GetAPIOperationDetail(apimname, resourceGroup, apiName, operationName);
Console.WriteLine("'{0}' Operation found", operationName);
// convert returned operation to template resource class
OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails);
string operationResourceName = operationResource.name;
operationResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}')]";
operationResource.apiVersion = GlobalConstants.APIVersion;
operationResource.scale = null;
// add api and schemas to operation dependsOn, 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);
// add operation policy resource to api template
try
{
string operationPolicy = await GetOperationPolicy(apimname, resourceGroup, oApiName, operationName);
Console.WriteLine($" - Operation policy found for {operationName} operation");
PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy);
operationPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = GlobalConstants.APIVersion;
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{oApiName}', '{operationResourceName}')]" };
templateResources.Add(operationPolicyResource);
}
catch (Exception) { }
}
#endregion
#region API Policies
// add api policy resource to api template
try
{
string apiPolicies = await GetAPIPolicies(apimname, resourceGroup, apiName);
Console.WriteLine("API policy found");
PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies);
apiPoliciesResource.apiVersion = GlobalConstants.APIVersion;
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) { }
#endregion
// add product api associations to template
#region API Products
try
{
// pull product api associations
string apiProducts = await GetAPIProducts(apimname, resourceGroup, apiName);
JObject oApiProducts = JObject.Parse(apiProducts);
foreach (var item in oApiProducts["value"])
{
string apiProductName = ((JValue)item["name"]).Value.ToString();
Console.WriteLine("'{0}' Product association found", apiProductName);
// convert returned api product associations to template resource class
ProductAPITemplateResource productAPIResource = JsonConvert.DeserializeObject <ProductAPITemplateResource>(apiProducts);
productAPIResource.type = ResourceTypeConstants.ProductAPI;
productAPIResource.name = $"[concat(parameters('ApimServiceName'), '/{apiProductName}/{oApiName}')]";
productAPIResource.apiVersion = GlobalConstants.APIVersion;
productAPIResource.scale = null;
productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
templateResources.Add(productAPIResource);
}
}
catch (Exception) { }
#endregion
#region Diagnostics
// add diagnostics to template
// pull diagnostics for api
string diagnostics = await GetAPIDiagnostics(apimname, resourceGroup, apiName);
JObject oDiagnostics = JObject.Parse(diagnostics);
foreach (var diagnostic in oDiagnostics["value"])
{
string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString();
Console.WriteLine("'{0}' Diagnostic found", diagnosticName);
// convert returned diagnostic to template resource class
DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>();
diagnosticResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{diagnosticName}')]";
diagnosticResource.type = ResourceTypeConstants.APIDiagnostic;
diagnosticResource.apiVersion = GlobalConstants.APIVersion;
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();
return(armTemplate);
}
public async Task <APITemplateResource> CreateAPITemplateResourceAsync(APIConfig api, bool isSplit, bool isInitial)
{
// create api resource
APITemplateResource apiTemplateResource = new APITemplateResource()
{
name = MakeResourceName(api),
type = ResourceTypeConstants.API,
apiVersion = GlobalConstants.APIVersion,
properties = new APITemplateProperties(),
dependsOn = new string[] { }
};
// add properties depending on whether the template is the initial, subsequent, or unified
if (!isSplit || !isInitial)
{
// add metadata properties for initial and unified templates
apiTemplateResource.properties.apiVersion = api.apiVersion;
apiTemplateResource.properties.serviceUrl = MakeServiceUrl(api);
apiTemplateResource.properties.type = api.type;
apiTemplateResource.properties.apiType = api.type;
apiTemplateResource.properties.description = api.description;
apiTemplateResource.properties.subscriptionRequired = api.subscriptionRequired;
apiTemplateResource.properties.apiRevision = api.apiRevision;
apiTemplateResource.properties.apiRevisionDescription = api.apiRevisionDescription;
apiTemplateResource.properties.apiVersionDescription = api.apiVersionDescription;
apiTemplateResource.properties.authenticationSettings = api.authenticationSettings;
apiTemplateResource.properties.subscriptionKeyParameterNames = api.subscriptionKeyParameterNames;
apiTemplateResource.properties.path = api.suffix;
apiTemplateResource.properties.isCurrent = api.isCurrent;
apiTemplateResource.properties.displayName = string.IsNullOrEmpty(api.displayName) ? api.name : api.displayName;
apiTemplateResource.properties.protocols = this.CreateProtocols(api);
// set the version set id
if (api.apiVersionSetId != null)
{
// point to the supplied version set if the apiVersionSetId is provided
apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/apiVersionSets', parameters('{ParameterNames.ApimServiceName}'), '{api.apiVersionSetId}')]";
}
// set the authorization server id
if (api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null &&
apiTemplateResource.properties.authenticationSettings != null && apiTemplateResource.properties.authenticationSettings.oAuth2 != null && apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId != null)
{
apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId = api.authenticationSettings.oAuth2.authorizationServerId;
}
// set the subscriptionKey Parameter Names
if (api.subscriptionKeyParameterNames != null)
{
if (api.subscriptionKeyParameterNames.header != null)
{
apiTemplateResource.properties.subscriptionKeyParameterNames.header = api.subscriptionKeyParameterNames.header;
}
if (api.subscriptionKeyParameterNames.query != null)
{
apiTemplateResource.properties.subscriptionKeyParameterNames.query = api.subscriptionKeyParameterNames.query;
}
}
}
if (!isSplit || isInitial)
{
// add open api spec properties for subsequent and unified templates
string format;
string value;
// determine if the open api spec is remote or local, yaml or json
bool isJSON = false;
bool isUrl = IsUri(api, out var _);
string fileContents = null;
if (!isUrl || api.openApiSpecFormat == OpenApiSpecFormat.Unspecified)
{
fileContents = await this.fileReader.RetrieveFileContentsAsync(api.openApiSpec);
}
value = isUrl
? api.openApiSpec
: fileContents
;
bool isVersionThree = false;
if (api.openApiSpecFormat == OpenApiSpecFormat.Unspecified)
{
isJSON = this.fileReader.isJSON(fileContents);
if (isJSON == true)
{
var openAPISpecReader = new OpenAPISpecReader();
isVersionThree = await openAPISpecReader.isJSONOpenAPISpecVersionThreeAsync(api.openApiSpec);
}
format = GetOpenApiSpecFormat(isUrl, isJSON, isVersionThree);
}
else
{
isJSON = IsOpenApiSpecJson(api.openApiSpecFormat);
format = GetOpenApiSpecFormat(isUrl, api.openApiSpecFormat);
}
// if the title needs to be modified
// we need to embed the OpenAPI definition
if (!string.IsNullOrEmpty(api.displayName))
{
format = GetOpenApiSpecFormat(false, isJSON, isVersionThree);
// download definition
if (isUrl)
{
using (var client = new WebClient())
value = client.DownloadString(value);
}
// update title
value = new OpenApi(value, format)
.SetTitle(api.displayName)
.GetDefinition()
;
}
// set the version set id
if (api.apiVersionSetId != null)
{
// point to the supplied version set if the apiVersionSetId is provided
apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/apiVersionSets', parameters('{ParameterNames.ApimServiceName}'), '{api.apiVersionSetId}')]";
}
apiTemplateResource.properties.format = format;
apiTemplateResource.properties.value = value;
apiTemplateResource.properties.path = api.suffix;
if (!String.IsNullOrEmpty(api.serviceUrl))
{
apiTemplateResource.properties.serviceUrl = MakeServiceUrl(api);
}
}
return(apiTemplateResource);
}
public async Task <APITemplateResource> CreateAPITemplateResourceAsync(APIConfig api, bool isSplit, bool isInitial)
{
// create api resource
APITemplateResource apiTemplateResource = new APITemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{api.name}')]",
type = ResourceTypeConstants.API,
apiVersion = GlobalConstants.APIVersion,
properties = new APITemplateProperties(),
dependsOn = new string[] { }
};
// add properties depending on whether the template is the initial, subsequent, or unified
if (!isSplit || isInitial)
{
// add metadata properties for initial and unified templates
apiTemplateResource.properties.apiVersion = api.apiVersion;
apiTemplateResource.properties.serviceUrl = api.serviceUrl;
apiTemplateResource.properties.type = api.type;
apiTemplateResource.properties.apiType = api.type;
apiTemplateResource.properties.description = api.description;
apiTemplateResource.properties.subscriptionRequired = api.subscriptionRequired;
apiTemplateResource.properties.apiRevision = api.apiRevision;
apiTemplateResource.properties.apiRevisionDescription = api.apiRevisionDescription;
apiTemplateResource.properties.apiVersionDescription = api.apiVersionDescription;
apiTemplateResource.properties.authenticationSettings = api.authenticationSettings;
apiTemplateResource.properties.path = api.suffix;
apiTemplateResource.properties.isCurrent = api.isCurrent;
apiTemplateResource.properties.displayName = api.name;
apiTemplateResource.properties.protocols = this.CreateProtocols(api);
// set the version set id
if (api.apiVersionSetId != null)
{
// point to the supplied version set if the apiVersionSetId is provided
apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/apiVersionSets', parameters('ApimServiceName'), '{api.apiVersionSetId}')]";
}
// set the authorization server id
if (api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null &&
apiTemplateResource.properties.authenticationSettings != null && apiTemplateResource.properties.authenticationSettings.oAuth2 != null && apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId != null)
{
apiTemplateResource.properties.authenticationSettings.oAuth2.authorizationServerId = api.authenticationSettings.oAuth2.authorizationServerId;
}
}
if (!isSplit || !isInitial)
{
// add open api spec properties for subsequent and unified templates
string format;
string value;
// determine if the open api spec is remote or local, yaml or json
Uri uriResult;
string fileContents = await this.fileReader.RetrieveFileContentsAsync(api.openApiSpec);
bool isJSON = this.fileReader.isJSON(fileContents);
bool isUrl = Uri.TryCreate(api.openApiSpec, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
if (isUrl == true)
{
value = api.openApiSpec;
if (isJSON == true)
{
// open api spec is remote json file, use swagger-link-json for v2 and openapi-link for v3
OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader();
bool isVersionThree = await openAPISpecReader.isJSONOpenAPISpecVersionThreeAsync(api.openApiSpec);
format = isVersionThree == false ? "swagger-link-json" : "openapi-link";
}
else
{
// open api spec is remote yaml file
format = "openapi-link";
}
}
else
{
value = fileContents;
if (isJSON == true)
{
// open api spec is local json file, use swagger-json for v2 and openapi+json for v3
OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader();
bool isVersionThree = await openAPISpecReader.isJSONOpenAPISpecVersionThreeAsync(api.openApiSpec);
format = isVersionThree == false ? "swagger-json" : "openapi+json";
}
else
{
// open api spec is local yaml file
format = "openapi";
}
}
apiTemplateResource.properties.format = format;
apiTemplateResource.properties.value = value;
apiTemplateResource.properties.path = api.suffix;
}
return(apiTemplateResource);
}
// this function will get the current revision of this api and will remove "isCurrent" paramter
public async Task <List <TemplateResource> > GenerateCurrentRevisionAPIResourceAsync(string apiName, string apimname, string resourceGroup, string fileFolder, string policyXMLBaseUrl, string policyXMLSasToken)
{
List <TemplateResource> templateResources = new List <TemplateResource>();
string apiDetails = await GetAPIDetailsAsync(apimname, resourceGroup, apiName);
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting resources from {0} API:", apiName);
// convert returned api to template resource class
JObject oApiDetails = JObject.Parse(apiDetails);
APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails);
apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString();
apiResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}')]";
apiResource.apiVersion = GlobalConstants.APIVersion;
apiResource.scale = null;
apiResource.properties.isCurrent = null;
if (apiResource.properties.apiVersionSetId != null)
{
apiResource.dependsOn = new string[] { };
string versionSetName = apiResource.properties.apiVersionSetId;
int versionSetPosition = versionSetName.IndexOf("apiVersionSets/");
versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition));
apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('ApimServiceName')), '/{versionSetName}')]";
}
else
{
apiResource.dependsOn = new string[] { };
}
templateResources.Add(apiResource);
#region Schemas
// add schema resources to api template
List <TemplateResource> schemaResources = await GenerateSchemasARMTemplate(apimname, apiName, resourceGroup, fileFolder);
templateResources.AddRange(schemaResources);
#endregion
#region Operations
// pull api operations for service
string[] operationNames = await GetAllOperationNames(apimname, resourceGroup, apiName);
foreach (string operationName in operationNames)
{
string operationDetails = await GetAPIOperationDetailsAsync(apimname, resourceGroup, apiName, operationName);
Console.WriteLine("'{0}' Operation found", operationName);
// convert returned operation to template resource class
OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails);
string operationResourceName = operationResource.name;
operationResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{operationResourceName}')]";
operationResource.apiVersion = GlobalConstants.APIVersion;
operationResource.scale = null;
// add operation dependencies and fix sample value if necessary
List <string> operationDependsOn = new List <string>()
{
$"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]"
};
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationResource.properties.request.representations)
{
AddSchemaDependencyToOperationIfNecessary(apiName, operationDependsOn, operationTemplateRepresentation);
ArmEscapeSampleValueIfNecessary(operationTemplateRepresentation);
}
foreach (OperationsTemplateResponse operationTemplateResponse in operationResource.properties.responses)
{
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationTemplateResponse.representations)
{
AddSchemaDependencyToOperationIfNecessary(apiName, operationDependsOn, operationTemplateRepresentation);
ArmEscapeSampleValueIfNecessary(operationTemplateRepresentation);
}
}
operationResource.dependsOn = operationDependsOn.ToArray();
templateResources.Add(operationResource);
// add operation policy resource to api template
try
{
string operationPolicy = await GetOperationPolicyAsync(apimname, resourceGroup, apiName, operationName);
Console.WriteLine($" - Operation policy found for {operationName} operation");
PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy);
operationPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = GlobalConstants.APIVersion;
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{apiName}', '{operationResourceName}')]" };
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (policyXMLBaseUrl != null)
{
string policyXMLContent = operationPolicyResource.properties.value;
string policyFolder = String.Concat(fileFolder, $@"/policies");
string operationPolicyFileName = $@"/{operationName}-operationPolicy.xml";
this.fileWriter.CreateFolderIfNotExists(policyFolder);
this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, operationPolicyFileName));
operationPolicyResource.properties.format = "rawxml-link";
if (policyXMLSasToken != null)
{
operationPolicyResource.properties.value = $"[concat(parameters('PolicyXMLBaseUrl'), '{operationPolicyFileName}', parameters('PolicyXMLSasToken'))]";
}
else
{
operationPolicyResource.properties.value = $"[concat(parameters('PolicyXMLBaseUrl'), '{operationPolicyFileName}')]";
}
}
templateResources.Add(operationPolicyResource);
}
catch (Exception) { }
// add tags associated with the operation to template
try
{
// pull tags associated with the operation
string apiOperationTags = await GetOperationTagsAsync(apimname, resourceGroup, apiName, operationName);
JObject oApiOperationTags = JObject.Parse(apiOperationTags);
foreach (var tag in oApiOperationTags["value"])
{
string apiOperationTagName = ((JValue)tag["name"]).Value.ToString();
Console.WriteLine(" - '{0}' Tag association found for {1} operation", apiOperationTagName, operationResourceName);
// convert operation tag association to template resource class
TagTemplateResource operationTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString());
operationTagResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{operationResourceName}/{apiOperationTagName}')]";
operationTagResource.apiVersion = GlobalConstants.APIVersion;
operationTagResource.scale = null;
operationTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{apiName}', '{operationResourceName}')]" };
templateResources.Add(operationTagResource);
}
}
catch (Exception) { }
}
#endregion
#region API Policies
// add api policy resource to api template
try
{
string apiPolicies = await GetAPIPolicyAsync(apimname, resourceGroup, apiName);
Console.WriteLine("API policy found");
PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies);
apiPoliciesResource.apiVersion = GlobalConstants.APIVersion;
apiPoliciesResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{apiPoliciesResource.name}')]";
apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (policyXMLBaseUrl != null)
{
string policyXMLContent = apiPoliciesResource.properties.value;
string policyFolder = String.Concat(fileFolder, $@"/policies");
string apiPolicyFileName = $@"/{apiName}-apiPolicy.xml";
this.fileWriter.CreateFolderIfNotExists(policyFolder);
this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, apiPolicyFileName));
apiPoliciesResource.properties.format = "rawxml-link";
if (policyXMLSasToken != null)
{
apiPoliciesResource.properties.value = $"[concat(parameters('PolicyXMLBaseUrl'), '{apiPolicyFileName}', parameters('PolicyXMLSasToken'))]";
}
else
{
apiPoliciesResource.properties.value = $"[concat(parameters('PolicyXMLBaseUrl'), '{apiPolicyFileName}')]";
}
}
templateResources.Add(apiPoliciesResource);
}
catch (Exception) { }
#endregion
// add tags associated with the api to template
try
{
// pull tags associated with the api
string apiTags = await GetAPITagsAsync(apimname, resourceGroup, apiName);
JObject oApiTags = JObject.Parse(apiTags);
foreach (var tag in oApiTags["value"])
{
string apiTagName = ((JValue)tag["name"]).Value.ToString();
Console.WriteLine("'{0}' Tag association found", apiTagName);
// convert associations between api and tags to template resource class
TagTemplateResource apiTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString());
apiTagResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{apiTagName}')]";
apiTagResource.apiVersion = GlobalConstants.APIVersion;
apiTagResource.scale = null;
apiTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
templateResources.Add(apiTagResource);
}
}
catch (Exception) { }
// add product api associations to template
#region API Products
try
{
// pull product api associations
string apiProducts = await GetAPIProductsAsync(apimname, resourceGroup, apiName);
JObject oApiProducts = JObject.Parse(apiProducts);
foreach (var item in oApiProducts["value"])
{
string apiProductName = ((JValue)item["name"]).Value.ToString();
Console.WriteLine("'{0}' Product association found", apiProductName);
// convert returned api product associations to template resource class
ProductAPITemplateResource productAPIResource = JsonConvert.DeserializeObject <ProductAPITemplateResource>(item.ToString());
productAPIResource.type = ResourceTypeConstants.ProductAPI;
productAPIResource.name = $"[concat(parameters('ApimServiceName'), '/{apiProductName}/{apiName}')]";
productAPIResource.apiVersion = GlobalConstants.APIVersion;
productAPIResource.scale = null;
productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
templateResources.Add(productAPIResource);
}
}
catch (Exception) { }
#endregion
#region Diagnostics
// add diagnostics to template
// pull diagnostics for api
string diagnostics = await GetAPIDiagnosticsAsync(apimname, resourceGroup, apiName);
JObject oDiagnostics = JObject.Parse(diagnostics);
foreach (var diagnostic in oDiagnostics["value"])
{
string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString();
Console.WriteLine("'{0}' Diagnostic found", diagnosticName);
// convert returned diagnostic to template resource class
DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>();
diagnosticResource.name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{diagnosticName}')]";
diagnosticResource.type = ResourceTypeConstants.APIDiagnostic;
diagnosticResource.apiVersion = GlobalConstants.APIVersion;
diagnosticResource.scale = null;
diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
if (!diagnosticName.Contains("applicationinsights"))
{
// enableHttpCorrelationHeaders only works for application insights, causes errors otherwise
diagnosticResource.properties.enableHttpCorrelationHeaders = null;
}
templateResources.Add(diagnosticResource);
}
#endregion
return(templateResources);
}
public async void ShouldCreateUnifiedAPITemplateResourceFromCreatorConfig()
{
// arrange
APITemplateCreator apiTemplateCreator = APITemplateCreatorFactory.GenerateAPITemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
apiVersion = "apiVersion",
apiVersionDescription = "apiVersionDescription",
apiVersionSetId = "apiVersionSetId",
apiRevision = "revision",
apiRevisionDescription = "revisionDescription",
suffix = "suffix",
subscriptionRequired = true,
authenticationSettings = new APITemplateAuthenticationSettings()
{
OAuth2 = new APITemplateOAuth2()
{
AuthorizationServerId = "",
Scope = ""
},
Openid = new APITemplateOpenID()
{
OpenIdProviderId = "",
BearerTokenSendingMethods = new string[] { }
},
SubscriptionKeyRequired = true
},
openApiSpec = "https://petstore.swagger.io/v2/swagger.json",
protocols = "https",
isCurrent = true,
type = "http"
};
creatorConfig.apis.Add(api);
// act
APITemplateResource apiTemplateResource = await apiTemplateCreator.CreateAPITemplateResourceAsync(api, false, true);
// assert
Assert.Equal($"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{api.name}')]", apiTemplateResource.Name);
Assert.Equal(api.name, apiTemplateResource.Properties.DisplayName);
Assert.Equal(api.apiVersion, apiTemplateResource.Properties.ApiVersion);
Assert.Equal(api.type, apiTemplateResource.Properties.Type);
Assert.Equal(api.type, apiTemplateResource.Properties.ApiType);
Assert.Equal(api.isCurrent, apiTemplateResource.Properties.IsCurrent);
Assert.Equal(new string[] { api.protocols }, apiTemplateResource.Properties.Protocols);
Assert.Equal(api.apiVersionDescription, apiTemplateResource.Properties.ApiVersionDescription);
Assert.Equal($"[resourceId('Microsoft.ApiManagement/service/apiVersionSets', parameters('{ParameterNames.ApimServiceName}'), '{api.apiVersionSetId}')]", apiTemplateResource.Properties.ApiVersionSetId);
Assert.Equal(api.apiRevision, apiTemplateResource.Properties.ApiRevision);
Assert.Equal(api.apiRevisionDescription, apiTemplateResource.Properties.ApiRevisionDescription);
Assert.Equal(api.suffix, apiTemplateResource.Properties.Path);
Assert.Equal(api.subscriptionRequired, apiTemplateResource.Properties.SubscriptionRequired);
Assert.Equal(api.authenticationSettings.OAuth2.AuthorizationServerId, apiTemplateResource.Properties.AuthenticationSettings.OAuth2.AuthorizationServerId);
Assert.Equal(api.authenticationSettings.OAuth2.Scope, apiTemplateResource.Properties.AuthenticationSettings.OAuth2.Scope);
Assert.Equal(api.authenticationSettings.Openid.OpenIdProviderId, apiTemplateResource.Properties.AuthenticationSettings.Openid.OpenIdProviderId);
Assert.Equal(api.authenticationSettings.Openid.BearerTokenSendingMethods, apiTemplateResource.Properties.AuthenticationSettings.Openid.BearerTokenSendingMethods);
Assert.Equal(api.authenticationSettings.SubscriptionKeyRequired, apiTemplateResource.Properties.AuthenticationSettings.SubscriptionKeyRequired);
Assert.Equal("swagger-link-json", apiTemplateResource.Properties.Format);
Assert.Equal(api.openApiSpec, apiTemplateResource.Properties.Value);
}
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();
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 CreateCommand()
{
this.Name = GlobalConstants.CreateName;
this.Description = GlobalConstants.CreateDescription;
CommandOption appInsightsInstrumentationKey = this.Option("--appInsightsInstrumentationKey <appInsightsInstrumentationKey>", "AppInsights intrumentationkey", CommandOptionType.SingleValue);
CommandOption appInsightsName = this.Option("--appInsightsName <appInsightsName>", "AppInsights Name", CommandOptionType.SingleValue);
// Allow Named values to pass as parameters
CommandOption namedValueKeys = this.Option("--namedValues <namedValues>", "Named Values", CommandOptionType.SingleValue);
// apimNameValue values to pass as parameters
CommandOption apimNameValue = this.Option("--apimNameValue <apimNameValue>", "Apim Name Value", CommandOptionType.SingleValue);
// list command options
CommandOption configFile = this.Option("--configFile <configFile>", "Config YAML file location", CommandOptionType.SingleValue).IsRequired();
// list command options
CommandOption backendurlconfigFile = this.Option("--backendurlconfigFile <backendurlconfigFile>", "backend url json file location", CommandOptionType.SingleValue);
// command options
CommandOption preferredAPIsForDeployment = this.Option("--preferredAPIsForDeployment <preferredAPIsForDeployment>", "create ARM templates for the given APIs Name(comma separated) else leave this parameter blank then by default all api's will be considered", CommandOptionType.SingleValue);
this.HelpOption();
this.OnExecute(async() =>
{
// convert config file to CreatorConfig class
FileReader fileReader = new FileReader();
bool considerAllApiForDeployments = true;
string[] preferredApis = null;
GlobalConstants.CommandStartDateTime = DateTime.Now.ToString("MMyyyydd hh mm ss");
CreatorConfig creatorConfig = await fileReader.ConvertConfigYAMLToCreatorConfigAsync(configFile.Value());
if (apimNameValue != null && !string.IsNullOrEmpty(apimNameValue.Value()))
{
creatorConfig.apimServiceName = apimNameValue.Value();
}
AppInsightsUpdater appInsightsUpdater = new AppInsightsUpdater();
appInsightsUpdater.UpdateAppInsightNameAndInstrumentationKey(creatorConfig, appInsightsInstrumentationKey, appInsightsName);
// Overwrite named values from build pipeline
NamedValuesUpdater namedValuesUpdater = new NamedValuesUpdater();
namedValuesUpdater.UpdateNamedValueInstances(creatorConfig, namedValueKeys);
// validate creator config
CreatorConfigurationValidator creatorConfigurationValidator = new CreatorConfigurationValidator(this);
//if preferredAPIsForDeployment passed as parameter
if (preferredAPIsForDeployment != null && !string.IsNullOrEmpty(preferredAPIsForDeployment.Value()))
{
considerAllApiForDeployments = false;
preferredApis = preferredAPIsForDeployment.Value().Split(",");
}
//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();
SubscriptionTemplateCreator productSubscriptionsTemplateCreator = new SubscriptionTemplateCreator();
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
ReleaseTemplateCreator releaseTemplateCreator = new ReleaseTemplateCreator();
ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator(policyTemplateCreator, productGroupTemplateCreator, productSubscriptionsTemplateCreator);
PropertyTemplateCreator propertyTemplateCreator = new PropertyTemplateCreator();
TagTemplateCreator tagTemplateCreator = new TagTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, policyTemplateCreator, 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 product/APIs template");
Console.WriteLine("------------------------------------------");
Template productAPIsTemplate = (creatorConfig.products != null && creatorConfig.apis != null) ? productAPITemplateCreator.CreateProductAPITemplate(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)
{
if (considerAllApiForDeployments || preferredApis.Contains(api.name))
{
// 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, productAPIsTemplate, 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 (productAPIsTemplate != null)
{
fileWriter.WriteJSONToFile(productAPIsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.productAPIs));
}
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);
});
}
