private void RegisterContainerCommands(CommandsContainer container)
{
BindingFlags validMethodsFlags = BindingFlags.Public | BindingFlags.Instance;
var commandClassType = container.GetType();
var methodsWithCommandAttribute = commandClassType.GetMethods(validMethodsFlags)
.Where(method => method.GetCustomAttribute <ConsoleCommandAttribute>() != null);
var validCommandMethods = methodsWithCommandAttribute.Where(method =>
method.GetParameters().All(param =>
param.ParameterType.IsPrimitive || param.ParameterType == typeof(string)));
int validCommands = 0;
foreach (var validCommand in validCommandMethods)
{
ConsoleCommand consoleCommand = new ConsoleCommand(container, validCommand);
if (ProcessCommand(consoleCommand))
{
validCommands++;
}
}
string name = container.GetType().Name.Replace("Container", "");
m_console.AddEntryToLog($"Registered {validCommands} commands for container {name}.", ConsoleEntryType.ConsoleMessage);
}
private void SetDocumentCommands()
{
CommandsContainer.Refresh();
CommandsContainer.Add(new TableOfContentsPageCommand(WordDocument, renderData));
CommandsContainer.Add(new ItemsCommand(WordDocument, renderData));
}
public ConsoleCommand(CommandsContainer instance, MethodInfo commandMethod)
{
ConsoleCommandAttribute attribute = commandMethod.GetCustomAttribute <ConsoleCommandAttribute>();
Id = attribute.Id;
Description = attribute.Description;
CommandMethod = commandMethod;
Instance = instance;
}
public void CommandsContainer_Initialize_Test()
{
// Arrange
// Act
var container = new CommandsContainer();
// Assert
Assert.NotNull(container);
}
public void CommandsContainer_GetCommandThrowsException_Test()
{
// Arrange
var container = new CommandsContainer();
var commandId = "aNonRegisteredCommand";
// Act
var e = Assert.Throws <CommandNotRegisteredException>(() => container.GetCommand(commandId));
// Assert
Assert.Equal(commandId, e.CommandId);
}
public void CommandsContainer_CanRegister_Test()
{
// Arrange
var container = new CommandsContainer();
var command = new NumericCommand(1, "Test Command 1", () => { });
// Act
var canRegister = container.CanRegister(command);
// Assert
Assert.True(canRegister);
}
private static async Task GetUpdatesManually(IHost host)
{
using (var scope = host.Services.CreateScope())
{
var provider = scope.ServiceProvider;
CommandsContainer commandsContainer = provider.GetService <CommandsContainer>();
var controller = new MessageController(commandsContainer, provider);
var config = provider.GetService <IConfiguration>();
string token = config.GetValue <string>("Token");
TelegramBotClient client = new TelegramBotClient(token);
await client.DeleteWebhookAsync();
var initialUpdates = await client.GetUpdatesAsync();
var lastUpdate = initialUpdates.LastOrDefault();
int lastUpdateId = lastUpdate?.Id ?? 0;
var logger = provider.GetRequiredService <ILogger <Program> >();
while (true)
{
try
{
var updates = await client.GetUpdatesAsync(offset : lastUpdateId + 1);
foreach (var update in updates)
{
try
{
await controller.Update(update);
logger.LogInformation("Send message in responce to update");
}
catch (Exception exc)
{
logger.LogError(exc, "Something went wrong while sending reply");
}
lastUpdateId = update.Id;
}
await Task.Delay(1000);
}
catch (Exception exc)
{
logger.LogError(exc, "Something went wrong while receiving updates");
}
}
}
}
private static void Run()
{
InitializeOptions();
var form = new MainForm();
form.FilesView.DirectoryImage = Resources.Folder;
var environmentHelper = new EnvironmentHelper();
var messageHelper = new MessageHelper(options);
var formFactory = new FormFactory(options);
var commandsContainer = new CommandsContainer(options, form, environmentHelper, messageHelper, formFactory);
commandsContainer.SetMainForm(form);
new MainFormPresenter(form, options, environmentHelper, commandsContainer, messageHelper, formFactory);
Application.Run(form);
}
public void CommandsContainer_AddSystemCommand_Test()
{
// Arrange
var container = new CommandsContainer();
var command = new SystemCommand("Join", "TestCommand One", () => { });
// Act
container.Add(command);
// Assert
Assert.Contains(command, container.AllCommands);
Assert.DoesNotContain(command as Command, container.StringCommands);
Assert.DoesNotContain(command as Command, container.NumericCommands);
Assert.Contains(command as Command, container.SystemCommands);
}
public void CommandsContainer_GetCommand_Test()
{
// Arrange
var container = new CommandsContainer();
container.Add(new StringCommand("a", "TestCommand A", () => { }));
container.Add(new NumericCommand(1, "TestCommand 1", () => { }));
// Act
var commandA = container.GetCommand("a");
var command1 = container.GetCommand(1.ToString());
// Assert
Assert.NotNull(commandA);
Assert.NotNull(command1);
}
public void CommandsContainer_CanNotRegister_Test()
{
// Arrange
var container = new CommandsContainer();
var command = new StringCommand("One", "Test Command 1", () => { });
// Act
var canRegister1 = container.CanRegister(command);
container.Add(command);
var canRegister2 = container.CanRegister(command);
// Assert
Assert.True(canRegister1);
Assert.False(canRegister2);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandsPresenter"/> class.
/// </summary>
/// <param name="servicesProvider">
/// The services Provider.
/// </param>
/// <param name="window">
/// The window.
/// </param>
public CommandsPresenter(IAppServiceProvider servicesProvider, ICommandsInfoWindow window)
{
this.window = window;
this.servicesProvider = servicesProvider;
this.dispatcher = servicesProvider.GetService <Dispatcher>();
this.commandScopeService = servicesProvider.GetService <ICommandScopeService>();
this.listenerService = servicesProvider.GetService <IKeyboardListenerService>();
this.packageSettings = servicesProvider.GetService <IPackageSettings>();
this.packageSettings.SettingsChanged += this.PackageSettingsOnSettingsChanged;
this.PackageSettingsOnSettingsChanged(this, EventArgs.Empty);
this.commandInfos = new CommandInfosLoader(this.servicesProvider).LoadCommands();
this.listenerService.KeyDown += this.ListenerServiceOnKeyDown;
this.listenerService.KeyUp += this.ListenerServiceOnKeyUp;
}
public async Task <byte[]> Render()
{
return(await Task.Run(() =>
{
var ms = new MemoryStream();
using (WordDocument = WordprocessingDocument.Create(ms, WordprocessingDocumentType.Document))
{
WordDocument.AddMainDocumentPart();
WordDocument.MainDocumentPart.Document = new WordDocument
{
Body = new Body()
};
SetDocumentCommands();
CommandsContainer.Render();
}
return ms.ToArray();
}));
}
private void SetFooterAndHeaderCommands()
{
CommandsContainer.Refresh();
}
public WordRenderer()
{
CommandsContainer = new CommandsContainer();
}
public MessageController(CommandsContainer container, IServiceProvider provider)
{
this._container = container;
this._provider = provider;
}
public static void RegisterContainer(CommandsContainer commandsContainer)
{
s_registeredContainers.Enqueue(commandsContainer);
OnCommandRegistered?.Invoke(commandsContainer);
}
