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)); }