private static void AddPredefinedActions(GenInfo genInfo, TemplateCreationResult genResult, List <PostAction> postActions)
{
switch (genInfo.Template.GetTemplateType())
{
case TemplateType.Project:
postActions.Add(new AddProjectToSolutionPostAction(genResult.ResultInfo.PrimaryOutputs));
postActions.Add(new GenerateTestCertificatePostAction(genInfo.GetUserName()));
break;
case TemplateType.Page:
postActions.Add(new AddItemToProjectPostAction(genResult.ResultInfo.PrimaryOutputs));
break;
case TemplateType.Feature:
postActions.Add(new AddItemToProjectPostAction(genResult.ResultInfo.PrimaryOutputs));
break;
case TemplateType.Composition:
postActions.Add(new AddItemToProjectPostAction(genResult.ResultInfo.PrimaryOutputs));
break;
default:
break;
}
}
private void HandlePostActions(TemplateCreationResult creationResult)
{
if (creationResult.Status != CreationResultStatus.Success)
{
return;
}
AllowPostActionsSetting scriptRunSettings;
if (string.IsNullOrEmpty(_commandInput.AllowScriptsToRun) || string.Equals(_commandInput.AllowScriptsToRun, "prompt", StringComparison.OrdinalIgnoreCase))
{
scriptRunSettings = AllowPostActionsSetting.Prompt;
}
else if (string.Equals(_commandInput.AllowScriptsToRun, "yes", StringComparison.OrdinalIgnoreCase))
{
scriptRunSettings = AllowPostActionsSetting.Yes;
}
else if (string.Equals(_commandInput.AllowScriptsToRun, "no", StringComparison.OrdinalIgnoreCase))
{
scriptRunSettings = AllowPostActionsSetting.No;
}
else
{
scriptRunSettings = AllowPostActionsSetting.Prompt;
}
PostActionDispatcher postActionDispatcher = new PostActionDispatcher(_environment, _callbacks, creationResult, scriptRunSettings, _commandInput.IsDryRun);
postActionDispatcher.Process(_inputGetter);
}
public PostActionDispatcher(IEngineEnvironmentSettings environment, TemplateCreationResult creationResult, AllowPostActionsSetting canRunStatus, bool isDryRun)
{
_environment = environment;
_creationResult = creationResult;
_canRunScripts = canRunStatus;
_isDryRun = isDryRun;
}
internal void AddTemplateDefinedPostActions(GenInfo genInfo, TemplateCreationResult genResult, List <PostAction> postActions)
{
foreach (var postaction in genResult.ResultInfo.PostActions)
{
switch (postaction.ActionId.ToString().ToUpper(CultureInfo.InvariantCulture))
{
case GenerateTestCertificatePostAction.Id:
postActions.Add(new GenerateTestCertificatePostAction(genInfo.Template.Identity, genInfo.GetUserName(), postaction, genResult.ResultInfo.PrimaryOutputs, genInfo.Parameters, genInfo.DestinationPath));
break;
case AddProjectReferencesToContextPostAction.Id:
postActions.Add(new AddProjectReferencesToContextPostAction(genInfo.Template.Identity, postaction, genResult.ResultInfo.PrimaryOutputs, genInfo.Parameters, genInfo.DestinationPath));
break;
case AddNugetReferenceToContextPostAction.Id:
postActions.Add(new AddNugetReferenceToContextPostAction(genInfo.Template.Identity, postaction, genInfo.Parameters, genInfo.DestinationPath));
break;
case AddJsonDictionaryItemPostAction.Id:
postActions.Add(new AddJsonDictionaryItemPostAction(genInfo.Template.Identity, postaction, genInfo.Parameters, genInfo.DestinationPath));
break;
case AddSdkReferencesToContextPostAction.Id:
postActions.Add(new AddSdkReferencesToContextPostAction(genInfo.Template.Identity, postaction, genInfo.Parameters, genInfo.DestinationPath));
break;
}
}
}
public void CanProcessFailedPostAction()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var postActionProcessor = new CaptureMePostAction(expectedResult: false);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), postActionProcessor);
var postAction = new MockPostAction();
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Failure, result);
Assert.Equal(engineEnvironmentSettings, postActionProcessor.Calls.Single().EngineEnvironmentSettings);
Assert.Equal(postAction, postActionProcessor.Calls.Single().PostAction);
Assert.Equal(creationEffects, postActionProcessor.Calls.Single().CreationEffects);
Assert.Equal(creationResult, postActionProcessor.Calls.Single().CreationResult);
Assert.Equal("TestPath", postActionProcessor.Calls.Single().OutputPath);
}
public void CanDryRunSuccessPostAction()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var postActionProcessor = new CaptureMePostAction(expectedResult: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), postActionProcessor);
var postAction = new MockPostAction();
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
null,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Success, result);
Assert.Empty(postActionProcessor.Calls);
}
public async Task TrackItemGenAsync(ITemplateInfo template, string appFx, TemplateCreationResult result)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (template != null && result != null)
{
switch (template.GetTemplateType())
{
case TemplateType.Page:
await TrackItemGenAsync(TelemetryEvents.PageGen, template, appFx, result);
break;
case TemplateType.Feature:
await TrackItemGenAsync(TelemetryEvents.FeatureGen, template, appFx, result);
break;
case TemplateType.Unspecified:
break;
}
}
}
public void CanProcessPostActionThrowingException()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), new ThrowExceptionPostAction());
var postAction = new MockPostAction();
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Yes);
Assert.Equal(PostActionExecutionStatus.Failure, result);
}
internal void AddTemplateDefinedPostActions(GenInfo genInfo, TemplateCreationResult genResult, List <PostAction> postActions)
{
var genCertificatePostAction = genResult.ResultInfo.PostActions.FirstOrDefault(x => x.ActionId == GenerateTestCertificatePostAction.Id);
if (genCertificatePostAction != null)
{
postActions.Add(new GenerateTestCertificatePostAction(genInfo.Template.Identity, genInfo.GetUserName(), genCertificatePostAction, genResult.ResultInfo.PrimaryOutputs, genInfo.Parameters));
}
}
public override IEnumerable <PostAction> FindPostActions(GenInfo genInfo, TemplateCreationResult genResult)
{
var postActions = new List <PostAction>();
AddPredefinedActions(genInfo, genResult, postActions);
AddMergeActions(postActions, $"*{MergePostAction.Extension}*", true);
return(postActions);
}
public override IEnumerable <PostAction> FindPostActions(GenInfo genInfo, TemplateCreationResult genResult)
{
var postActions = new List <PostAction>();
AddGetMergeFilesFromProjectPostAction(postActions);
AddGenerateMergeInfoPostAction(postActions);
AddMergeActions(postActions, $"*{MergeConfiguration.Extension}*", false);
return(postActions);
}
internal void ExecutePostActions(GenInfo genInfo, TemplateCreationResult generationResult)
{
// Get post actions from template
var postActions = _postactionFactory.FindPostActions(genInfo, generationResult);
foreach (var postAction in postActions)
{
postAction.Execute();
}
}
private void HandlePostActions(TemplateCreationResult creationResult)
{
if (creationResult.Status != CreationResultStatus.Success)
{
return;
}
PostActionDispatcher postActionDispatcher = new PostActionDispatcher(creationResult, EnvironmentSettings.SettingsLoader.Components);
postActionDispatcher.Process();
}
public override IEnumerable <PostAction> FindPostActions(GenInfo genInfo, TemplateCreationResult genResult)
{
var postActions = new List <PostAction>();
AddPredefinedActions(genInfo, genResult, postActions);
AddTemplateDefinedPostActions(genInfo, genResult, postActions);
AddMergeActions(genInfo, postActions, $"*{MergeConfiguration.Extension}*", true);
AddSearchAndReplaceActions(genInfo, postActions, $"*{MergeConfiguration.SearchReplaceExtension}*", true);
return(postActions);
}
public void CanContinueOnErrorWhenConfigured()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var trueProcessorGuid = Guid.NewGuid();
var falseProcessorGuid = Guid.NewGuid();
var trueProcessor = new CaptureMePostAction(expectedResult: true, guid: trueProcessorGuid);
var falseProcessor = new CaptureMePostAction(expectedResult: false, guid: falseProcessorGuid);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), trueProcessor);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), falseProcessor);
var postAction1 = new MockPostAction
{
ActionId = falseProcessorGuid,
ContinueOnError = true
};
var postAction2 = new MockPostAction
{
ActionId = trueProcessorGuid,
ContinueOnError = true
};
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction1, postAction2
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Yes);
// in case continue on error is true, success status is returned on failure
Assert.Equal(PostActionExecutionStatus.Success, result);
//2 post actions were executed
Assert.Equal(1, trueProcessor.Calls.Count);
Assert.Equal(1, falseProcessor.Calls.Count);
Assert.Equal(postAction1, falseProcessor.Calls[0].PostAction);
Assert.Equal(postAction2, trueProcessor.Calls[0].PostAction);
}
public void CanProcessRunScriptPostActionAndSuccessPostAction_WhenRunScriptPrompt_No()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var postActionProcessor = new CaptureMePostAction(expectedResult: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), postActionProcessor);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), new ProcessStartPostActionProcessor());
var postAction1 = new MockPostAction
{
ActionId = ProcessStartPostActionProcessor.ActionProcessorId,
//the post action will fail, but that is OK for test purpose
Args = new Dictionary <string, string>()
{
{ "executable", "do-not-exist" }
},
ContinueOnError = true
};
var postAction2 = new MockPostAction
{
ActionId = Guid.Empty, //CaptureMePostAction
ContinueOnError = true
};
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction1, postAction2
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
Path.GetTempPath(),
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => "N"); // the user forbids to run post action
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Cancelled, result);
Assert.NotEqual(PostActionExecutionStatus.Failure, result);
Assert.Single(postActionProcessor.Calls);
Assert.Equal(postAction2, postActionProcessor.Calls.Single().PostAction);
}
async Task <List <IWorkspaceFileObject> > GetWorkspaceItems(TemplateCreationResult result)
{
var items = new List <IWorkspaceFileObject> ();
foreach (ICreationPath path in result.ResultInfo.PrimaryOutputs)
{
string fullPath = Path.Combine(config.ProjectLocation, GetPath(path));
if (Services.ProjectService.IsSolutionItemFile(fullPath))
{
items.Add(await Services.ProjectService.ReadSolutionItem(new ProgressMonitor(), fullPath));
}
}
return(items);
}
internal void AddPredefinedActions(GenInfo genInfo, TemplateCreationResult genResult, List <PostAction> postActions)
{
switch (genInfo.Template.GetTemplateOutputType())
{
case TemplateOutputType.Project:
postActions.Add(new AddProjectToContextPostAction(genInfo.Template.Identity, genResult.ResultInfo.PrimaryOutputs, genInfo.Parameters, genInfo.DestinationPath, genInfo.GenerationPath));
break;
case TemplateOutputType.Item:
postActions.Add(new AddItemToContextPostAction(genInfo.Template.Identity, genResult.ResultInfo.PrimaryOutputs, genInfo.Parameters, genInfo.DestinationPath));
break;
default:
break;
}
}
public void CanProcessRunScriptPostAction_DryRun()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), new ProcessStartPostActionProcessor());
var postAction = new MockPostAction
{
ActionId = ProcessStartPostActionProcessor.ActionProcessorId,
//the post action will fail, but that is OK for test purpose
Args = new Dictionary <string, string>()
{
{ "executable", "do-not-exist" }
}
};
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
Path.GetTempPath(),
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => "N"); // the user forbids to run post action
//run script setting doesn't matter for dry run
var result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Success, result);
result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.Yes);
Assert.Equal(PostActionExecutionStatus.Success, result);
result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.No);
Assert.Equal(PostActionExecutionStatus.Success, result);
}
IEnumerable <string> GetFilesToOpen(TemplateCreationResult result)
{
foreach (var postAction in result.ResultInfo.PostActions)
{
switch (postAction.ActionId.ToString().ToUpper())
{
case "84C0DA21-51C8-4541-9940-6CA19AF04EE6":
if (postAction.Args.TryGetValue("files", out var files))
{
foreach (var fi in files.Split(';'))
{
if (int.TryParse(fi.Trim(), out var i))
{
yield return(Path.Combine(config.ProjectLocation, GetPath(result.ResultInfo.PrimaryOutputs [i])));
}
}
}
break;
}
}
}
public async Task TrackProjectGenAsync(ITemplateInfo template, string appFx, TemplateCreationResult result, int?pagesCount = null, int?featuresCount = null, double?timeSpent = null)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (template.GetTemplateType() != TemplateType.Project)
{
return;
}
GenStatusEnum telemetryStatus = result.Status == CreationResultStatus.Success ? GenStatusEnum.Completed : GenStatusEnum.Error;
await TrackProjectAsync(telemetryStatus, template.Name, template.GetProjectType(), appFx, pagesCount, featuresCount, timeSpent, result.Status, result.Message);
}
public async Task TrackItemGenAsync(ITemplateInfo template, GenSourceEnum genSource, UserSelectionContext context, TemplateCreationResult result)
{
if (template == null)
{
throw new ArgumentNullException(nameof(template));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (template != null && result != null)
{
switch (template.GetTemplateType())
{
case TemplateType.Page:
await TrackItemGenAsync(TelemetryEvents.PageGen, template, genSource, context, result);
break;
case TemplateType.Feature:
await TrackItemGenAsync(TelemetryEvents.FeatureGen, template, genSource, context, result);
break;
case TemplateType.Service:
await TrackItemGenAsync(TelemetryEvents.ServiceGen, template, genSource, context, result);
break;
case TemplateType.Testing:
await TrackItemGenAsync(TelemetryEvents.TestingGen, template, genSource, context, result);
break;
case TemplateType.Unspecified:
break;
}
}
}
public async Task <ICreationResult> CreateAsync(ITemplateInfo info, string name, string outputPath, IReadOnlyDictionary <string, string> parameters, bool skipUpdateCheck, string baselineName)
{
TemplateCreationResult instantiateResult = await _templateCreator.InstantiateAsync(info, name, name, outputPath, parameters, skipUpdateCheck, forceCreation : false, baselineName : baselineName).ConfigureAwait(false);
return(instantiateResult.ResultInfo);
}
private async Task TrackItemGenAsync(string eventToTrack, ITemplateInfo template, GenSourceEnum genSource, UserSelectionContext context, TemplateCreationResult result)
{
GenStatusEnum telemetryStatus = result.Status == CreationResultStatus.Success ? GenStatusEnum.Completed : GenStatusEnum.Error;
await TrackItemGenAsync(eventToTrack, telemetryStatus, context, template.GetTelemetryName(), genSource, result.Status, result.Message);
}
public async Task TrackProjectGenAsync(ITemplateInfo template, UserSelectionContext context, TemplateCreationResult result, Guid vsProjectId, GenItemsTelemetryData genItemsTelemetryData = null, double?timeSpent = null, Dictionary <ProjectMetricsEnum, double> performanceCounters = null)
{
if (template == null)
{
throw new ArgumentNullException(nameof(template));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (template.GetTemplateType() != TemplateType.Project)
{
return;
}
GenStatusEnum telemetryStatus = result.Status == CreationResultStatus.Success ? GenStatusEnum.Completed : GenStatusEnum.Error;
await TrackProjectAsync(telemetryStatus, template.GetTelemetryName(), context, vsProjectId, genItemsTelemetryData, timeSpent, performanceCounters, result.Status, result.Message);
}
public async Task TrackItemGenAsync(ITemplateInfo template, GenSourceEnum genSource, string appProjectType, string appFrontendFramework, string appBackendFramework, string appPlatform, TemplateCreationResult result)
{
if (template == null)
{
throw new ArgumentNullException(nameof(template));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (template != null && result != null)
{
switch (template.GetTemplateType())
{
case TemplateType.Page:
await TrackItemGenAsync(TelemetryEvents.PageGen, template, genSource, appProjectType, appFrontendFramework, appBackendFramework, appPlatform, result);
break;
case TemplateType.Feature:
await TrackItemGenAsync(TelemetryEvents.FeatureGen, template, genSource, appProjectType, appFrontendFramework, appBackendFramework, appPlatform, result);
break;
case TemplateType.Service:
await TrackItemGenAsync(TelemetryEvents.ServiceGen, template, genSource, appProjectType, appFrontendFramework, appBackendFramework, appPlatform, result);
break;
case TemplateType.Testing:
await TrackItemGenAsync(TelemetryEvents.TestingGen, template, genSource, appProjectType, appFrontendFramework, appBackendFramework, appPlatform, result);
break;
case TemplateType.Unspecified:
break;
}
}
}
private async Task TrackItemGenAsync(string eventToTrack, ITemplateInfo template, GenSourceEnum genSource, string appProjectType, string appFrontendFramework, string appBackendFramework, string appPlatform, TemplateCreationResult result)
{
GenStatusEnum telemetryStatus = result.Status == CreationResultStatus.Success ? GenStatusEnum.Completed : GenStatusEnum.Error;
await TrackItemGenAsync(eventToTrack, telemetryStatus, appProjectType, appFrontendFramework, appBackendFramework, appPlatform, template.GetTelemetryName(), genSource, result.Status, result.Message);
}
public abstract IEnumerable <PostAction> FindPostActions(GenInfo genInfo, TemplateCreationResult genResult);
private static int Main(string[] args)
{
string profileDir = GetHomeDirectory();
string hivePath = Path.Combine(profileDir, ".templateengine", HostName, HostVersion);
ITemplateEngineHost host = CreateHost(HostName, HostVersion);
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x), hivePath);
EnvironmentSettings.SettingsLoader.Components.OfType <IIdentifiedComponent>().ToList();
_paths = new Paths(EnvironmentSettings);
//NOTE: With the base directory virtualized, packages cannot be installed from NuGet,
// only local packages and folders
EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.Content);
EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.Packages);
_settingsLoader = (SettingsLoader)EnvironmentSettings.SettingsLoader;
_hostDataLoader = new HostSpecificDataLoader(EnvironmentSettings.SettingsLoader);
CommandLineParser parser = new CommandLineParser(args)
.AddOptionWithConstrainedValue("--operation", new[]
{
"list",
"create"
})
.AddOptionWithValue("--require")
.AddOptionWithValue("--source");
if (!parser.TryGetValues("--require", out IReadOnlyList <string> requireDirectives) ||
!parser.TryGetSingleValue("--operation", out string operation))
{
Console.SetOut(Console.Error);
Console.WriteLine("ERROR: Expected \"--require\" and/or \"--operation\" parameter.");
return(-1);
}
IInstaller installer = new Installer(EnvironmentSettings);
if (!parser.TryGetValues("--source", out IReadOnlyList <string> sources))
{
sources = null;
}
installer.InstallPackages(requireDirectives, sources?.ToList());
//All required templates/components/lang packs have now been configured
//Desired operation information starts at args[commandArgsStart]
_templateCreator = new TemplateCreator(EnvironmentSettings);
IReadOnlyList <TemplateInfo> rawTemplates = _settingsLoader.UserTemplateCache.TemplateInfo;
var templates = new JArray();
foreach (var rawTemplate in rawTemplates)
{
var template = JObject.FromObject(rawTemplate);
template.Add("Parameters", JArray.FromObject(rawTemplate.Parameters));
templates.Add(template);
}
if (string.Equals(operation, "list"))
{
Console.WriteLine(templates);
return(0);
}
parser = parser.AddOptionWithValue("--identity");
if (!parser.TryGetSingleValue("--identity", out string identity))
{
Console.SetOut(Console.Error);
Console.WriteLine("ERROR: Expected \"--identity\" parameter.");
return(-1);
}
TemplateInfo info = rawTemplates.FirstOrDefault(x => string.Equals(x.Identity, identity, StringComparison.Ordinal));
if (info == null)
{
Console.SetOut(Console.Error);
Console.WriteLine("ERROR: Failed to find template with identity \"{0}\".", identity);
return(-1);
}
if (string.Equals(operation, "create"))
{
Dictionary <string, string> templateArgs = new Dictionary <string, string>(StringComparer.Ordinal);
foreach (ITemplateParameter x in info.Parameters)
{
if (x.DataType != null && x.DataType.StartsWith("bool", StringComparison.OrdinalIgnoreCase))
{
parser = parser.AddOptionWithBooleanValue($"--arg:{x.Name}", string.IsNullOrEmpty(x.DefaultValue) || string.Equals(x.DefaultValue, "true"));
}
else if (x.DataType != null && x.DataType.Equals("choice", StringComparison.OrdinalIgnoreCase))
{
parser = parser.AddOptionWithConstrainedValue($"--arg:{x.Name}", x.Choices.Keys.ToList());
}
else
{
parser = parser.AddOptionWithValue($"--arg:{x.Name}");
}
if (parser.TryGetSingleValue($"--arg:{x.Name}", out string val))
{
templateArgs[x.Name] = val;
}
}
TemplateCreationResult result = _templateCreator.InstantiateAsync(info, null, null, null, templateArgs, true, false, null).Result;
if (result.Status == CreationResultStatus.Success)
{
PostActionDispatcher postActionDispatcher = new PostActionDispatcher(EnvironmentSettings, result, AllowPostActionsSetting.Yes, false);
postActionDispatcher.Process(null);
}
Console.WriteLine(JObject.FromObject(result));
return((int)result.Status);
}
return(0);
}
private async Task TrackItemGenAsync(string eventToTrack, ITemplateInfo template, GenSourceEnum genSource, string appProjectType, string appFx, TemplateCreationResult result)
{
GenStatusEnum telemetryStatus = result.Status == CreationResultStatus.Success ? GenStatusEnum.Completed : GenStatusEnum.Error;
await TrackItemGenAsync(eventToTrack, telemetryStatus, appProjectType, appFx, template.Name, genSource, result.Status, result.Message);
}
