public static TypinException DirectiveExecutedInInvalidMode(DirectiveSchema directive, Type currentMode)
{
StringBuilder builder = new();
builder.AppendLine($"This application is running in '{currentMode}' mode.");
if (directive.SupportedModes is not null)
{
builder.AppendLine();
builder.AppendLine($"Directive '{directive.Type.FullName}' supports modes:");
foreach (Type mode in directive.SupportedModes)
{
builder.AppendLine($" - '{mode.FullName}'");
}
}
if (directive.ExcludedModes is not null)
{
builder.AppendLine();
builder.AppendLine($"Directive '{directive.Type.FullName}' cannot run in modes:");
foreach (Type mode in directive.ExcludedModes)
{
builder.AppendLine($" - '{mode.FullName}'");
}
}
return(new TypinException(builder.ToString()));
}
private void ResolveDirectives(IReadOnlyList <Type> directiveTypes)
{
var directives = new Dictionary <string, DirectiveSchema>();
var invalidDirectives = new List <DirectiveSchema>();
foreach (Type?directiveType in directiveTypes)
{
DirectiveSchema directive = DirectiveSchemaResolver.Resolve(directiveType);
if (!directives.TryAdd(directive.Name, directive))
{
invalidDirectives.Add(directive);
}
}
if (invalidDirectives.Count > 0)
{
IGrouping <string, DirectiveSchema>?duplicateNameGroup = invalidDirectives.Union(directives.Values)
.GroupBy(c => c.Name, StringComparer.OrdinalIgnoreCase)
.FirstOrDefault();
throw InternalTypinExceptions.DirectiveWithSameName(duplicateNameGroup.Key, duplicateNameGroup.ToArray());
}
Directives = directives;
}
private async Task <bool> ProcessDefinedDirectives(ICliContext context)
{
bool isInteractiveMode = context.IsInteractiveMode;
IReadOnlyList <DirectiveInput> directives = context.Input.Directives;
foreach (DirectiveInput directiveInput in directives)
{
// Try to get the directive matching the input or fallback to default
DirectiveSchema directive = context.RootSchema.TryFindDirective(directiveInput.Name) ?? throw EndUserTypinExceptions.UnknownDirectiveName(directiveInput);
if (!isInteractiveMode && directive.InteractiveModeOnly)
{
throw EndUserTypinExceptions.InteractiveModeDirectiveNotAvailable(directiveInput.Name);
}
// Get directive instance
IDirective instance = (IDirective)_serviceProvider.GetRequiredService(directive.Type);
await instance.HandleAsync(context.Console);
if (!instance.ContinueExecution)
{
return(false);
}
}
return(true);
}
private void ResolveDirectives(IReadOnlyList <Type> directiveTypes)
{
Dictionary <string, DirectiveSchema> directives = new();
List <DirectiveSchema> invalidDirectives = new();
foreach (Type?directiveType in directiveTypes)
{
DirectiveSchema directive = DirectiveSchemaResolver.Resolve(directiveType, _modeTypes);
if (!directives.TryAdd(directive.Name, directive))
{
invalidDirectives.Add(directive);
}
}
if (invalidDirectives.Count > 0)
{
IGrouping <string, DirectiveSchema> duplicateNameGroup = invalidDirectives.Union(directives.Values)
.GroupBy(c => c.Name, StringComparer.Ordinal)
.First();
throw DirectiveResolverExceptions.DirectiveWithSameName(duplicateNameGroup.Key, duplicateNameGroup.ToArray());
}
Directives = directives;
}
private void WriteDirectiveDescription(DirectiveSchema directive)
{
if (string.IsNullOrWhiteSpace(directive.Description))
{
return;
}
WriteColumnMargin();
Write(directive.Description);
}
public async Task HandleAsync(ICliContext context, CommandPipelineHandlerDelegate next, CancellationToken cancellationToken)
{
//Get current CLI mode and input directives
Type currentModeType = _applicationLifetime.CurrentModeType !;
IReadOnlyList <DirectiveInput> directives = context.Input.Directives;
//Initialize collections
List <IDirective> directivesInstances = new List <IDirective>();
List <IPipelinedDirective> pipelinedDirectivesInstances = new List <IPipelinedDirective>();
//Process directive input
foreach (DirectiveInput directiveInput in directives)
{
// Try to get the directive matching the input or fallback to default
DirectiveSchema directive = context.RootSchema.TryFindDirective(directiveInput.Name) ?? throw ArgumentBindingExceptions.UnknownDirectiveName(directiveInput);
// Handle interactive directives not supported in current mode
if (!directive.CanBeExecutedInMode(currentModeType))
{
throw ModeEndUserExceptions.DirectiveExecutedInInvalidMode(directive, currentModeType);
}
// Get directive instance
IDirective instance = (IDirective)_serviceProvider.GetRequiredService(directive.Type);
//Initialize directive
await instance.OnInitializedAsync(cancellationToken);
//Add directive to list
directivesInstances.Add(instance);
if (directive.IsPipelinedDirective && instance is IPipelinedDirective pd)
{
pipelinedDirectivesInstances.Add(pd);
}
}
//Set directives lists in context
CliContext internalCliContext = (CliContext)context;
internalCliContext.Directives = directivesInstances;
internalCliContext.PipelinedDirectives = pipelinedDirectivesInstances;
await next();
}
/// <summary>
/// Resolves <see cref="DirectiveSchema"/>.
/// </summary>
public static DirectiveSchema Resolve(Type type)
{
if (!DirectiveSchema.IsDirectiveType(type))
{
throw InternalTypinExceptions.InvalidDirectiveType(type);
}
DirectiveAttribute attribute = type.GetCustomAttribute <DirectiveAttribute>() !;
string name = attribute.Name.TrimStart('[').TrimEnd(']');
if (string.IsNullOrWhiteSpace(name))
{
throw InternalTypinExceptions.DirectiveNameIsInvalid(name, type);
}
return(new DirectiveSchema(
type,
name,
attribute.Description,
attribute.InteractiveModeOnly
));
}
private void WriteDirectivesManual(IReadOnlyDictionary <string, DirectiveSchema> directives)
{
if (directives.Count == 0)
{
return;
}
if (!IsEmpty)
{
WriteVerticalMargin();
}
WriteHeader("Directives");
foreach (KeyValuePair <string, DirectiveSchema> directive in directives.OrderBy(x => x.Value.Name))
{
DirectiveSchema schema = directive.Value;
// Name
if (schema.HasModeRestrictions())
{
Write(ModeRestrictedColor, "@");
WriteHorizontalMargin(1);
}
else
{
WriteHorizontalMargin();
}
Write(DirectiveNameColor, "[");
Write(DirectiveNameColor, directive.Key);
Write(DirectiveNameColor, "]");
WriteDirectiveDescription(schema);
WriteLine();
}
}
