public Template CreateProductTemplate(CreatorConfig creatorConfig)
{
// create empty template
Template productTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters
productTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
foreach (ProductsTemplateProperties productTemplateProperties in creatorConfig.products)
{
// create product resource with properties
ProductsTemplateResource productsTemplateResource = new ProductsTemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{productTemplateProperties.displayName}')]",
type = ResourceTypeConstants.Product,
apiVersion = "2018-06-01-preview",
properties = productTemplateProperties,
dependsOn = new string[] { }
};
resources.Add(productsTemplateResource);
}
productTemplate.resources = resources.ToArray();
return(productTemplate);
}
public async Task <Template> Create(DeploymentDefinition creatorConfig)
{
var template = EmptyTemplate;
template.Parameters.Add(ApiServiceNameParameter.Key, ApiServiceNameParameter.Value);
var resources = new List <TemplateResource>();
foreach (var product in creatorConfig.Products)
{
// create product resource with properties
var productsTemplateResource = new ProductsTemplateResource()
{
Name = $"[concat(parameters('ApimServiceName'), '/{product.Name}')]",
Properties = new ProductsProperties()
{
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);
resources.AddRange(await CreateChildResourceTemplates(product));
}
template.Resources = resources.ToArray();
return(await Task.FromResult(template));
}
public void ShouldCreateProductFromCreatorConfig()
{
// arrange
ProductTemplateCreator productTemplateCreator = ProductTemplateCreatorFactory.GenerateProductTemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
products = new List <ProductConfig>()
};
ProductConfig product = new ProductConfig()
{
displayName = "displayName",
description = "description",
terms = "terms",
subscriptionRequired = true,
approvalRequired = true,
subscriptionsLimit = 1,
state = "state"
};
creatorConfig.products.Add(product);
// act
Template productTemplate = productTemplateCreator.CreateProductTemplate(creatorConfig);
ProductsTemplateResource productsTemplateResource = (ProductsTemplateResource)productTemplate.resources[0];
// assert
Assert.Equal($"[concat(parameters('ApimServiceName'), '/{product.displayName}')]", productsTemplateResource.name);
Assert.Equal(product.displayName, productsTemplateResource.properties.displayName);
Assert.Equal(product.description, productsTemplateResource.properties.description);
Assert.Equal(product.terms, productsTemplateResource.properties.terms);
Assert.Equal(product.subscriptionsLimit, productsTemplateResource.properties.subscriptionsLimit);
Assert.Equal(product.subscriptionRequired, productsTemplateResource.properties.subscriptionRequired);
Assert.Equal(product.approvalRequired, productsTemplateResource.properties.approvalRequired);
Assert.Equal(product.state, productsTemplateResource.properties.state);
}
public void ShouldNotCreateApprovalRequiredOrSubscriptionsLimitIfSubscriptionRequiredIsFalse()
{
// arrange
ProductTemplateCreator productTemplateCreator = ProductTemplateCreatorFactory.GenerateProductTemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
products = new List <ProductConfig>()
};
ProductConfig product = new ProductConfig()
{
DisplayName = "displayName",
Description = "description",
Terms = "terms",
SubscriptionRequired = false,
ApprovalRequired = true,
SubscriptionsLimit = 1,
State = "state"
};
creatorConfig.products.Add(product);
// act
var productTemplate = productTemplateCreator.CreateProductTemplate(creatorConfig);
ProductsTemplateResource productsTemplateResource = (ProductsTemplateResource)productTemplate.Resources[0];
// assert
Assert.Equal($"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.Name}')]", productsTemplateResource.Name);
Assert.Equal(product.DisplayName, productsTemplateResource.Properties.DisplayName);
Assert.Equal(product.Description, productsTemplateResource.Properties.Description);
Assert.Equal(product.Terms, productsTemplateResource.Properties.Terms);
Assert.Equal(product.SubscriptionRequired, productsTemplateResource.Properties.SubscriptionRequired);
Assert.Null(productsTemplateResource.Properties.SubscriptionsLimit);
Assert.Null(productsTemplateResource.Properties.ApprovalRequired);
Assert.Equal(product.State, productsTemplateResource.Properties.State);
}
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)
{
// create product resource with properties
ProductsTemplateResource productsTemplateResource = new ProductsTemplateResource()
{
name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.displayName}')]",
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.displayName}')]" };
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.displayName}')]" };
List <ProductGroupsValue> productGroups = this.productGroupTemplateCreator.CreateProductGroupTemplateResources(product, dependsOn);
resources.AddRange(productGroups);
}
}
productTemplate.resources = resources.ToArray();
return(productTemplate);
}
private void GenerateProductsARMTemplate(string apimname, string resourceGroup, string fileFolder, string singleApiName, List <TemplateResource> armTemplateResources)
{
APIExtractor apiExtractor = new APIExtractor();
Template armTemplate = GenerateEmptyTemplateWithParameters();
// isolate product api associations in the case of a single api extraction
var productAPIResources = armTemplateResources.Where(resource => resource.type == ResourceTypeConstants.ProductAPI);
List <TemplateResource> templateResources = new List <TemplateResource>();
string products = apiExtractor.GetProducts(apimname, resourceGroup).Result;
JObject oProducts = JObject.Parse(products);
foreach (var item in oProducts["value"])
{
string productName = ((JValue)item["name"]).Value.ToString();
Console.WriteLine("'{0}' Product found", productName);
string productDetails = apiExtractor.GetProductDetails(apimname, resourceGroup, productName).Result;
var settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
ProductsTemplateResource productsTemplateResource = JsonConvert.DeserializeObject <ProductsTemplateResource>(productDetails, settings);
productsTemplateResource.name = $"[concat(parameters('ApimServiceName'), '/{productName}')]";
productsTemplateResource.apiVersion = "2018-06-01-preview";
// only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api
if (singleApiName == null || productAPIResources.SingleOrDefault(p => p.name.Contains(productName)) != null)
{
templateResources.Add(productsTemplateResource);
}
}
armTemplate.resources = templateResources.ToArray();
FileWriter fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-products.json");
}
public async Task <Template> GenerateProductsARMTemplate(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting products from service");
Template armTemplate = GenerateEmptyTemplateWithParameters();
// isolate product api associations in the case of a single api extraction
var productAPIResources = apiTemplateResources.Where(resource => resource.type == ResourceTypeConstants.ProductAPI);
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull all products for service
string products = await GetProducts(apimname, resourceGroup);
JObject oProducts = JObject.Parse(products);
foreach (var item in oProducts["value"])
{
string productName = ((JValue)item["name"]).Value.ToString();
string productDetails = await GetProductDetails(apimname, resourceGroup, productName);
// convert returned product to template resource class
JsonSerializerSettings settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
ProductsTemplateResource productsTemplateResource = JsonConvert.DeserializeObject <ProductsTemplateResource>(productDetails, settings);
productsTemplateResource.name = $"[concat(parameters('ApimServiceName'), '/{productName}')]";
productsTemplateResource.apiVersion = GlobalConstants.APIVersion;
// only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api
if (singleApiName == null || productAPIResources.SingleOrDefault(p => p.name.Contains(productName)) != null)
{
Console.WriteLine("'{0}' Product found", productName);
templateResources.Add(productsTemplateResource);
}
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
public async Task <Template> GenerateProductsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, string policyXMLBaseUrl, string fileFolder)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting products from service");
Template armTemplate = GenerateEmptyTemplateWithParameters(policyXMLBaseUrl);
// isolate product api associations in the case of a single api extraction
var productAPIResources = apiTemplateResources.Where(resource => resource.type == ResourceTypeConstants.ProductAPI);
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull all products for service
string products = await GetProductsAsync(apimname, resourceGroup);
JObject oProducts = JObject.Parse(products);
foreach (var item in oProducts["value"])
{
string productName = ((JValue)item["name"]).Value.ToString();
string productDetails = await GetProductDetailsAsync(apimname, resourceGroup, productName);
// convert returned product to template resource class
JsonSerializerSettings settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore
};
ProductsTemplateResource productsTemplateResource = JsonConvert.DeserializeObject <ProductsTemplateResource>(productDetails, settings);
productsTemplateResource.name = $"[concat(parameters('ApimServiceName'), '/{productName}')]";
productsTemplateResource.apiVersion = GlobalConstants.APIVersion;
// only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api
if (singleApiName == null || productAPIResources.SingleOrDefault(p => p.name.Contains(productName)) != null)
{
Console.WriteLine("'{0}' Product found", productName);
templateResources.Add(productsTemplateResource);
// add product policy resource to template
try
{
string productPolicy = await GetProductPolicyAsync(apimname, resourceGroup, productName);
Console.WriteLine($" - Product policy found for {productName} product");
PolicyTemplateResource productPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(productPolicy);
productPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{productName}/policy')]";
productPolicyResource.apiVersion = GlobalConstants.APIVersion;
productPolicyResource.scale = null;
productPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('ApimServiceName'), '{productName}')]" };
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (policyXMLBaseUrl != null)
{
string policyXMLContent = productPolicyResource.properties.value;
string policyFolder = String.Concat(fileFolder, $@"/policies");
string productPolicyFileName = $@"/{productName}-productPolicy.xml";
this.fileWriter.CreateFolderIfNotExists(policyFolder);
this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, productPolicyFileName));
productPolicyResource.properties.format = "rawxml-link";
productPolicyResource.properties.value = $"[concat(parameters('PolicyXMLBaseUrl'), '{productPolicyFileName}')]";
}
templateResources.Add(productPolicyResource);
}
catch (Exception) { }
}
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
public Template CreateProductTemplate(CreatorConfig creatorConfig)
{
// create empty template
Template productTemplate = this.templateBuilder.GenerateEmptyTemplate().Build();
// 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 ProductsProperties()
{
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 <GroupTemplateResource> productGroups = this.productGroupTemplateCreator.CreateProductGroupTemplateResources(product, dependsOn);
resources.AddRange(productGroups);
}
// create product subscriptions if provided
if (product.subscriptions != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.Name}')]" };
List <SubscriptionsTemplateResource> subscriptions = this.subscriptionTemplateCreator.CreateSubscriptionsTemplateResources(product, dependsOn);
resources.AddRange(subscriptions);
}
}
productTemplate.Resources = resources.ToArray();
return(productTemplate);
}
