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));
}
}
public TemplateInvocationAndAcquisitionCoordinator(SettingsLoader settingsLoader, INewCommandInput commandInput, TemplateCreator templateCreator, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, string defaultLanguage, string commandName, Func <string> inputGetter, New3Callbacks callbacks)
{
_settingsLoader = settingsLoader;
_environment = _settingsLoader.EnvironmentSettings;
_commandInput = commandInput;
_templateCreator = templateCreator;
_hostDataLoader = hostDataLoader;
_telemetryLogger = telemetryLogger;
_defaultLanguage = defaultLanguage;
_commandName = commandName;
_inputGetter = inputGetter;
_callbacks = callbacks;
}
private static CreationResultStatus DisplayHelpForAmbiguousTemplateGroup(TemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, string defaultLanguage)
{
if (!string.IsNullOrEmpty(commandInput.TemplateName) &&
templateResolutionResult.GetBestTemplateMatchList(true).Count > 0 &&
templateResolutionResult.GetBestTemplateMatchList(true).All(x => x.MatchDisposition.Any(d => d.Location == MatchLocation.Language && d.Kind == MatchKind.Mismatch)))
{
string errorMessage = GetLanguageMismatchErrorMessage(commandInput);
Reporter.Error.WriteLine(errorMessage.Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.RunHelpForInformationAboutAcceptedParameters, $"{commandInput.CommandName} {commandInput.TemplateName}").Bold().Red());
return(CreationResultStatus.NotFound);
}
// The following occurs when:
// --alias <value> is specifed
// --help is specified
// template (group) can't be resolved
if (!string.IsNullOrWhiteSpace(commandInput.Alias))
{
Reporter.Error.WriteLine(LocalizableStrings.InvalidInputSwitch.Bold().Red());
Reporter.Error.WriteLine(" " + commandInput.TemplateParamInputFormat("--alias").Bold().Red());
return(CreationResultStatus.NotFound);
}
bool hasInvalidParameters = false;
IReadOnlyList <ITemplateMatchInfo> templatesForDisplay = templateResolutionResult.GetBestTemplateMatchList(true);
GetParametersInvalidForTemplatesInList(templatesForDisplay, out IReadOnlyList <string> invalidForAllTemplates, out IReadOnlyList <string> invalidForSomeTemplates);
if (invalidForAllTemplates.Any() || invalidForSomeTemplates.Any())
{
hasInvalidParameters = true;
DisplayInvalidParameters(invalidForAllTemplates);
DisplayParametersInvalidForSomeTemplates(invalidForSomeTemplates, LocalizableStrings.PartialTemplateMatchSwitchesNotValidForAllMatches);
}
ShowContextAndTemplateNameMismatchHelp(templateResolutionResult, commandInput.TemplateName, commandInput.TypeFilter);
DisplayTemplateList(templatesForDisplay, environmentSettings, commandInput.Language, defaultLanguage);
if (!commandInput.IsListFlagSpecified)
{
TemplateUsageHelp.ShowInvocationExamples(templateResolutionResult, hostDataLoader, commandInput.CommandName);
}
if (hasInvalidParameters)
{
return(CreationResultStatus.NotFound);
}
else if (commandInput.IsListFlagSpecified || commandInput.IsHelpFlagSpecified)
{
return(!templateResolutionResult.IsNoTemplatesMatchedState ? CreationResultStatus.Success : CreationResultStatus.NotFound);
}
else
{
return(CreationResultStatus.OperationNotSpecified);
}
}
private static CreationResultStatus DisplayHelpForUnambiguousTemplateGroup(ListOrHelpTemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator, ITelemetryLogger telemetryLogger, string defaultLanguage)
{
// sanity check: should never happen; as condition for unambiguous template group is checked above
if (!templateResolutionResult.UnambiguousTemplateGroup.Any())
{
return(DisplayListOrHelpForAmbiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, telemetryLogger, defaultLanguage));
}
//if language is specified and all templates in unambigiuos group match the language show the help for that template
if (templateResolutionResult.AllTemplatesInUnambiguousTemplateGroupAreSameLanguage)
{
IReadOnlyCollection <ITemplateMatchInfo> unambiguousTemplateGroupForDetailDisplay = templateResolutionResult.UnambiguousTemplateGroup;
return(TemplateDetailedHelpForSingularTemplateGroup(unambiguousTemplateGroupForDetailDisplay, environmentSettings, commandInput, hostDataLoader, templateCreator));
}
//if language is not specified and group has template that matches the language show the help for that the template that matches the language
if (string.IsNullOrEmpty(commandInput.Language) && !string.IsNullOrEmpty(defaultLanguage) && templateResolutionResult.HasUnambiguousTemplateGroupForDefaultLanguage)
{
IReadOnlyCollection <ITemplateMatchInfo> unambiguousTemplateGroupForDetailDisplay = templateResolutionResult.UnambiguousTemplatesForDefaultLanguage;
return(TemplateDetailedHelpForSingularTemplateGroup(unambiguousTemplateGroupForDetailDisplay, environmentSettings, commandInput, hostDataLoader, templateCreator));
}
else
{
return(DisplayListOrHelpForAmbiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, telemetryLogger, defaultLanguage));
}
}
private static CreationResultStatus TemplateDetailedHelpForSingularTemplateGroup(IReadOnlyCollection <ITemplateMatchInfo> unambiguousTemplateGroup, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, TemplateCreator templateCreator)
{
// sanity check: should never happen; as condition for unambiguous template group is checked above
if (!unambiguousTemplateGroup.Any())
{
return(CreationResultStatus.NotFound);
}
// (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);
}
if (invalidForAllTemplates.Count == 0)
{
bool showImplicitlyHiddenParams = unambiguousTemplateGroup.Count > 1;
TemplateDetailsDisplay.ShowTemplateGroupHelp(unambiguousTemplateGroup, environmentSettings, commandInput, hostDataLoader, templateCreator, showImplicitlyHiddenParams);
}
else
{
Reporter.Error.WriteLine(
string.Format(LocalizableStrings.InvalidParameterTemplateHint, GetTemplateHelpCommand(commandInput.CommandName, unambiguousTemplateGroup.First().Info)).Bold().Red());
}
return(invalidForAllTemplates.Count > 0 || invalidForSomeTemplates.Count > 0
? CreationResultStatus.InvalidParamValues
: CreationResultStatus.Success);
}
private static CreationResultStatus DisplayListOrHelpForAmbiguousTemplateGroup(ListOrHelpTemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, string defaultLanguage)
{
// The following occurs when:
// --alias <value> is specifed
// --help is specified
// template (group) can't be resolved
if (!string.IsNullOrWhiteSpace(commandInput.Alias))
{
Reporter.Error.WriteLine(LocalizableStrings.InvalidInputSwitch.Bold().Red());
Reporter.Error.WriteLine(" " + commandInput.TemplateParamInputFormat("--alias").Bold().Red());
return(CreationResultStatus.NotFound);
}
bool hasInvalidParameters = false;
IReadOnlyCollection <ITemplateMatchInfo> templatesForDisplay = templateResolutionResult.ExactMatchedTemplates;
GetParametersInvalidForTemplatesInList(templatesForDisplay, out IReadOnlyList <string> invalidForAllTemplates, out IReadOnlyList <string> invalidForSomeTemplates);
if (invalidForAllTemplates.Any() || invalidForSomeTemplates.Any())
{
hasInvalidParameters = true;
DisplayInvalidParameters(invalidForAllTemplates);
DisplayParametersInvalidForSomeTemplates(invalidForSomeTemplates, LocalizableStrings.PartialTemplateMatchSwitchesNotValidForAllMatches);
}
if (templateResolutionResult.HasExactMatches)
{
IReadOnlyCollection <IGrouping <string, ITemplateMatchInfo> > groupedTemplatesForDisplay = templateResolutionResult.ExactMatchedTemplatesGrouped;
ShowTemplatesFoundMessage(commandInput.TemplateName, commandInput.Language, commandInput.TypeFilter, commandInput.BaselineName);
DisplayTemplateList(groupedTemplatesForDisplay, environmentSettings, commandInput.Language, defaultLanguage);
}
else
{
ShowContextAndTemplateNameMismatchHelp(templateResolutionResult, commandInput.TemplateName, commandInput.Language, commandInput.TypeFilter, commandInput.BaselineName);
}
if (!commandInput.IsListFlagSpecified)
{
TemplateUsageHelp.ShowInvocationExamples(templateResolutionResult, hostDataLoader, commandInput.CommandName);
}
if (hasInvalidParameters)
{
return(CreationResultStatus.NotFound);
}
else if (commandInput.IsListFlagSpecified || commandInput.IsHelpFlagSpecified)
{
return(templateResolutionResult.HasExactMatches ? CreationResultStatus.Success : CreationResultStatus.NotFound);
}
else
{
return(CreationResultStatus.OperationNotSpecified);
}
}
public static CreationResultStatus CoordinateHelpAndUsageDisplay(ListOrHelpTemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, TemplateCreator templateCreator, string defaultLanguage, bool showUsageHelp = true)
{
if (showUsageHelp)
{
ShowUsageHelp(commandInput, telemetryLogger);
}
//in case only --help option is specified we don't need to show templates list
if (commandInput.IsHelpFlagSpecified && string.IsNullOrEmpty(commandInput.TemplateName))
{
return(CreationResultStatus.Success);
}
// in case list is specified we always need to list templates
if (commandInput.IsListFlagSpecified)
{
return(DisplayListOrHelpForAmbiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, telemetryLogger, defaultLanguage));
}
else // help flag specified or no flag specified
{
if (!string.IsNullOrEmpty(commandInput.TemplateName) &&
templateResolutionResult.HasUnambiguousTemplateGroup)
{
// This will show detailed help on the template group, which only makes sense if there is a single template group adn all templates are the same language.
return(DisplayHelpForUnambiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, templateCreator, telemetryLogger, defaultLanguage));
}
else
{
return(DisplayListOrHelpForAmbiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, telemetryLogger, defaultLanguage));
}
}
}
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>();
}
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));
}
}
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);
}
// adds dispositions to the templates based on matches between the input parameters & the template parameters.
private static void AddParameterMatchingToTemplates(IReadOnlyList <ITemplateMatchInfo> templatesToFilter, IHostSpecificDataLoader hostDataLoader, INewCommandInput commandInput)
{
foreach (ITemplateMatchInfo template in templatesToFilter)
{
try
{
ParseTemplateArgs(template.Info, hostDataLoader, commandInput);
// params are already parsed. But choice values aren't checked
foreach (KeyValuePair <string, string> matchedParamInfo in commandInput.InputTemplateParams)
{
string paramName = matchedParamInfo.Key;
string paramValue = matchedParamInfo.Value;
if (template.Info.Tags.TryGetValue(paramName, out ICacheTag paramDetails))
{
// key is the value user should provide, value is description
if (string.IsNullOrEmpty(paramValue))
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.InvalidParameterValue, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
else if (paramDetails.ChoicesAndDescriptions.ContainsKey(paramValue))
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.Exact, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
else
{
int startsWithCount = paramDetails.ChoicesAndDescriptions.Count(x => x.Key.StartsWith(paramValue, StringComparison.OrdinalIgnoreCase));
if (startsWithCount == 1)
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.SingleStartsWith, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
else if (startsWithCount > 1)
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.AmbiguousParameterValue, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
else
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.InvalidParameterValue, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
}
}
else if (template.Info.CacheParameters.ContainsKey(paramName))
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.Exact, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
else
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.InvalidParameterValue, ChoiceIfLocationIsOtherChoice = paramName, ParameterValue = paramValue
});
}
}
foreach (string unmatchedParamName in commandInput.RemainingParameters.Keys.Where(x => !x.Contains(':'))) // filter debugging params
{
if (commandInput.TryGetCanonicalNameForVariant(unmatchedParamName, out string canonical))
{
// the name is a known template param, it must have not parsed due to an invalid value
// Note (scp 2017-02-27): This probably can't happen, the param parsing doesn't check the choice values.
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.InvalidParameterValue, ChoiceIfLocationIsOtherChoice = unmatchedParamName
});
}
else
{
// the name is not known
// TODO: reconsider storing the canonical in this situation. It's not really a canonical since the param is unknown.
template.AddDisposition(new MatchInfo {
Location = MatchLocation.OtherParameter, Kind = MatchKind.InvalidParameterName, ChoiceIfLocationIsOtherChoice = unmatchedParamName
});
}
}
}
catch (CommandParserException ex)
{
// if we do actually throw, add a non-match
template.AddDisposition(new MatchInfo {
Location = MatchLocation.Unspecified, Kind = MatchKind.Unspecified, AdditionalInformation = ex.Message
});
}
catch (Exception ex)
{
template.AddDisposition(new MatchInfo {
Location = MatchLocation.Unspecified, Kind = MatchKind.Unspecified, AdditionalInformation = $"Unexpected error: {ex.Message}"
});
}
}
}
private static bool IsTemplateHiddenByHostFile(ITemplateInfo templateInfo, IHostSpecificDataLoader hostDataLoader)
{
HostSpecificTemplateData hostData = hostDataLoader.ReadHostSpecificTemplateData(templateInfo);
return(hostData.IsHidden);
}
public static void ParseTemplateArgs(ITemplateInfo templateInfo, IHostSpecificDataLoader hostDataLoader, INewCommandInput commandInput)
{
HostSpecificTemplateData hostData = hostDataLoader.ReadHostSpecificTemplateData(templateInfo);
commandInput.ReparseForTemplate(templateInfo, hostData);
}
// Query for template matches, filtered by everything available: name, language, context, parameters, and the host file.
public static IReadOnlyCollection <ITemplateMatchInfo> PerformCoreTemplateQuery(IReadOnlyList <ITemplateInfo> templateInfo, IHostSpecificDataLoader hostDataLoader, INewCommandInput commandInput, string defaultLanguage)
{
IReadOnlyCollection <ITemplateMatchInfo> templates = TemplateListFilter.GetTemplateMatchInfo
(
templateInfo,
TemplateListFilter.PartialMatchFilter,
WellKnownSearchFilters.NameFilter(commandInput.TemplateName),
WellKnownSearchFilters.ClassificationsFilter(commandInput.TemplateName),
WellKnownSearchFilters.LanguageFilter(commandInput.Language),
WellKnownSearchFilters.ContextFilter(commandInput.TypeFilter),
WellKnownSearchFilters.BaselineFilter(commandInput.BaselineName)
)
.Where(x => !IsTemplateHiddenByHostFile(x.Info, hostDataLoader)).ToList();
IReadOnlyList <ITemplateMatchInfo> coreMatchedTemplates = templates.Where(x => x.IsMatch).ToList();
if (coreMatchedTemplates.Count == 0)
{
// No exact matches, take the partial matches and be done.
coreMatchedTemplates = templates.Where(x => x.IsPartialMatch).ToList();
}
else
{
IReadOnlyList <ITemplateMatchInfo> matchesWithExactDispositionsInNameFields = coreMatchedTemplates.Where(x => x.MatchDisposition.Any(y => NameFields.Contains(y.Location) && y.Kind == MatchKind.Exact)).ToList();
if (matchesWithExactDispositionsInNameFields.Count > 0)
{
// Start with the exact name matches, if there are any.
coreMatchedTemplates = matchesWithExactDispositionsInNameFields;
}
}
if (string.IsNullOrEmpty(commandInput.Language) && !string.IsNullOrEmpty(defaultLanguage))
{
// default language matching only makes sense if the user didn't specify a language.
AddDefaultLanguageMatchingToTemplates(coreMatchedTemplates, defaultLanguage);
}
AddParameterMatchingToTemplates(coreMatchedTemplates, hostDataLoader, commandInput);
return(coreMatchedTemplates);
}
public static TemplateListResolutionResult GetTemplateResolutionResult(IReadOnlyList <ITemplateInfo> templateInfo, IHostSpecificDataLoader hostDataLoader, INewCommandInput commandInput, string defaultLanguage)
{
IReadOnlyCollection <ITemplateMatchInfo> coreMatchedTemplates = PerformCoreTemplateQuery(templateInfo, hostDataLoader, commandInput, defaultLanguage);
IReadOnlyCollection <ITemplateMatchInfo> allTemplatesInContext = PerformAllTemplatesInContextQuery(templateInfo, hostDataLoader, commandInput.TypeFilter);
return(new TemplateListResolutionResult(commandInput.TemplateName, commandInput.Language, coreMatchedTemplates, allTemplatesInContext));
}
// Lists all the templates, filtered only by the context (item, project, etc) - and the host file.
public static IReadOnlyCollection <ITemplateMatchInfo> PerformAllTemplatesInContextQuery(IReadOnlyList <ITemplateInfo> templateInfo, IHostSpecificDataLoader hostDataLoader, string context)
{
// If there is a context match, it must be exact. Other dispositions are irrelevant.
Func <ITemplateMatchInfo, bool> contextFilter = x => x.MatchDisposition.All(d => d.Location != MatchLocation.Context || d.Kind == MatchKind.Exact);
IReadOnlyCollection <ITemplateMatchInfo> templates = TemplateListFilter.GetTemplateMatchInfo
(
templateInfo,
contextFilter,
WellKnownSearchFilters.ContextFilter(context),
WellKnownSearchFilters.NameFilter(string.Empty)
)
.Where(x => !IsTemplateHiddenByHostFile(x.Info, hostDataLoader)).ToList();
return(templates);
}
// Lists all the templates, unfiltered - except the ones hidden by their host file.
public static IReadOnlyCollection <ITemplateMatchInfo> PerformAllTemplatesQuery(IReadOnlyList <ITemplateInfo> templateInfo, IHostSpecificDataLoader hostDataLoader)
{
IReadOnlyCollection <ITemplateMatchInfo> templates = TemplateListFilter.GetTemplateMatchInfo
(
templateInfo,
TemplateListFilter.PartialMatchFilter,
WellKnownSearchFilters.NameFilter(string.Empty)
)
.Where(x => !IsTemplateHiddenByHostFile(x.Info, hostDataLoader)).ToList();
return(templates);
}