public TemplateEngineHost() : base(VSHost, FindTemplateHostVersion(), VSHostLocale)
{
MountPointFactory = new FileSystemMountPointFactory();
Settings = new EngineEnvironmentSettings(this, settings => new TemplateSettingsLoader(settings));
Orchestrator = new RunnableProjectOrchestrator(new Orchestrator());
TemplateCreator = new TemplateCreator(Settings);
Generator = new RunnableProjectGenerator();
MountPointManager = new MountPointManager(Settings, ComponentManager);
HostDefaults = new Dictionary <string, string>
{
["HostIdentifier"] = HostIdentifier,
["Locale"] = Locale,
["Version"] = Version
};
UserTemplates = SettingsLoader.UserTemplateCache.TemplateInfo;
MountPoints = new List <IMountPoint>();
foreach (var mountPointInfo in SettingsLoader.MountPoints)
{
if (MountPointFactory.TryMount(MountPointManager, mountPointInfo, out var mountPoint))
{
MountPoints.Add(mountPoint);
}
}
}
private CodeGen(string locationId, string hostVersion)
{
var host = CreateHost(locationId, hostVersion);
Settings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x));
Creator = new TemplateCreator(Settings);
}
public Template GenerateEmptyTemplate()
{
TemplateCreator templateCreator = new TemplateCreator();
Template armTemplate = templateCreator.CreateEmptyTemplate();
return(armTemplate);
}
public static MasterTemplateCreator GenerateMasterTemplateCreator()
{
TemplateCreator templateCreator = new TemplateCreator();
MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator(templateCreator);
return(masterTemplateCreator);
}
public async Task TestLocalizedPostActionFields(
int postActionIndex,
string locale,
string expectedDescription,
string expectedManualInstructions)
{
var environmentSettings = LoadHostWithLocalizationTemplates(locale, out var templatePackageManager, out ITemplateInfo localizationTemplate);
var templateCreator = new TemplateCreator(environmentSettings);
ITemplate template = templateCreator.LoadTemplate(localizationTemplate, null);
Assert.NotNull(template);
Assert.NotNull(template.Generator);
ICreationEffects effects = await template.Generator.GetCreationEffectsAsync(
environmentSettings,
template,
template.Generator.GetParametersForTemplate(environmentSettings, template),
Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()),
default);
Assert.NotNull(effects);
Assert.NotNull(effects.CreationResult);
Assert.NotNull(effects.CreationResult.PostActions);
Assert.True(effects.CreationResult.PostActions.Count > postActionIndex, "Template does not contain enough post actions");
Assert.Equal(expectedDescription, effects.CreationResult.PostActions[postActionIndex].Description);
Assert.Equal(expectedManualInstructions, effects.CreationResult.PostActions[postActionIndex].ManualInstructions);
}
public int Execute()
{
//add deps and runtime config to params
var targetPath = Path.GetFullPath(AssemblyPath !);
var targetDirectory = Path.GetDirectoryName(targetPath) !;
var assemblyName = Path.GetFileNameWithoutExtension(targetPath);
var depsFile = Path.Combine(targetDirectory, assemblyName + ".deps.json");
var runtimeConfig = Path.Combine(targetDirectory, assemblyName + ".runtimeconfig.json");
var args = new List <string> {
"exec", "--depsfile", depsFile
};
if (File.Exists(runtimeConfig))
{
args.Add("--runtimeconfig");
args.Add(runtimeConfig);
}
//we want to run run PostgreSql.Exec
var currentAssembly = Path.GetFullPath(Assembly.GetExecutingAssembly().Location) !;
args.Add(currentAssembly);
//pass the arguments
args.AddRange(TemplateCreator.GetArgs(this));
return(Exe.Run("dotnet", args, targetDirectory));
}
public static APIVersionSetTemplateCreator GenerateAPIVersionSetTemplateCreator()
{
TemplateCreator templateCreator = new TemplateCreator();
APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator(templateCreator);
return(apiVersionSetTemplateCreator);
}
public async Task <string> GenerateProject(GeneratorModel model)
{
var randomString = Guid.NewGuid().ToString() + DateTime.Now.Millisecond;
var outFolder = Path.Combine(_outPath, randomString, model.ProjectName);
var iParams = new Dictionary <string, string> {
{ "Name", model.ProjectName }
};
foreach (var p in model.GetTemplateParameters())
{
if (p.Contains('='))
{
var paramkvp = p.Split('=');
if (paramkvp.Length == 2)
{
iParams.Add(paramkvp[0], paramkvp[1]);
}
}
else
{
iParams.Add(p, "true");
}
}
if (!string.IsNullOrEmpty(model.TargetFrameworkVersion))
{
iParams.Add("Framework", model.TargetFrameworkVersion);
}
var templateShortName = string.IsNullOrEmpty(model.TemplateShortName) ? DEFAULT_TEMPLATE : model.TemplateShortName;
TemplateInfo templateInfo = FindTemplateByShortName(templateShortName, model.TemplateVersion, EnvSettings);
if (templateInfo == null)
{
throw new Exception($"Could not find template with shortName: {templateShortName} ");
}
TemplateCreator creator = new TemplateCreator(EnvSettings);
var creationResult = await creator.InstantiateAsync(
templateInfo : templateInfo,
name : model.ProjectName,
fallbackName : "SteeltoeProject",
outputPath : outFolder,
inputParameters : iParams,
skipUpdateCheck : true,
forceCreation : false,
baselineName : "baseLine");
if (creationResult.Status != CreationResultStatus.Success)
{
throw new InvalidDataException(creationResult.Message + ": " + creationResult.Status + " " + templateShortName);
}
return(outFolder);
}
void Initialize()
{
host = new CustomTemplateEngineHost();
settings = new EngineEnvironmentSettings(host, s => new SettingsLoader(s));
paths = new Paths(settings);
templateCreator = new TemplateCreator(settings);
DeleteCache();
}
public void CreateDefaultTemplate()
{
using (var unitOfWork = new UnitOfWork(_sessionFactory))
{
string docXContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
var templateCreator = new TemplateCreator(unitOfWork, _repositoriesFactory);
templateCreator.Create("Domyślny", "UMOWA.docx", docXContentType);
}
}
private static void ConfigureTemplates()
{
var mediaTemplate = new Template <MediaElement, UIElement>()
.WithArgument(m => m.ScrubbingEnabled = true)
.WithArgument(m => m.LoadedBehavior = MediaState.Manual)
.WithArgument(m => m.UnloadedBehavior = MediaState.Manual)
.WithArgument(m => m.Volume = 0);
MediaPlayerTemplate = new TemplateCreator <MediaElement, UIElement>(mediaTemplate);
}
public static int Main(string[] args)
{
if (args.Length > 0 && args[0] == TemplateCreator.Verb)
{
return(TemplateCreator.Run(args));
}
//Cannot continue with statics or in the same class here as otherwise references to other libs (like CommandLineParser) get loaded, which may
//not be available when running in a completely different load context of another project when creating templates.
return(Commandline.ParseAndExecute(args));
}
public TemplateInvoker(IEngineEnvironmentSettings environment, INewCommandInput commandInput, ITelemetryLogger telemetryLogger, string commandName, Func <string> inputGetter)
{
_environment = environment;
_commandInput = commandInput;
_telemetryLogger = telemetryLogger;
_commandName = commandName;
_inputGetter = inputGetter;
_templateCreator = new TemplateCreator(_environment);
_hostDataLoader = new HostSpecificDataLoader(_environment.SettingsLoader);
}
public static APITemplateCreator GenerateAPITemplateCreator()
{
FileReader fileReader = new FileReader();
TemplateCreator templateCreator = new TemplateCreator();
PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader);
ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator();
DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator();
APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, templateCreator, policyTemplateCreator, productAPITemplateCreator, diagnosticTemplateCreator);
return(apiTemplateCreator);
}
public TemplateInvocationAndAcquisitionCoordinator(SettingsLoader settingsLoader, INewCommandInput commandInput, TemplateCreator templateCreator, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, string defaultLanguage, string commandName, Func <string> inputGetter)
{
_settingsLoader = settingsLoader;
_environment = _settingsLoader.EnvironmentSettings;
_commandInput = commandInput;
_templateCreator = templateCreator;
_hostDataLoader = hostDataLoader;
_telemetryLogger = telemetryLogger;
_defaultLanguage = defaultLanguage;
_commandName = commandName;
_inputGetter = inputGetter;
}
public Template GenerateEmptyTemplateWithParameters()
{
TemplateCreator templateCreator = new TemplateCreator();
Template armTemplate = templateCreator.CreateEmptyTemplate();
armTemplate.parameters = new Dictionary <string, TemplateParameterProperties> {
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
return(armTemplate);
}
public Bootstrapper(ITemplateEngineHost host, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, bool virtualizeConfiguration)
{
_host = host;
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x));
Installer = new Installer(EnvironmentSettings);
_onFirstRun = onFirstRun;
_paths = new Paths(EnvironmentSettings);
_templateCreator = new TemplateCreator(EnvironmentSettings);
if (virtualizeConfiguration)
{
EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.BaseDir);
}
}
public New3Command(string commandName, ITemplateEngineHost host, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, ExtendedCommandParser app, CommandArgument templateName)
{
host = new ExtendedTemplateEngineHost(host, this);
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x));
Installer = new Installer(EnvironmentSettings);
_templateCreator = new TemplateCreator(EnvironmentSettings);
_templateCache = new TemplateCache(EnvironmentSettings);
_aliasRegistry = new AliasRegistry(EnvironmentSettings);
CommandName = commandName;
_paths = new Paths(EnvironmentSettings);
_app = app;
_templateNameArgument = templateName;
_onFirstRun = onFirstRun;
}
internal void CreateSideBySideFiles(TestDescription test, string testHeaderHtml)
{
var dirManager = new DirectoryManager(_argProc);
var _templateCreator = new TemplateCreator(_argProc, TemplateCreator.TemplateNameSideBySide);
_templateCreator.SetTemplateParam(TemplateCreator.TemplateParamHeader, testHeaderHtml);
_templateCreator.SetTemplateParam(TemplateCreator.TemplateParamExpectedImage, dirManager.GetExpectedImageFilename(test));
_templateCreator.SetTemplateParam(TemplateCreator.TemplateParamActualImage, dirManager.GetActualImageFilename(test.Name));
_templateCreator.SetTemplateParam(TemplateCreator.TemplateParamName, test.Name);
string outFilename = dirManager.GetSideBySideFilename(test);
string outFilePath = Path.Combine(dirManager.GetOutputDirectoryFullPath(), outFilename);
_templateCreator.Save(outFilePath);
}
public virtual void SetUp()
{
unitOfWork = new UnitOfWork(sessionFactory);
studentsCreator = new StudentCreator(unitOfWork, repositoriesFactory);
studentsProvider = new StudentsProvider(unitOfWork, repositoriesFactory);
studentDestructor = new StudentDestructor(unitOfWork, repositoriesFactory);
studentImporter = new CsvStudentsImporter(studentsCreator);
modesCreator = new ModesCreator(unitOfWork, repositoriesFactory);
modesProvider = new ModesProvider(unitOfWork, repositoriesFactory);
companyCreator = new CompanyCreator(unitOfWork, repositoriesFactory);
companyUpdater = new CompanyUpdater(unitOfWork, repositoriesFactory);
companyDestructor = new CompanyDestructor(unitOfWork, repositoriesFactory);
companiesProvider = new CompaniesProvider(unitOfWork, repositoriesFactory);
offerCreator = new OfferCreator(unitOfWork, repositoriesFactory);
offerUpdater = new OfferUpdater(unitOfWork, repositoriesFactory);
offerDestructor = new OfferDestructor(unitOfWork, repositoriesFactory);
offerProvider = new OffersProvider(unitOfWork, repositoriesFactory);
courseCreator = new CourseCreator(unitOfWork, repositoriesFactory);
courseProvider = new CoursesProvider(unitOfWork, repositoriesFactory);
courseUpdater = new CourseUpdater(unitOfWork, repositoriesFactory, authenticationService);
courseDestructor = new CourseDestructor(unitOfWork, repositoriesFactory);
departmentCreator = new DepartmentCreator(unitOfWork, repositoriesFactory);
departmentProvider = new DepartmentsProvider(unitOfWork, repositoriesFactory);
departmentDestructor = new DepartmentDestructor(unitOfWork, repositoriesFactory);
departmentUpdater = new DepartmentUpdater(unitOfWork, repositoriesFactory);
employeesDestructor = new EmployeeDestructor(unitOfWork, this.repositoriesFactory, this.authenticationService);
employeesProvider = new EmployeesProvider(unitOfWork, repositoriesFactory);
employeeCreator = new EmployeeCreator(unitOfWork, this.authenticationService, this.repositoriesFactory);
employeesUpdater = new EmployeeUpdater(unitOfWork, this.repositoriesFactory, this.authenticationService);
templateCreator = new TemplateCreator(unitOfWork, repositoriesFactory);
templateDestructor = new TemplateDestructor(unitOfWork, repositoriesFactory);
templateProvider = new TemplatesProvider(unitOfWork, repositoriesFactory);
offerTypeCreator = new OfferTypeCreator(unitOfWork, repositoriesFactory);
offerTypeProvider = new OfferTypeProvider(unitOfWork, repositoriesFactory);
universityDetailsCreator = new UniversityDetailsCreator(unitOfWork, repositoriesFactory);
universityUpdater = new UniversityDetailsUpdater(unitOfWork, repositoriesFactory);
universityDetailsProvider = new UniversityDetailsProvider(unitOfWork, repositoriesFactory);
}
public New3Command(string commandName, ITemplateEngineHost host, ITelemetryLogger telemetryLogger, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, INewCommandInput commandInput, string hivePath)
{
_telemetryLogger = telemetryLogger;
host = new ExtendedTemplateEngineHost(host, this);
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x), hivePath);
_settingsLoader = (SettingsLoader)EnvironmentSettings.SettingsLoader;
Installer = new Installer(EnvironmentSettings);
_templateCreator = new TemplateCreator(EnvironmentSettings);
_aliasRegistry = new AliasRegistry(EnvironmentSettings);
CommandName = commandName;
_paths = new Paths(EnvironmentSettings);
_onFirstRun = onFirstRun;
_hostDataLoader = new HostSpecificDataLoader(EnvironmentSettings.SettingsLoader);
_commandInput = commandInput;
if (!EnvironmentSettings.Host.TryGetHostParamDefault("prefs:language", out _defaultLanguage))
{
_defaultLanguage = null;
}
}
/// <summary>
/// The intilizaing of menu tabs creates the correct pages depending on if a user is a instructor or student.
/// </summary>
private void InitializeMenuTabs()
{
if (Session.LoggedInUser.Sysmin)
{
overviewTab = new InstructorOverviewTab();
profileTab = new InstructorProfileTab(Session.LoggedInUser);
}
else
{
overviewTab = new StudentOverviewTab();
profileTab = new StudentProfileTab(Session.LoggedInUser);
}
documentViewer = new DocumentViewer();
userSearchTab = new UserSearchTab();
calendarTab = new CalendarTabG(overviewTab, this);
driveLogTab = new DriveLogTab(Session.LoggedInUser);
_lessonCreator = new TemplateCreator();
overviewTab.Hide();
profileTab.Hide();
driveLogTab.Hide();
documentViewer.Hide();
userSearchTab.Hide();
calendarTab.Hide();
_lessonCreator.Hide();
MoveButtonSpaces(OverviewButton, 8);
MoveButtonSpaces(ProfileButton, 8);
MoveButtonSpaces(bookingButton, 8);
MoveButtonSpaces(settingsButton, 8);
MoveButtonSpaces(userSearchButton, 8);
OverviewButton.Controls.Add(pictureHomeTab);
ProfileButton.Controls.Add(pictureProfileTab);
bookingButton.Controls.Add(pictureBookingTab);
settingsButton.Controls.Add(pictureSettingsTab);
userSearchButton.Controls.Add(pictureSearchTab);
}
public TemplateManager()
{
var host = new ExtendedTemplateEngineHost(CreateHost(false), this);
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x), null);
_settingsLoader = (SettingsLoader)EnvironmentSettings.SettingsLoader;
Installer = new Installer(EnvironmentSettings);
_templateCreator = new TemplateCreator(EnvironmentSettings);
_aliasRegistry = new AliasRegistry(EnvironmentSettings);
CommandName = CommandNameString;
_paths = new Paths(EnvironmentSettings);
_onFirstRun = FirstRun;
_hostDataLoader = new HostSpecificDataLoader(EnvironmentSettings.SettingsLoader);
_commandInput = new NewCommandInputCli(CommandNameString);
if (!EnvironmentSettings.Host.TryGetHostParamDefault("prefs:language", out _defaultLanguage))
{
_defaultLanguage = null;
}
_commandInput.ResetArgs();
Initialise();
}
public MainForm(Account account)
{
InitializeComponent();
this.account = account;
notificationSender = new NotificationSender();
NotificationSender.LoginedEmployee = account;
notificationSender.FormClosed += (sender, e) => Close();
InitializeButtonList(notificationSender);
templateCreator = new TemplateCreator();
TemplateCreator.LoginedEmployee = account;
templateCreator.FormClosed += (sender, e) => Close();
InitializeButtonList(templateCreator);
logViewer = new LogViewer();
LogViewer.LoginedEmployee = account;
logViewer.FormClosed += (sender, e) => Close();
InitializeButtonList(logViewer);
defaultForm = notificationSender;
ShowInTaskbar = false;
}
private static CreationResultStatus TemplateDetailedHelpForSingularTemplateGroup(IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroup, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator)
{
// (scp 2017-09-06): parse errors probably can't happen in this context.
foreach (string parseErrorMessage in unambiguousTemplateGroup.Where(x => x.HasParseError()).Select(x => x.GetParseError()).ToList())
{
Reporter.Error.WriteLine(parseErrorMessage.Bold().Red());
}
GetParametersInvalidForTemplatesInList(unambiguousTemplateGroup, out IReadOnlyList <string> invalidForAllTemplates, out IReadOnlyList <string> invalidForSomeTemplates);
if (invalidForAllTemplates.Count > 0 || invalidForSomeTemplates.Count > 0)
{
DisplayInvalidParameters(invalidForAllTemplates);
DisplayParametersInvalidForSomeTemplates(invalidForSomeTemplates, LocalizableStrings.SingleTemplateGroupPartialMatchSwitchesNotValidForAllMatches);
}
bool showImplicitlyHiddenParams = unambiguousTemplateGroup.Count > 1;
TemplateDetailsDisplay.ShowTemplateGroupHelp(unambiguousTemplateGroup, environmentSettings, commandInput, hostDataLoader, templateCreator, showImplicitlyHiddenParams);
return(invalidForAllTemplates.Count > 0 || invalidForSomeTemplates.Count > 0
? CreationResultStatus.InvalidParamValues
: CreationResultStatus.Success);
}
private static CreationResultStatus DisplayHelpForUnambiguousTemplateGroup(TemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator, string defaultLanguage)
{
// filter on the default language if needed, the details display should be for a single language group
if (!templateResolutionResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroupForDetailDisplay))
{
// this is really an error
unambiguousTemplateGroupForDetailDisplay = new List <ITemplateMatchInfo>();
}
if (commandInput.IsListFlagSpecified)
{
// because the list flag is present, don't display help for the template group, even though an unambiguous group was resolved.
if (!AreAllParamsValidForAnyTemplateInList(unambiguousTemplateGroupForDetailDisplay) &&
TemplateListResolver.FindHighestPrecedenceTemplateIfAllSameGroupIdentity(unambiguousTemplateGroupForDetailDisplay) != null)
{
DisplayHelpForAcceptedParameters(commandInput.CommandName);
return(CreationResultStatus.InvalidParamValues);
}
// get the group without filtering on default language
if (!templateResolutionResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroupForList, true))
{
// this is really an error
unambiguousTemplateGroupForList = new List <ITemplateMatchInfo>();
}
if (templateResolutionResult.UsingPartialMatches)
{
ShowNoTemplatesFoundMessage(commandInput.TemplateName, commandInput.Language, commandInput.TypeFilter);
return(CreationResultStatus.NotFound);
}
ShowTemplatesFoundMessage(commandInput.TemplateName, commandInput.Language, commandInput.TypeFilter);
DisplayTemplateList(unambiguousTemplateGroupForList, environmentSettings, commandInput.Language, defaultLanguage);
// list flag specified, so no usage examples or detailed help
return(CreationResultStatus.Success);
}
else
{
// not in list context, but Unambiguous
// this covers whether or not --help was input, they do the same thing in the unambiguous case
return(TemplateDetailedHelpForSingularTemplateGroup(unambiguousTemplateGroupForDetailDisplay, environmentSettings, commandInput, hostDataLoader, templateCreator));
}
}
public static CreationResultStatus CoordinateHelpAndUsageDisplay(TemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, TemplateCreator templateCreator, string defaultLanguage, bool showUsageHelp = true)
{
if (showUsageHelp)
{
ShowUsageHelp(commandInput, telemetryLogger);
}
// this is just checking if there is an unambiguous group.
// the called methods decide whether to get the default language filtered lists, based on what they're doing.
//
// The empty TemplateName check is for when only 1 template (or group) is installed.
// When that occurs, the group is considered partial matches. But the output should be the ambiguous case - list the templates, not help on the singular group.
if (!string.IsNullOrEmpty(commandInput.TemplateName) &&
templateResolutionResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroup) &&
TemplateListResolver.AreAllTemplatesSameLanguage(unambiguousTemplateGroup))
{
// This will often show detailed help on the template group, which only makes sense if they're all the same language.
return(DisplayHelpForUnambiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, templateCreator, defaultLanguage));
}
else
{
return(DisplayHelpForAmbiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, telemetryLogger, defaultLanguage));
}
}
private static TemplateGroupParameterDetails DetermineParameterDispositionsForTemplateGroup(IReadOnlyList <ITemplateInfo> templateGroup, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator)
{
HashSet <string> groupUserParamsWithInvalidValues = new HashSet <string>(StringComparer.Ordinal);
bool groupHasPostActionScriptRunner = false;
List <IParameterSet> parameterSetsForAllTemplatesInGroup = new List <IParameterSet>();
IDictionary <string, InvalidParameterInfo> invalidParametersForGroup = new Dictionary <string, InvalidParameterInfo>(StringComparer.Ordinal);
bool firstInList = true;
Dictionary <string, IReadOnlyList <string> > defaultVariantsForCanonicals = new Dictionary <string, IReadOnlyList <string> >(StringComparer.Ordinal);
Dictionary <string, IReadOnlyList <string> > groupVariantsForCanonicals = new Dictionary <string, IReadOnlyList <string> >(StringComparer.Ordinal);
HashSet <string> groupUserParamsWithDefaultValues = new HashSet <string>(StringComparer.Ordinal);
Dictionary <string, bool> parameterHidingDisposition = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
HashSet <string> parametersToAlwaysShow = new HashSet <string>(StringComparer.Ordinal);
foreach (ITemplateInfo templateInfo in templateGroup.OrderByDescending(x => x.Precedence))
{
TemplateUsageInformation usageInformation = TemplateUsageHelp.GetTemplateUsageInformation(templateInfo, environmentSettings, commandInput, hostDataLoader, templateCreator);
HostSpecificTemplateData hostSpecificTemplateData = hostDataLoader.ReadHostSpecificTemplateData(templateInfo);
HashSet <string> parametersToExplicitlyHide = hostSpecificTemplateData?.HiddenParameterNames ?? new HashSet <string>(StringComparer.Ordinal);
foreach (ITemplateParameter parameter in usageInformation.AllParameters.ParameterDefinitions)
{
//If the parameter has previously been encountered...
if (parameterHidingDisposition.TryGetValue(parameter.Name, out bool isCurrentlyHidden))
{
//...and it was hidden, but it's not hidden in this template in the group,
// remove its hiding, otherwise leave it as is
if (isCurrentlyHidden && !parametersToExplicitlyHide.Contains(parameter.Name))
{
parameterHidingDisposition[parameter.Name] = false;
}
}
else
{
//...otherwise, since this is the first time the parameter has been seen,
// its hiding state should be used as the current disposition
parameterHidingDisposition[parameter.Name] = parametersToExplicitlyHide.Contains(parameter.Name);
}
}
if (firstInList)
{
invalidParametersForGroup = usageInformation.InvalidParameters.ToDictionary(x => x.Canonical, x => x);
firstInList = false;
}
else
{
invalidParametersForGroup = InvalidParameterInfo.IntersectWithExisting(invalidParametersForGroup, usageInformation.InvalidParameters);
}
groupUserParamsWithInvalidValues.IntersectWith(usageInformation.UserParametersWithInvalidValues); // intersect because if the value is valid for any version, it's valid.
groupHasPostActionScriptRunner |= usageInformation.HasPostActionScriptRunner;
parameterSetsForAllTemplatesInGroup.Add(usageInformation.AllParameters);
// If this template has name overrides (either long or short), it's opinionated.
// If it's the first opinionated template about the param, use its variants.
// Else this template is not opinionated, note its values if there aren't defaults for the param already.
// At the end, anything in the default list that isn't in the opinionated list will get merged in.
// TODO: write tests for this code (and the rest of this method while we're at it)
foreach (KeyValuePair <string, IReadOnlyList <string> > canonicalAndVariants in usageInformation.VariantsForCanonicals)
{
if (hostSpecificTemplateData.LongNameOverrides.ContainsKey(canonicalAndVariants.Key) || hostSpecificTemplateData.ShortNameOverrides.ContainsKey(canonicalAndVariants.Key))
{
// this template is opinionated about this parameter. If no previous template is opinionated about this param, use this template's variants.
if (!groupVariantsForCanonicals.ContainsKey(canonicalAndVariants.Key))
{
groupVariantsForCanonicals[canonicalAndVariants.Key] = canonicalAndVariants.Value;
}
}
else
{
// this template is not opinionated about this parameter. If no previous template had defaults for this param, use this template's defaults.
if (!defaultVariantsForCanonicals.ContainsKey(canonicalAndVariants.Key))
{
defaultVariantsForCanonicals[canonicalAndVariants.Key] = canonicalAndVariants.Value;
}
}
}
// If any template says the user input value is the default, include it here.
groupUserParamsWithDefaultValues.UnionWith(usageInformation.UserParametersWithDefaultValues);
parametersToAlwaysShow.UnionWith(hostSpecificTemplateData.ParametersToAlwaysShow);
}
// aggregate the parameter variants
foreach (KeyValuePair <string, IReadOnlyList <string> > defaultVariants in defaultVariantsForCanonicals)
{
if (!groupVariantsForCanonicals.ContainsKey(defaultVariants.Key))
{
// there were no opinionated variants, take the preferred default.
groupVariantsForCanonicals[defaultVariants.Key] = defaultVariants.Value;
}
}
IParameterSet allGroupParameters = new TemplateGroupParameterSet(parameterSetsForAllTemplatesInGroup);
string parameterErrors = InvalidParameterInfo.InvalidParameterListToString(invalidParametersForGroup.Values.ToList());
HashSet <string> parametersToHide = new HashSet <string>(parameterHidingDisposition.Where(x => x.Value).Select(x => x.Key), StringComparer.Ordinal);
return(new TemplateGroupParameterDetails
{
AllParams = allGroupParameters,
AdditionalInfo = parameterErrors,
InvalidParams = groupUserParamsWithInvalidValues.ToList(),
ExplicitlyHiddenParams = parametersToHide,
GroupVariantsForCanonicals = groupVariantsForCanonicals,
GroupUserParamsWithDefaultValues = groupUserParamsWithDefaultValues,
HasPostActionScriptRunner = groupHasPostActionScriptRunner,
ParametersToAlwaysShow = parametersToAlwaysShow,
});
}
public static void ShowTemplateGroupHelp(IReadOnlyList <ITemplateMatchInfo> templateGroup, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator, bool showImplicitlyHiddenParams = false)
{
if (templateGroup.Count == 0 || !TemplateListResolver.AreAllTemplatesSameGroupIdentity(templateGroup))
{
return;
}
IReadOnlyList <ITemplateInfo> templateInfoList = templateGroup.Select(x => x.Info).ToList();
ShowTemplateDetailHeaders(templateInfoList);
TemplateGroupParameterDetails groupParameterDetails = DetermineParameterDispositionsForTemplateGroup(templateInfoList, environmentSettings, commandInput, hostDataLoader, templateCreator);
// get the input params valid for any param in the group
IReadOnlyDictionary <string, string> inputTemplateParams = CoalesceInputParameterValuesFromTemplateGroup(templateGroup);
ShowParameterHelp(inputTemplateParams, showImplicitlyHiddenParams, groupParameterDetails, environmentSettings);
}
private static bool CheckIfTemplateHasScriptRunningPostActions(ITemplate template, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, TemplateCreator templateCreator)
{
// use a throwaway set of params for getting the creation effects - it makes changes to them.
string targetDir = commandInput.OutputPath ?? environmentSettings.Host.FileSystem.GetCurrentDirectory();
IParameterSet paramsForCreationEffects = templateCreator.SetupDefaultParamValuesFromTemplateAndHost(template, template.DefaultName ?? "testName", out IReadOnlyList <string> throwaway);
templateCreator.ResolveUserParameters(template, paramsForCreationEffects, commandInput.InputTemplateParams, out IReadOnlyList <string> userParamsWithInvalidValues);
ICreationEffects creationEffects = template.Generator.GetCreationEffects(environmentSettings, template, paramsForCreationEffects, environmentSettings.SettingsLoader.Components, targetDir);
return(creationEffects.CreationResult.PostActions.Any(x => x.ActionId == ProcessStartPostActionProcessor.ActionProcessorId));
}
