/// <summary>
/// Checks if there is an update for the package containing the template to execute.
/// </summary>
/// <param name="args">template command arguments.</param>
/// <param name="cancellationToken"></param>
/// <returns>Task for checking the update or null when check for update is not possible.</returns>
internal async Task <CheckUpdateResult?> CheckUpdateForTemplate(TemplateCommandArgs args, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
//if update check is disabled - do nothing
if (args.NoUpdateCheck)
{
return(null);
}
ITemplatePackage templatePackage;
try
{
templatePackage = await _templatePackageManager.GetTemplatePackageAsync(args.Template, cancellationToken).ConfigureAwait(false);
}
catch (Exception)
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.TemplatePackageCoordinator_Error_PackageForTemplateNotFound, args.Template.Identity));
return(null);
}
if (!(templatePackage is IManagedTemplatePackage managedTemplatePackage))
{
//update is not supported - built-in or optional workload source
return(null);
}
InitializeNuGetCredentialService(interactive: false);
return((await managedTemplatePackage.ManagedProvider.GetLatestVersionsAsync(new[] { managedTemplatePackage }, cancellationToken).ConfigureAwait(false)).Single());
}
internal void Create_CanParseChoiceTemplateOptions(string command, string parameterName, string parameterValues, string?defaultIfNoOptionValue, string?expectedValue)
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithChoiceParameter(parameterName, parameterValues.Split("|"), defaultIfNoOptionValue: defaultIfNoOptionValue);
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse($"new create {command}");
var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
Parser parser = ParserFactory.CreateParser(templateCommand);
ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>());
var templateArgs = new TemplateCommandArgs(templateCommand, instantiateCommand, templateParseResult);
if (string.IsNullOrWhiteSpace(expectedValue))
{
Assert.False(templateArgs.TemplateParameters.ContainsKey(parameterName));
}
else
{
Assert.True(templateArgs.TemplateParameters.ContainsKey(parameterName));
Assert.Equal(expectedValue, templateArgs.TemplateParameters[parameterName]);
}
}
internal void CanParseAllowScriptsOption(string command, AllowRunScripts?result)
{
var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group")
.WithPostActions(ProcessStartPostActionProcessor.ActionProcessorId);
TemplateGroup templateGroup = TemplateGroup.FromTemplateList(
CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>()))
.Single();
ITemplateEngineHost host = TestHost.GetVirtualHost();
IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>();
NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
var parseResult = myCommand.Parse(command);
InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
Parser parser = ParserFactory.CreateParser(templateCommand);
ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>());
TemplateCommandArgs templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
Assert.Equal(result, templateArgs.AllowScripts);
}
internal async Task <NewCommandStatus> InvokeTemplateAsync(TemplateCommandArgs templateArgs, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
string?templateLanguage = templateArgs.Template.GetLanguage();
bool isMicrosoftAuthored = string.Equals(templateArgs.Template.Author, "Microsoft", StringComparison.OrdinalIgnoreCase);
string?framework = null;
string?auth = null;
string?templateName = TelemetryHelper.HashWithNormalizedCasing(templateArgs.Template.Identity);
if (isMicrosoftAuthored)
{
templateArgs.TemplateParameters.TryGetValue("Framework", out string?inputFrameworkValue);
framework = TelemetryHelper.HashWithNormalizedCasing(TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(templateArgs.Template, "Framework", inputFrameworkValue));
templateArgs.TemplateParameters.TryGetValue("auth", out string?inputAuthValue);
auth = TelemetryHelper.HashWithNormalizedCasing(TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(templateArgs.Template, "auth", inputAuthValue));
}
bool success = true;
try
{
return(await CreateTemplateAsync(templateArgs, cancellationToken).ConfigureAwait(false));
}
catch (ContentGenerationException cx)
{
success = false;
Reporter.Error.WriteLine(cx.Message.Bold().Red());
if (cx.InnerException != null)
{
Reporter.Error.WriteLine(cx.InnerException.Message.Bold().Red());
}
return(NewCommandStatus.CreateFailed);
}
catch (Exception ex)
{
success = false;
Reporter.Error.WriteLine(ex.Message.Bold().Red());
}
finally
{
_telemetryLogger.TrackEvent(templateArgs.RootCommand.Name + TelemetryConstants.CreateEventSuffix, new Dictionary <string, string?>
{
{ TelemetryConstants.Language, templateLanguage },
{ TelemetryConstants.ArgError, "False" },
{ TelemetryConstants.Framework, framework },
{ TelemetryConstants.TemplateName, templateName },
{ TelemetryConstants.IsTemplateThirdParty, (!isMicrosoftAuthored).ToString() },
{ TelemetryConstants.CreationResult, success.ToString() },
{ TelemetryConstants.Auth, auth }
});
}
return(NewCommandStatus.CreateFailed);
}
protected override async Task Execute(IFieldObjUser user, FieldTemplate template, TemplateCommandArgs args)
{
var field = await _repository.Retrieve(template.ID);
await field.Enter(user, 0);
}
protected override async Task Execute(IFieldObjUser user, ItemTemplate template, TemplateCommandArgs args)
{
await user.ModifyInventory(i => i.Add(template.ID));
}
