public Template CreateLinkedMasterTemplate(Template apiVersionSetTemplate,
Template initialAPITemplate,
Template subsequentAPITemplate,
CreatorFileNames creatorFileNames)
{
// create empty template
Template masterTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters
masterTemplate.parameters = this.CreateMasterTemplateParameters(true);
// add links to all resources
List <TemplateResource> resources = new List <TemplateResource>();
// apiVersionSet
if (apiVersionSetTemplate != null)
{
string apiVersionSetUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.apiVersionSet}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("versionSetTemplate", apiVersionSetUri, new string[] { }));
}
//api
string initialAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.initialAPI}')]";
string[] initialAPIDependsOn = apiVersionSetTemplate != null ? new string[] { "[resourceId('Microsoft.Resources/deployments', 'versionSetTemplate')]" } : new string[] { };
resources.Add(this.CreateLinkedMasterTemplateResource("initialAPITemplate", initialAPIUri, initialAPIDependsOn));
string subsequentAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.subsequentAPI}')]";
string[] subsequentAPIDependsOn = apiVersionSetTemplate != null ? new string[] { "[resourceId('Microsoft.Resources/deployments', 'initialAPITemplate')]" } : new string[] { };
resources.Add(this.CreateLinkedMasterTemplateResource("subsequentAPITemplate", subsequentAPIUri, subsequentAPIDependsOn));
masterTemplate.resources = resources.ToArray();
return(masterTemplate);
}
public Template CreateLinkedMasterTemplate(Template apiVersionSetTemplate,
Template productsTemplate,
Template loggersTemplate,
List <LinkedMasterTemplateAPIInformation> apiInformation,
CreatorFileNames creatorFileNames,
FileNameGenerator fileNameGenerator)
{
// create empty template
Template masterTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters
masterTemplate.parameters = this.CreateMasterTemplateParameters(true);
// add links to all resources
List <TemplateResource> resources = new List <TemplateResource>();
// apiVersionSet
if (apiVersionSetTemplate != null)
{
string apiVersionSetUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.apiVersionSets}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("versionSetTemplate", apiVersionSetUri, new string[] { }));
}
// product
if (productsTemplate != null)
{
string productsUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.products}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("productsTemplate", productsUri, new string[] { }));
}
// logger
if (loggersTemplate != null)
{
string loggersUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.loggers}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("loggersTemplate", loggersUri, new string[] { }));
}
// api info stores api name as the key and whether the api depends on the version set template as the value
foreach (LinkedMasterTemplateAPIInformation apiInfo in apiInformation)
{
string initialAPIDeploymentResourceName = $"{apiInfo.name}-InitialAPITemplate";
string subsequentAPIDeploymentResourceName = $"{apiInfo.name}-SubsequentAPITemplate";
string initialAPIFileName = fileNameGenerator.GenerateAPIFileName(apiInfo.name, true);
string initialAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{initialAPIFileName}')]";
List <string> initialAPIDependsOn = new List <string>();
if (apiVersionSetTemplate != null && apiInfo.dependsOnVersionSets == true)
{
initialAPIDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'versionSetTemplate')]");
}
if (productsTemplate != null && apiInfo.dependsOnProducts == true)
{
initialAPIDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'productsTemplate')]");
}
if (loggersTemplate != null && apiInfo.dependsOnLoggers == true)
{
initialAPIDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'loggersTemplate')]");
}
resources.Add(this.CreateLinkedMasterTemplateResource(initialAPIDeploymentResourceName, initialAPIUri, initialAPIDependsOn.ToArray()));
string subsequentAPIFileName = fileNameGenerator.GenerateAPIFileName(apiInfo.name, false);
string subsequentAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{subsequentAPIFileName}')]";
string[] subsequentAPIDependsOn = new string[] { $"[resourceId('Microsoft.Resources/deployments', '{initialAPIDeploymentResourceName}')]" };
resources.Add(this.CreateLinkedMasterTemplateResource(subsequentAPIDeploymentResourceName, subsequentAPIUri, subsequentAPIDependsOn));
}
masterTemplate.resources = resources.ToArray();
return(masterTemplate);
}
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
bool isValidCreatorConfig = ValidateCreatorConfig(creatorConfig);
if (isValidCreatorConfig == true)
{
// required parameters have been supplied
// initialize helper classes
FileWriter fileWriter = new FileWriter();
FileNameGenerator fileNameGenerator = new FileNameGenerator();
TemplateCreator templateCreator = new TemplateCreator();
APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator(templateCreator);
LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator(templateCreator);
ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator(templateCreator);
ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator();
PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader);
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, templateCreator, policyTemplateCreator, productAPITemplateCreator, diagnosticTemplateCreator);
MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator(templateCreator);
CreatorFileNames creatorFileNames = fileNameGenerator.GenerateCreatorLinkedFileNames(creatorConfig);
// create templates from provided configuration
Template apiVersionSetsTemplate = creatorConfig.apiVersionSets != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null;
Template productsTemplate = creatorConfig.products != null ? productTemplateCreator.CreateProductTemplate(creatorConfig) : null;
Template loggersTemplate = creatorConfig.loggers != null ? loggerTemplateCreator.CreateLoggerTemplate(creatorConfig) : null;
// store name and full template on each api necessary to build unlinked templates
Dictionary <string, Template> initialAPITemplates = new Dictionary <string, Template>();
Dictionary <string, Template> subsequentAPITemplates = new Dictionary <string, Template>();
// 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>();
// create parameters file
Template masterTemplateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig);
foreach (APIConfig api in creatorConfig.apis)
{
Template initialAPITemplate = await apiTemplateCreator.CreateInitialAPITemplateAsync(creatorConfig, api);
Template subsequentAPITemplate = apiTemplateCreator.CreateSubsequentAPITemplate(api);
initialAPITemplates.Add(api.name, initialAPITemplate);
subsequentAPITemplates.Add(api.name, subsequentAPITemplate);
apiInformation.Add(new LinkedMasterTemplateAPIInformation()
{
name = api.name,
dependsOnVersionSets = api.apiVersionSetId != null,
dependsOnProducts = api.products != null,
dependsOnLoggers = masterTemplateCreator.DetermineIfAPIDependsOnLogger(api, fileReader)
});
}
// write templates to outputLocation
if (creatorConfig.linked == true)
{
// create linked master template
Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(apiVersionSetsTemplate, productsTemplate, loggersTemplate, apiInformation, creatorFileNames, fileNameGenerator);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.linkedMaster));
}
foreach (KeyValuePair <string, Template> initialAPITemplatePair in initialAPITemplates)
{
string initialAPIFileName = fileNameGenerator.GenerateAPIFileName(initialAPITemplatePair.Key, true);
fileWriter.WriteJSONToFile(initialAPITemplatePair.Value, String.Concat(creatorConfig.outputLocation, initialAPIFileName));
}
foreach (KeyValuePair <string, Template> subsequentAPITemplatePair in subsequentAPITemplates)
{
string subsequentAPIFileName = fileNameGenerator.GenerateAPIFileName(subsequentAPITemplatePair.Key, false);
fileWriter.WriteJSONToFile(subsequentAPITemplatePair.Value, String.Concat(creatorConfig.outputLocation, subsequentAPIFileName));
}
if (apiVersionSetsTemplate != null)
{
fileWriter.WriteJSONToFile(apiVersionSetsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.apiVersionSets));
}
if (productsTemplate != null)
{
fileWriter.WriteJSONToFile(productsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.products));
}
if (loggersTemplate != null)
{
fileWriter.WriteJSONToFile(loggersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.loggers));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(masterTemplateParameters, String.Concat(creatorConfig.outputLocation, creatorConfig.linked == true ? creatorFileNames.linkedParameters : creatorFileNames.unlinkedParameters));
ColoredConsole.WriteLine("Templates written to output location");
}
return(0);
});
}
public CreateCommand()
{
this.Name = Constants.CreateName;
this.Description = Constants.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
bool isValidCreatorConfig = ValidateCreatorConfig(creatorConfig);
if (isValidCreatorConfig == true)
{
// required parameters have been supplied
// initialize helper classes
FileWriter fileWriter = new FileWriter();
TemplateCreator templateCreator = new TemplateCreator();
APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator(templateCreator);
ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator();
PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader);
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, templateCreator, policyTemplateCreator, productAPITemplateCreator, diagnosticTemplateCreator);
MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator(templateCreator);
// create templates from provided configuration
Template apiVersionSetTemplate = creatorConfig.apiVersionSet != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null;
Template initialAPITemplate = await apiTemplateCreator.CreateInitialAPITemplateAsync(creatorConfig);
Template subsequentAPITemplate = apiTemplateCreator.CreateSubsequentAPITemplate(creatorConfig);
if (creatorConfig.linked == true)
{
CreatorFileNames creatorFileNames = fileWriter.GenerateCreatorLinkedFileNames();
// create linked master template
Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(apiVersionSetTemplate, initialAPITemplate, subsequentAPITemplate, creatorFileNames);
Template masterTemplateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig);
// write templates to outputLocation
if (apiVersionSetTemplate != null)
{
fileWriter.WriteJSONToFile(apiVersionSetTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.apiVersionSet));
}
fileWriter.WriteJSONToFile(initialAPITemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.initialAPI));
fileWriter.WriteJSONToFile(subsequentAPITemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.subsequentAPI));
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, "/master.template.json"));
fileWriter.WriteJSONToFile(masterTemplateParameters, String.Concat(creatorConfig.outputLocation, "/master.parameters.json"));
}
else
{
// create unlinked master template
Template initialMasterTemplate = masterTemplateCreator.CreateInitialUnlinkedMasterTemplate(apiVersionSetTemplate, initialAPITemplate);
Template subsequentMasterTemplate = masterTemplateCreator.CreateSubsequentUnlinkedMasterTemplate(subsequentAPITemplate);
Template masterTemplateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig);
// write templates to outputLocation
fileWriter.WriteJSONToFile(initialMasterTemplate, String.Concat(creatorConfig.outputLocation, "/master1.template.json"));
fileWriter.WriteJSONToFile(subsequentMasterTemplate, String.Concat(creatorConfig.outputLocation, "/master2.template.json"));
fileWriter.WriteJSONToFile(masterTemplateParameters, String.Concat(creatorConfig.outputLocation, "/master.parameters.json"));
}
ColoredConsole.WriteLine("Templates written to output location");
}
return(0);
});
}
public Template CreateLinkedMasterTemplate(Template apiVersionSetTemplate,
Template productsTemplate,
Template loggersTemplate,
Template backendsTemplate,
Template authorizationServersTemplate,
List <LinkedMasterTemplateAPIInformation> apiInformation,
CreatorFileNames creatorFileNames,
FileNameGenerator fileNameGenerator)
{
// create empty template
Template masterTemplate = CreateEmptyTemplate();
// add parameters
masterTemplate.parameters = this.CreateMasterTemplateParameters(true);
// add deployment resources that links to all resource files
List <TemplateResource> resources = new List <TemplateResource>();
// apiVersionSet
if (apiVersionSetTemplate != null)
{
string apiVersionSetUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.apiVersionSets}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("versionSetTemplate", apiVersionSetUri, new string[] { }));
}
// product
if (productsTemplate != null)
{
string productsUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.products}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("productsTemplate", productsUri, new string[] { }));
}
// logger
if (loggersTemplate != null)
{
string loggersUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.loggers}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("loggersTemplate", loggersUri, new string[] { }));
}
// backend
if (backendsTemplate != null)
{
string backendsUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.backends}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("backendsTemplate", backendsUri, new string[] { }));
}
// authorizationServer
if (authorizationServersTemplate != null)
{
string authorizationServersUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{creatorFileNames.authorizationServers}')]";
resources.Add(this.CreateLinkedMasterTemplateResource("authorizationServersTemplate", authorizationServersUri, new string[] { }));
}
// each api has an associated api info class that determines whether the api is split and its dependencies on other resources
foreach (LinkedMasterTemplateAPIInformation apiInfo in apiInformation)
{
if (apiInfo.isSplit == true)
{
// add a deployment resource for both api template files
string initialAPIDeploymentResourceName = $"{apiInfo.name}-InitialAPITemplate";
string subsequentAPIDeploymentResourceName = $"{apiInfo.name}-SubsequentAPITemplate";
string initialAPIFileName = fileNameGenerator.GenerateAPIFileName(apiInfo.name, apiInfo.isSplit, true);
string initialAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{initialAPIFileName}')]";
string[] initialAPIDependsOn = CreateAPIResourceDependencies(apiVersionSetTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, apiInfo);
resources.Add(this.CreateLinkedMasterTemplateResource(initialAPIDeploymentResourceName, initialAPIUri, initialAPIDependsOn));
string subsequentAPIFileName = fileNameGenerator.GenerateAPIFileName(apiInfo.name, apiInfo.isSplit, false);
string subsequentAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{subsequentAPIFileName}')]";
string[] subsequentAPIDependsOn = new string[] { $"[resourceId('Microsoft.Resources/deployments', '{initialAPIDeploymentResourceName}')]" };
resources.Add(this.CreateLinkedMasterTemplateResource(subsequentAPIDeploymentResourceName, subsequentAPIUri, subsequentAPIDependsOn));
}
else
{
// add a deployment resource for the unified api template file
string unifiedAPIDeploymentResourceName = $"{apiInfo.name}-APITemplate";
string unifiedAPIFileName = fileNameGenerator.GenerateAPIFileName(apiInfo.name, apiInfo.isSplit, true);
string unifiedAPIUri = $"[concat(parameters('LinkedTemplatesBaseUrl'), '{unifiedAPIFileName}')]";
string[] unifiedAPIDependsOn = CreateAPIResourceDependencies(apiVersionSetTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, apiInfo);
resources.Add(this.CreateLinkedMasterTemplateResource(unifiedAPIDeploymentResourceName, unifiedAPIUri, unifiedAPIDependsOn));
}
}
masterTemplate.resources = resources.ToArray();
return(masterTemplate);
}
public CreateCommand()
{
this.Name = GlobalConstants.CreateName;
this.Description = GlobalConstants.CreateDescription;
// list command options
CommandOption configFile = this.Option("--configFile <configFile>", "Config YAML file location", CommandOptionType.SingleValue).IsRequired();
this.HelpOption();
this.OnExecute(async() =>
{
// convert config file to CreatorConfig class
FileReader fileReader = new FileReader();
CreatorConfig creatorConfig = await fileReader.ConvertConfigYAMLToCreatorConfigAsync(configFile.Value());
// validate creator config
CreatorConfigurationValidator creatorConfigurationValidator = new CreatorConfigurationValidator(this);
bool isValidCreatorConfig = creatorConfigurationValidator.ValidateCreatorConfig(creatorConfig);
if (isValidCreatorConfig == true)
{
// required parameters have been supplied
// initialize file helper classes
FileWriter fileWriter = new FileWriter();
FileNameGenerator fileNameGenerator = new FileNameGenerator();
CreatorFileNames creatorFileNames = fileNameGenerator.GenerateCreatorLinkedFileNames();
// initialize template creator classes
APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator();
LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator();
ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator();
BackendTemplateCreator backendTemplateCreator = new BackendTemplateCreator();
AuthorizationServerTemplateCreator authorizationServerTemplateCreator = new AuthorizationServerTemplateCreator();
ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator();
PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader);
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, policyTemplateCreator, productAPITemplateCreator, diagnosticTemplateCreator);
MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator();
// create templates from provided configuration
Console.WriteLine("Creating API version set template");
Console.WriteLine("------------------------------------------");
Template apiVersionSetsTemplate = creatorConfig.apiVersionSets != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null;
Console.WriteLine("Creating product template");
Console.WriteLine("------------------------------------------");
Template productsTemplate = creatorConfig.products != null ? productTemplateCreator.CreateProductTemplate(creatorConfig) : null;
Console.WriteLine("Creating logger template");
Console.WriteLine("------------------------------------------");
Template loggersTemplate = creatorConfig.loggers != null ? loggerTemplateCreator.CreateLoggerTemplate(creatorConfig) : null;
Console.WriteLine("Creating backend template");
Console.WriteLine("------------------------------------------");
Template backendsTemplate = creatorConfig.backends != null ? backendTemplateCreator.CreateBackendTemplate(creatorConfig) : null;
Console.WriteLine("Creating authorization server template");
Console.WriteLine("------------------------------------------");
Template authorizationServersTemplate = creatorConfig.authorizationServers != null ? authorizationServerTemplateCreator.CreateAuthorizationServerTemplate(creatorConfig) : null;
// store name and whether the api will depend on the version set template each api necessary to build linked templates
List <LinkedMasterTemplateAPIInformation> apiInformation = new List <LinkedMasterTemplateAPIInformation>();
List <Template> apiTemplates = new List <Template>();
Console.WriteLine("Creating API templates");
Console.WriteLine("------------------------------------------");
foreach (APIConfig api in creatorConfig.apis)
{
// create api templates from provided api config - if the api config contains a supplied apiVersion, split the templates into 2 for metadata and swagger content, otherwise create a unified template
List <Template> apiTemplateSet = await apiTemplateCreator.CreateAPITemplatesAsync(creatorConfig, api);
apiTemplates.AddRange(apiTemplateSet);
// create the relevant info that will be needed to properly link to the api template(s) from the master template
apiInformation.Add(new LinkedMasterTemplateAPIInformation()
{
name = api.name,
isSplit = apiTemplateCreator.isSplitAPI(api),
dependsOnVersionSets = api.apiVersionSetId != null,
dependsOnProducts = api.products != null,
dependsOnLoggers = await masterTemplateCreator.DetermineIfAPIDependsOnLogger(api, fileReader),
dependsOnAuthorizationServers = api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null,
dependsOnBackends = await masterTemplateCreator.DetermineIfAPIDependsOnBackend(api, fileReader)
});
}
// create parameters file
Template masterTemplateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig);
// write templates to outputLocation
if (creatorConfig.linked == true)
{
// create linked master template
Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(apiVersionSetsTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, apiInformation, creatorFileNames, fileNameGenerator);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.linkedMaster));
}
foreach (Template apiTemplate in apiTemplates)
{
APITemplateResource apiResource = apiTemplate.resources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as APITemplateResource;
APIConfig providedAPIConfiguration = creatorConfig.apis.FirstOrDefault(api => apiResource.name.Contains(api.name));
// if the api version is not null the api is split into multiple templates. If the template is split and the content value has been set, then the template is for a subsequent api
string apiFileName = fileNameGenerator.GenerateAPIFileName(providedAPIConfiguration.name, apiTemplateCreator.isSplitAPI(providedAPIConfiguration), apiResource.properties.value == null);
fileWriter.WriteJSONToFile(apiTemplate, String.Concat(creatorConfig.outputLocation, apiFileName));
}
if (apiVersionSetsTemplate != null)
{
fileWriter.WriteJSONToFile(apiVersionSetsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.apiVersionSets));
}
if (productsTemplate != null)
{
fileWriter.WriteJSONToFile(productsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.products));
}
if (loggersTemplate != null)
{
fileWriter.WriteJSONToFile(loggersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.loggers));
}
if (backendsTemplate != null)
{
fileWriter.WriteJSONToFile(backendsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.backends));
}
if (authorizationServersTemplate != null)
{
fileWriter.WriteJSONToFile(authorizationServersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.authorizationServers));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(masterTemplateParameters, String.Concat(creatorConfig.outputLocation, creatorConfig.linked == true ? creatorFileNames.linkedParameters : creatorFileNames.unlinkedParameters));
Console.WriteLine("Templates written to output location");
Console.WriteLine("Press any key to exit process:");
#if DEBUG
Console.ReadKey();
#endif
}
return(0);
});
}