public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
bool handled = false;
int hresult = VSConstants.S_OK;
var commandKey = new DeveroomEditorCommandTargetKey(pguidCmdGroup, nCmdID);
if (!CommandRegistry.TryGetValue(commandKey, out var commands))
{
return(Next.Exec(commandKey.CommandGroup, commandKey.CommandId, nCmdexecopt, pvaIn, pvaOut));
}
// Pre-process
foreach (var editorCommand in commands)
{
handled = editorCommand.PreExec(TextView, commandKey, pvaIn);
if (handled)
{
break;
}
}
if (!handled)
{
hresult = Next.Exec(commandKey.CommandGroup, commandKey.CommandId, nCmdexecopt, pvaIn, pvaOut);
}
// Post-process
foreach (var editorCommand in commands)
{
editorCommand.PostExec(TextView, commandKey, pvaIn);
}
return(hresult);
}
public void WhenNoAsyncHandlerRegistereded_ThenInvokesOnThreadPoolAndPersistsToStore()
{
var command = new FooCommand {
Id = 5
};
var handler = new Mock <ICommandHandler <FooCommand> >();
handler.Setup(x => x.IsAsync).Returns(true);
var handlerCalled = false;
handler.Setup(x => x.Handle(It.IsAny <FooCommand>(), It.IsAny <IDictionary <string, object> >()))
.Callback <FooCommand, IDictionary <string, object> >((c, h) => handlerCalled = true);
var store = new Mock <IMessageStore <IDomainCommand> >();
var bus = new CommandRegistry <IDomainCommand>(store.Object, new[] { handler.Object });
bus.Execute(command);
while (!handlerCalled)
{
System.Threading.Thread.Sleep(10);
}
handler.Verify(x => x.Handle(command, It.IsAny <IDictionary <string, object> >()));
store.Verify(x => x.Save(command, It.IsAny <IDictionary <string, object> >()));
}
public void Startup(ConfigurationLoader loader)
{
m_Commands = loader.CommandRegistry;
m_WebIF = loader.GetAdminWebIF();
m_WebIF.ModuleNames.Add("console");
m_WebIF.JsonMethods.Add("console.command", ConsoleCommand);
}
public UserUseCases()
{
_token = Guid.NewGuid().ToString("N");
_passwordHasher = s => Convert.ToBase64String(MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(s)));
_keyStore = new ReallyInsecureAndVeryTemporaryKeyStore();
_keyStore.CreateKeyIfNotExists("test");
SerializationRegistry serializationRegistry = new SerializationRegistry();
UserBoundedContext.RegisterSerializers(serializationRegistry, _keyStore);
IKnownSerializers serialization = serializationRegistry.Build();
_eventStore = new TestEventStore(serialization);
CommandRegistry commandRegistry = new CommandRegistry();
_lockoutPolicy = () => Clock.Now + TimeSpan.FromMinutes(5);
UserBoundedContext.RegisterCommands(
commandRegistry,
new UserRepository(_eventStore, serialization),
tokenSource: () => _token,
passwordHasher: _passwordHasher,
maxLoginAttempts: 3,
lockoutPolicy: _lockoutPolicy);
_handler = commandRegistry.Build();
_now = DateTimeOffset.UtcNow;
Clock.UtcNowFunc = () => _now;
}
public TestService(ISomneoApiClient somneoApiClient)
{
_commandRegistry = new CommandRegistry();
var commandHandlers = new CommandHandlerBase[]
{
new DeviceCommandHandler(somneoApiClient),
new SensorCommandHandler(somneoApiClient),
new LightCommandHandler(somneoApiClient),
new DisplayCommandHandler(somneoApiClient),
new PlayerCommandHandler(somneoApiClient),
new FMRadioCommandHandler(somneoApiClient),
new WakeUpSoundCommandHandler(somneoApiClient),
new AUXCommandHandler(somneoApiClient),
new AlarmCommandHandler(somneoApiClient)
};
_commandRegistry.RegisterCommand("help", "Show available commands.", ShowHelp);
foreach (var commandHandler in commandHandlers)
{
commandHandler.RegisterCommands(_commandRegistry);
}
_commandRegistry.RegisterCommand("exit", "Exit the application.", args => _canRun = false);
}
/// <summary> Show main menu. </summary>
private static void ShowMainMenu()
{
while (true)
{
if (VersionHandler.TryGetCurrentDatabaseVersion(out double version))
{
ConsoleUtility.Write(Environment.UserName, ConsoleColor.Yellow);
ConsoleUtility.WriteLine("->v" + version, ConsoleColor.Blue);
ConsoleUtility.Write("-> ", TextColor);
string command = ConsoleUtility.ReadLine(TextColor);
string[] args = command.Split(' ');
if (CommandRegistry.ContainCommand(args[0]))
{
CommandRegistry.ExecuteCommand(args[0], args);
}
else
{
ConsoleUtility.WriteLine("Unknown command.", ErrorColor);
}
Console.WriteLine();
}
else
{
ConsoleUtility.WriteLine("Failed to get current database version.", ErrorColor);
Console.ReadKey();
return;
}
}
}
public void Startup(ConfigurationLoader loader)
{
HomeURI = loader.HomeURI;
m_AgentInventoryService = loader.GetService <InventoryServiceInterface>(m_AgentInventoryServiceName);
m_AgentAssetService = loader.GetService <AssetServiceInterface>(m_AgentAssetServiceName);
if (m_AgentProfileServiceName?.Length != 0)
{
m_AgentProfileService = loader.GetService <ProfileServiceInterface>(m_AgentProfileServiceName);
}
m_AgentFriendsService = loader.GetService <FriendsServiceInterface>(m_AgentFriendsServiceName);
m_UserSessionService = loader.GetService <UserSessionServiceInterface>(m_UserSessionServiceName);
m_GridService = loader.GetService <GridServiceInterface>(m_GridServiceName);
if (m_OfflineIMServiceName?.Length != 0)
{
m_OfflineIMService = loader.GetService <OfflineIMServiceInterface>(m_OfflineIMServiceName);
}
if (m_AgentExperienceServiceName?.Length != 0)
{
loader.GetService(m_AgentExperienceServiceName, out m_AgentExperienceService);
}
if (m_AgentGroupsServiceName?.Length != 0)
{
loader.GetService(m_AgentGroupsServiceName, out m_AgentGroupsService);
}
m_UserAccountService = loader.GetService <UserAccountServiceInterface>(m_UserAccountServiceName);
m_AgentUserAgentService = new LocalUserAgentService(m_UserSessionService, m_UserAccountService, m_RequiresInventoryIDAsIMSessionID, HomeURI);
m_Scenes = loader.Scenes;
m_Commands = loader.CommandRegistry;
m_CapsRedirector = loader.CapsRedirector;
m_PacketHandlerPlugins = loader.GetServicesByValue <IProtocolExtender>();
}
public void RegisterTheSameCommandTwice()
{
var registry = new CommandRegistry();
registry.Register(new HelpCommand());
Assert.Throws<ArgumentException>(() => registry.Register(new HelpCommand()));
}
public void FindShouldReturnTheSameCommandJustOnce()
{
var registry = new CommandRegistry();
registry.Register(new HelpCommand());
registry.Register(new HelpCommand(), "hlp");
Assert.AreEqual(1, registry.Find("h").Count);
}
public void RegisterOne()
{
var registry = new CommandRegistry();
registry.Register(new HelpCommand());
Assert.AreEqual(1, registry.Commands.Count);
Assert.IsTrue(registry.Contains("help"));
}
/// <summary>
/// Initialize the core game systems.
/// </summary>
public static void Initialize()
{
Routines = RoutineRunner.GetInstance();
Assets = AssetLoader.GetInstance();
Scenes = SceneLoader.GetInstance();
Commands = CommandRegistry.GetInstance();
}
public void PriorityIsIndependentOfRegistryOrder(bool reverseRegistration)
{
// Arrange
var registry = new CommandRegistry(new Mock <ICommandHandlerExecuter>().Object);
// Act
if (reverseRegistration)
{
registry.Register <SimpleCommandHandlerTwo>(order: 1500);
registry.Register <SimpleCommandHandler>(order: 1000);
}
else
{
registry.Register <SimpleCommandHandler>(order: 1000);
registry.Register <SimpleCommandHandlerTwo>(order: 1500);
}
// Assert
var result = registry.GetPrioritisedCommandHandlers(new SimpleCommand());
Assert.Collection(result, pca =>
{
if (pca.Priority != 1000)
{
throw new Exception("Wrong order");
}
}, pca =>
{
if (pca.Priority != 1500)
{
throw new Exception("Wrong order");
}
});
}
private Session CreateSession(
Action <ScopedObjectRegistry> sessionObjectsConfigurator = null,
params Type[] commandTypes)
{
var parser = new Parser();
var nameValidator = new NameValidator();
var descriptorGenerator = new CommandAttributeInspector();
var registry = new CommandRegistry(nameValidator, descriptorGenerator);
foreach (var commandType in commandTypes)
{
registry.Register(commandType);
}
var services = new CommandServices();
var scopedObjects = new ScopedObjectRegistry();
scopedObjects.Register <VariableCollection>();
sessionObjectsConfigurator?.Invoke(scopedObjects);
var factory = new CommandFactory(registry, services, scopedObjects);
var variables = scopedObjects.Resolve(typeof(VariableCollection)) as VariableCollection;
var replacer = new VariableReplacer();
var binder = new CommandParameterBinder(registry, replacer, variables);
return(new Session(parser, factory, binder));
}
public CommandHandler(IMessageBus messageBus, CommandRegistry commandRegistry)
{
_messageBus = messageBus;
_commandRegistry = commandRegistry;
messageBus.Received += (sender, args) =>
{
try
{
MessageBusOnReceived(sender, args);
}
catch
{
// ignore
}
};
messageBus.Sent += (sender, args) =>
{
try
{
MessageBusOnSent(sender, args);
}
catch
{
// ignore
}
};
}
public void CommandRegistry_WithCommands_SupportsThoseCommands()
{
List <TestCommand> commands = Build.Many.Commands(Build.A.Command, Build.A.Command, Build.A.Command);
CommandRegistry sut = new CommandRegistry(commands);
commands.All(c => sut.Supports(c.SupportedCommand)).Should().BeTrue();
}
private CommandFactory CreateCommandFactory(
Action <CommandRegistry> commandRegistryConfigurator = null,
Action <CommandServices> commandServicesConfigurator = null,
Action <ScopedObjectRegistry> scopedObjectRegistryConfigurator = null)
{
var nameValidator = new NameValidator();
var descriptorGenerator = new CommandAttributeInspector();
var registry = new CommandRegistry(nameValidator, descriptorGenerator);
if (commandRegistryConfigurator != null)
{
commandRegistryConfigurator.Invoke(registry);
}
var services = new CommandServices();
if (commandServicesConfigurator != null)
{
commandServicesConfigurator.Invoke(services);
}
var sessionObjects = new ScopedObjectRegistry();
sessionObjects.Register <VariableCollection>();
if (scopedObjectRegistryConfigurator != null)
{
scopedObjectRegistryConfigurator.Invoke(sessionObjects);
}
return(new CommandFactory(registry, services, sessionObjects));
}
private void OnKick(string txt)
{
if (string.IsNullOrEmpty(txt))
{
CommandRegistry.ShowCurrentHelp();
return;
}
if (!NetGame.isServer)
{
string str = ScriptLocalization.Get("XTRA/NetChat_OnlyHost");
Print(str);
return;
}
NetHost client = GetClient(txt);
if (client != null)
{
if (client == NetGame.instance.local)
{
string str2 = ScriptLocalization.Get("XTRA/NetChat_NoKickMe");
Print(str2);
}
else
{
NetGame.instance.Kick(client);
}
}
}
public override void RegisterCommands(CommandRegistry commandRegistry)
{
commandRegistry.RegisterCommand("alarms", "Show the alarms.", ShowAlarms);
commandRegistry.RegisterCommand("alarm-settings", "[1-16]", "Show the settings of an alarm.", ShowAlarmSettings);
commandRegistry.RegisterCommand("toggle-alarm", "[1-16] [on/off]", "Toggle an alarm.", ToggleAlarm);
commandRegistry.RegisterCommand("remove-alarm", "[1-16]", "Remove an alarm.", RemoveAlarm);
commandRegistry.RegisterCommand("set-snooze-time", "[1-20]", "Sets the snooze time in minutes.", SetSnoozeTime);
}
public CommandHandler(IMessageBus messageBus, CommandRegistry commandRegistry)
{
_messageBus = messageBus;
_commandRegistry = commandRegistry;
messageBus.Received += MessageBusOnReceived;
messageBus.Sent += MessageBusOnSent;
}
private static void InitiateCommands()
{
cmdController = new CommandRegistry();
cmdController.Commands.Add(new Multiply());
cmdController.Commands.Add(new Help(cmdController.Commands));
}
public void CommandRegistry_WithACommand_DoesNotSupportUnknownCommand()
{
List <TestCommand> commands = Build.A.Command.InAList();
CommandRegistry sut = new CommandRegistry(commands);
TestCommand unknownCommand = Build.A.Command;
sut.Supports(unknownCommand.SupportedCommand).Should().BeFalse();
}
public override void RegisterCommands(CommandRegistry commandRegistry)
{
commandRegistry.RegisterCommand("device", "Show the device information.", ShowDeviceDetails);
commandRegistry.RegisterCommand("firmware", "Show the firmware information.", ShowFirmwareDetails);
commandRegistry.RegisterCommand("wifi", "Show the wifi connection details.", ShowWifiDetails);
commandRegistry.RegisterCommand("locale", "Show the locale set for the device.", ShowLocale);
commandRegistry.RegisterCommand("time", "Show the time of the device.", ShowTime);
}
public void SetDefaultCommand_ThrowsIfCommandNotRegistered()
{
CommandRegistry commandRegistry = new CommandRegistry();
var ex = Assert.Throws <Exception>(() => commandRegistry.SetDefaultCommand(typeof(TestCommand)));
Assert.That(ex.Message, Is.EqualTo("Command NConsole.Tests.Internal.CommandRegistryTests+TestCommand is not registered."));
}
public override void RegisterCommands(CommandRegistry commandRegistry)
{
commandRegistry.RegisterCommand("light", "Show the light state.", ShowLightState);
commandRegistry.RegisterCommand("toggle-light", "[on/off]", "Toggle the light.", ToggleLight);
commandRegistry.RegisterCommand("set-light-level", "[1-25]", "Set the light level.", SetLightLevel);
commandRegistry.RegisterCommand("toggle-night-light", "[on/off]", "Toggle the night light.", ToggleNightLight);
commandRegistry.RegisterCommand("toggle-sunrise-preview", "[on/off]", "Toggle the Sunrise Preview mode.", ToggleSunrisePreview);
}
public void TestAddition()
{
//Asserts that a command registry can register the command without throwing an exception
using (CommandRegistry registry = new CommandRegistry(new RegistrySettings()))
{
registry.AddCommand(typeof(TestCommand));
}
}
public void RegisterBothCommandAndAliasAndFindWithPrefix()
{
var registry = new CommandRegistry();
registry.Register(new HelpCommand());
registry.Register(new HelpCommand(), "h");
// Only finds the alias, because the prefix and the name of the
// command are the same in this case.
Assert.AreEqual(1, registry.Find("h").Count);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
base.Initialize();
// Load up the options from file.
string optionsFileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NiftySolution.xml");
Options options = Options.Load(optionsFileName);
// Create our main plugin facade.
DTE2 application = GetGlobalService(typeof(DTE)) as DTE2;
IVsProfferCommands3 profferCommands3 = base.GetService(typeof(SVsProfferCommands)) as IVsProfferCommands3;
OleMenuCommandService oleMenuCommandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
ImageList icons = new ImageList();
icons.Images.AddStrip(Properties.Resources.Icons);
m_plugin = new Plugin(application, profferCommands3, icons, oleMenuCommandService, "NiftySolution", "Aurora.NiftySolution.Connect", options);
// Every plugin needs a command bar.
CommandBar commandBar = m_plugin.AddCommandBar("NiftySolution", MsoBarPosition.msoBarTop);
m_commandRegistry = new CommandRegistry(m_plugin, commandBar, new Guid(PackageGuidString), new Guid(PackageGuidGroup));
// Initialize the logging system.
if (Log.HandlerCount == 0)
{
#if DEBUG
Log.AddHandler(new DebugLogHandler());
#endif
Log.AddHandler(new VisualStudioLogHandler(m_plugin));
Log.Prefix = "NiftySolution";
}
// Now we can take care of registering ourselves and all our commands and hooks.
Log.Debug("Booting up...");
Log.IncIndent();
bool doBindings = options.EnableBindings;
m_commandRegistry.RegisterCommand(doBindings, new QuickOpen(m_plugin, "NiftyOpen"));
m_commandRegistry.RegisterCommand(doBindings, new ToggleFile(m_plugin, "NiftyToggle"));
m_commandRegistry.RegisterCommand(doBindings, new CloseToolWindow(m_plugin, "NiftyClose"));
m_commandRegistry.RegisterCommand(doBindings, new Configure(m_plugin, "NiftyConfigure"));
if (options.SilentDebuggerExceptions || options.IgnoreDebuggerExceptions)
{
m_debuggerEvents = application.Events.DebuggerEvents;
m_debuggerEvents.OnExceptionNotHandled += new _dispDebuggerEvents_OnExceptionNotHandledEventHandler(OnExceptionNotHandled);
}
m_timings = new SolutionBuildTimings(m_plugin);
Log.DecIndent();
Log.Debug("Initialized...");
}
public override void RegisterCommands(CommandRegistry commandRegistry)
{
commandRegistry.RegisterCommand("fm-radio-presets", "Show the FM-radio presets.", ShowFMRadioPresets);
commandRegistry.RegisterCommand("set-fm-radio-preset", $"[1-5] [{87.50F:0.00}-{107.99F:0.00}]", "Set an FM-radio preset to a frequency.", SetFMRadioPreset);
commandRegistry.RegisterCommand("fm-radio", "Show the FM-radio state.", ShowFMRadioState);
commandRegistry.RegisterCommand("enable-fm-radio", "Enable the FM-radion.", EnableFMRadio);
commandRegistry.RegisterCommand("enable-fm-radio-preset", "[1-5]", "Enable an FM-radio preset.", EnableFMRadioPreset);
commandRegistry.RegisterCommand("seek-fm-radio-station", "[up/down]", "Seek a next FM-radio station.", SeekFMRadioStation);
}
public void RegisterBothCommandAndAlias()
{
var registry = new CommandRegistry();
registry.Register(new HelpCommand());
registry.Register(new HelpCommand(), "h");
Assert.AreEqual(2, registry.Commands.Count);
Assert.IsTrue(registry.Contains("help"));
Assert.IsTrue(registry.Contains("h"));
}
public void AmbiguousMatchCommand()
{
var registry = new CommandRegistry();
registry.Register(new BarCommand());
registry.Register(new BazCommand());
var factory = new CommandFactory(registry);
var command = factory.Create(new[] {"ba"});
Assert.That(command, Is.InstanceOf(typeof(AmbiguousMatchCommand)));
}
/// <summary>
/// Main entry-point.
/// </summary>
public static void Main()
{
// Register command information
CommandRegistry.LoadCommandEntries();
// Start up the bot
BotStartup.StartBotAsync()
.GetAwaiter()
.GetResult();
}
/// <summary>
/// Generates a new parser that uses the given registry, args, metadata, context, and ID to run
/// </summary>
/// <param name="registry">Registry from which the parser will obtain <see cref="IObjectConverter"/>s</param>
/// <param name="input">The original input string</param>
/// <param name="additionalArgs">Any additional arguments to be added to the end of the argument list</param>
/// <param name="metadata">CommandMetadata containing information used to parse and execute</param>
/// <param name="exeData"><see cref="CommandExecutorData"/> containing the data required for execution</param>
/// <param name="ctx">Context object passed to the executed command, and an <see cref="IObjectConverter"/>s that are used</param>
/// <param name="callback">Reference to a method used as a callback when processing completes</param>
public Parser(CommandRegistry registry,
string input,
IEnumerable <object> additionalArgs,
CommandMetadata metadata,
CommandExecutorData exeData,
IContextObject ctx,
InputResultDelegate callback)
: base(registry, input, additionalArgs, metadata, exeData, ctx, callback)
{
}
public void GetDescriptor_ReturnsRegisteredCommand()
{
CommandRegistry commandRegistry = new CommandRegistry();
commandRegistry.Register(typeof(TestCommand));
CommandDescriptor descriptor = commandRegistry.GetDescriptor("test", null);
Assert.That(descriptor.Name, Is.EqualTo("test"));
}
public void GetDescriptor_ReturnsRegisteredCommandUsingCommandAttribute()
{
CommandRegistry commandRegistry = new CommandRegistry();
commandRegistry.Register(typeof(TestAttributedCommand));
CommandDescriptor descriptor = commandRegistry.GetDescriptor("overridden", null);
Assert.That(descriptor.Name, Is.EqualTo("overridden"));
}
public static void RegisterAllCommands()
{
//CommandRegistry.RegisterCommand(new Command("Console.WriteLine({contents});", "Output:WriteLn[{contents}]", new string[] { "contents" }));
//CommandRegistry.RegisterCommand(new Command("using {namespace};", "Use {namespace}", new string[] { "namespace" }));
//CommandRegistry.RegisterCommand(new Command("{type} {name};", "InitializeVar {type} {name}", new string[] { "type", "name" }));
//CommandRegistry.RegisterCommand(new Command("{name} = Console.ReadLine();", "{name}=Input:ReadLn[]", new string[] { "name" }));
CommandRegistry.RegisterKeyword(new Keyword("class", "DefClass"));
CommandRegistry.RegisterKeyword(new Keyword("public", "Visibility:Public"));
CommandRegistry.RegisterKeyword(new Keyword("private", "Visibility:Private"));
CommandRegistry.RegisterKeyword(new Keyword("protected", "Visibility:Protected"));
CommandRegistry.RegisterKeyword(new Keyword("static", "StaticObj"));
CommandRegistry.RegisterKeyword(new Keyword("void", "Void"));
CommandRegistry.RegisterKeyword(new Keyword("string", "String"));
CommandRegistry.RegisterKeyword(new Keyword("int", "Int32"));
CommandRegistry.RegisterKeyword(new Keyword("short", "Int16"));
CommandRegistry.RegisterKeyword(new Keyword("long", "Long"));
CommandRegistry.RegisterKeyword(new Keyword("char", "Character"));
CommandRegistry.RegisterKeyword(new Keyword("object", "Object"));
CommandRegistry.RegisterKeyword(new Keyword("var", "Variable"));
CommandRegistry.RegisterKeyword(new Keyword("sealed", "NonInheritable"));
CommandRegistry.RegisterKeyword(new Keyword("abstract", "Abstract"));
CommandRegistry.RegisterKeyword(new Keyword("using", "Use"));
CommandRegistry.RegisterKeyword(new Keyword("namespace", "Namespace"));
CommandRegistry.RegisterKeyword(new Keyword("delegate", "Delegate"));
CommandRegistry.RegisterKeyword(new Keyword("enum", "Enumeration"));
CommandRegistry.RegisterKeyword(new Keyword("if", "[IF]"));
CommandRegistry.RegisterKeyword(new Keyword("else if", "[ELSE_IF]"));
CommandRegistry.RegisterKeyword(new Keyword("else", "[ELSE]"));
CommandRegistry.RegisterKeyword(new Keyword("for", "For"));
CommandRegistry.RegisterKeyword(new Keyword("foreach", "ForEach"));
CommandRegistry.RegisterKeyword(new Keyword("while", "DoWhile"));
CommandRegistry.RegisterKeyword(new Keyword("try", "TryDo"));
CommandRegistry.RegisterKeyword(new Keyword("catch", "CatchException"));
CommandRegistry.RegisterKeyword(new Keyword("finally", "DoFinally"));
CommandRegistry.RegisterKeyword(new Keyword("interface", "DefInterface"));
CommandRegistry.RegisterKeyword(new Keyword("switch", "Switch"));
CommandRegistry.RegisterKeyword(new Keyword("case", "Case"));
CommandRegistry.RegisterKeyword(new Keyword("break", "BreakConstruction"));
CommandRegistry.RegisterKeyword(new Keyword("default", "DefaultCase"));
CommandRegistry.RegisterKeyword(new Keyword("continue", "Continue"));
CommandRegistry.RegisterKeyword(new Keyword("return", "Return"));
CommandRegistry.RegisterKeyword(new Keyword("event", "Event"));
CommandRegistry.RegisterKeyword(new Keyword("null", "NullValue"));
}
public void OnConnection(object application_, ext_ConnectMode connectMode, object addInInst, ref Array custom)
{
if (null != m_plugin)
{
return;
}
// Load up the options from file.
string optionsFileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NiftySolution.xml");
Options options = Options.Load(optionsFileName);
// Create our main plugin facade.
DTE2 application = (DTE2)application_;
m_plugin = new Plugin(application, (AddIn)addInInst, "NiftySolution", "Aurora.NiftySolution.Connect", options);
// Every plugin needs a command bar.
CommandBar commandBar = m_plugin.AddCommandBar("NiftySolution", MsoBarPosition.msoBarTop);
m_commandRegistry = new CommandRegistry(m_plugin, commandBar);
// Initialize the logging system.
if (Log.HandlerCount == 0)
{
#if DEBUG
Log.AddHandler(new DebugLogHandler());
#endif
Log.AddHandler(new VisualStudioLogHandler(m_plugin.OutputPane));
Log.Prefix = "NiftySolution";
}
// Now we can take care of registering ourselves and all our commands and hooks.
Log.Debug("Booting up...");
Log.IncIndent();
bool doBindings = options.EnableBindings;
m_commandRegistry.RegisterCommand("NiftyOpen", doBindings, new QuickOpen(m_plugin));
m_commandRegistry.RegisterCommand("NiftyToggle", doBindings, new ToggleFile(m_plugin));
m_commandRegistry.RegisterCommand("NiftyClose", doBindings, new CloseToolWindow(m_plugin));
m_commandRegistry.RegisterCommand("NiftyConfigure", doBindings, new Configure(m_plugin));
if (options.SilentDebuggerExceptions || options.IgnoreDebuggerExceptions)
{
m_debuggerEvents = application.Events.DebuggerEvents;
m_debuggerEvents.OnExceptionNotHandled += new _dispDebuggerEvents_OnExceptionNotHandledEventHandler(OnExceptionNotHandled);
}
m_timings = new SolutionBuildTimings(m_plugin);
Log.DecIndent();
Log.Debug("Initialized...");
}
public void OutputForAmbiguousMatchCommand()
{
var registry = new CommandRegistry();
registry.Register(new BarCommand());
registry.Register(new BazCommand());
var factory = new CommandFactory(registry);
var command = factory.Create(new[] {"ba"});
var output = OutputFor(command);
Assert.That(output, Is.StringContaining("Multiple commands start with 'ba':"));
Assert.That(output, Is.StringContaining(" bar"));
Assert.That(output, Is.StringContaining(" baz"));
}
/// <summary>
/// Initialises a new instance of the ServerCommands class.
/// </summary>
/// <param name="server">The instance of the Server running.</param>
/// <param name="registry">A CommandRegistry to register commands to.</param>
public ServerCommands(Server server, CommandRegistry<ServerCommand> registry)
{
_server = server;
_registry = registry;
_registry.Register(new ServerCommand("broadcast", false, Broadcast, "Broadcasts a message to every connected client."));
_registry.Register(new ServerCommand("help", false, Help, "Provides help for the command utility."));
_registry.Register(new ServerCommand("ban", true, BanUser, "Bans a user from the server, never to return!"));
_registry.Register(new ServerCommand("kick", true, KickUser, "Kicks a user from their session. They may reconnect, but their sessions will be read-only until the server is restarted."));
_registry.Register(new ServerCommand("restart", true, Restart, "Restarts the server, notifying clients that it's happening."));
_registry.Register(new ServerCommand("privileged", false, ListPrivileged, "Gives a list of all the privileged users."));
_registry.Register(new ServerCommand("banned", false, ListBanned, "Gives a list of all the banned users."));
}
public void OnConnection(object application_, ext_ConnectMode connectMode, object addInInst, ref Array custom)
{
if(null != m_plugin)
return;
// Load up the options from file.
string optionsFileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NiftySolution.xml");
Options options = Options.Load(optionsFileName);
// Create our main plugin facade.
DTE2 application = (DTE2)application_;
m_plugin = new Plugin(application, (AddIn)addInInst, "NiftySolution", "Aurora.NiftySolution.Connect", options);
// Every plugin needs a command bar.
CommandBar commandBar = m_plugin.AddCommandBar("NiftySolution", MsoBarPosition.msoBarTop);
m_commandRegistry = new CommandRegistry(m_plugin, commandBar);
// Initialize the logging system.
if(Log.HandlerCount == 0)
{
#if DEBUG
Log.AddHandler(new DebugLogHandler());
#endif
Log.AddHandler(new VisualStudioLogHandler(m_plugin.OutputPane));
Log.Prefix = "NiftySolution";
}
// Now we can take care of registering ourselves and all our commands and hooks.
Log.Debug("Booting up...");
Log.IncIndent();
bool doBindings = options.EnableBindings;
m_commandRegistry.RegisterCommand("NiftyOpen", doBindings, new QuickOpen(m_plugin));
m_commandRegistry.RegisterCommand("NiftyToggle", doBindings, new ToggleFile(m_plugin));
m_commandRegistry.RegisterCommand("NiftyClose", doBindings, new CloseToolWindow(m_plugin));
m_commandRegistry.RegisterCommand("NiftyConfigure", doBindings, new Configure(m_plugin));
if (options.SilentDebuggerExceptions || options.IgnoreDebuggerExceptions)
{
m_debuggerEvents = application.Events.DebuggerEvents;
m_debuggerEvents.OnExceptionNotHandled += new _dispDebuggerEvents_OnExceptionNotHandledEventHandler(OnExceptionNotHandled);
}
m_timings = new SolutionBuildTimings(m_plugin);
Log.DecIndent();
Log.Debug("Initialized...");
}
public void CommandRegistryTests()
{
var command = new FakeCommand { Identifier = Guid.NewGuid() };
var registry = new CommandRegistry(
new InMemoryRecordMapper<CommandPublicationRecord>(), new InMemoryBlobStorage(), new JsonMessageSerializer());
var record = registry.PublishMessage(command);
Assert.NotNull(record);
var retrieved = registry.GetMessage(record.MessageLocation, record.MessageType);
Assert.NotNull(retrieved);
Assert.AreEqual(command.Identifier, retrieved.Identifier);
Assert.NotNull(retrieved as FakeCommand);
}
/// <summary>
/// Initialises a new instance of the ServerWindow class and sets up the required values and
/// objects for use.
/// </summary>
public ServerWindow(bool crashRecovery)
{
InitializeComponent();
_logger = new Logger();
_logger.IsEnabled = true;
Overlay.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#44FFFFFF"));
this.Log("Loading Messenger::Server modules");
this.Log("Creating Server instance...");
RunningServer = new Server(this, this.GetPort());
this.Log("Server instance {0} on port {1}", RunningServer, RunningServer.Port);
this.Log("Log location: {0}", _logger.LogDirectory + "\\" + _logger.LogFile);
new Thread(FinishLoadingThread).Start();
RunningServer.Start();
_commands = new CommandRegistry<ServerCommand>();
new ServerCommands(RunningServer, _commands);
}
static void Main(string[] args)
{
ICommandRegistry commandRegistry = new CommandRegistry();
commandRegistry.Register<SayHelloQuery, SayHelloQueryHandler>();
commandRegistry.Register<SayHelloCommand, SayHelloCommandHandler>();
ContainerBuilder container = new ContainerBuilder();
RegisterHandlers(container);
AutofacCommandHandlerFactory autofacCommandHandlerFactory = new AutofacCommandHandlerFactory(container.Build());
_commandProcessor = new CommandProcessor(commandRegistry, autofacCommandHandlerFactory);
ExecuteCommand(_commandProcessor);
ExecuteCommand(_commandProcessor);
ExecuteQuery(_commandProcessor);
Console.ReadLine();
}
public HelpCommand(CommandRegistry registry, string name)
{
this.registry = registry;
this.name = name;
}
public HelpCommand(CommandRegistry registry)
{
this.registry = registry;
}
public DefaultFrontController(CommandRegistry command_registry)
{
this.command_registry = command_registry;
}
public DefaultFrontController(CommandRegistry registry)
{
//this represents new functionality
this.command_registry = registry;
}
public FrontControllerImplementation(CommandRegistry command_registry)
{
this.command_registry = command_registry;
}
public DefaultFrontController(CommandRegistry registry)
{
this.registry = registry;
}
public ConsoleApplication(CommandRegistry registry)
{
this.registry = registry;
}
public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst_, ref Array custom)
{
if(null != m_plugin)
return;
// Load up the options from file.
string optionsFileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "NiftyPerforce.xml");
Config options = Config.Load(optionsFileName);
// Every plugin needs a command bar.
m_plugin = new Plugin((DTE2)application, (AddIn)addInInst_, "NiftyPerforce", "Aurora.NiftyPerforce.Connect", options);
CommandBar commandBar = m_plugin.AddCommandBar("NiftyPerforce", MsoBarPosition.msoBarTop);
m_commandRegistry = new CommandRegistry(m_plugin, commandBar);
// Initialize the logging system.
if(Log.HandlerCount == 0)
{
#if DEBUG
Log.AddHandler(new DebugLogHandler());
#endif
Log.AddHandler(new VisualStudioLogHandler(m_plugin.OutputPane));
Log.Prefix = "NiftyPerforce";
}
// Now we can take care of registering ourselves and all our commands and hooks.
Log.Debug("Booting up...");
Log.IncIndent();
bool doContextCommands = true;
bool doBindings = options.EnableBindings;
m_commandRegistry.RegisterCommand("NiftyConfig", doBindings, new NiftyConfigure(m_plugin), true);
m_commandRegistry.RegisterCommand("NiftyEditModified", doBindings, new P4EditModified(m_plugin), true);
m_commandRegistry.RegisterCommand("NiftyEdit", doBindings, new P4EditItem(m_plugin), true);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyEditItem", doBindings, new P4EditItem(m_plugin), false);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyEditSolution", doBindings, new P4EditSolution(m_plugin), false);
m_commandRegistry.RegisterCommand("NiftyDiff", doBindings, new P4DiffItem(m_plugin));
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyDiffItem", doBindings, new P4DiffItem(m_plugin), false);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyDiffSolution", doBindings, new P4DiffSolution(m_plugin), false);
m_commandRegistry.RegisterCommand("NiftyHistory", doBindings, new P4RevisionHistoryItem(m_plugin, false), true);
m_commandRegistry.RegisterCommand("NiftyHistoryMain", doBindings, new P4RevisionHistoryItem(m_plugin, true), true);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyHistoryItem", doBindings, new P4RevisionHistoryItem(m_plugin, false), false);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyHistoryItemMain", doBindings, new P4RevisionHistoryItem(m_plugin, true), false);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyHistorySolution", doBindings, new P4RevisionHistorySolution(m_plugin), false);
m_commandRegistry.RegisterCommand("NiftyTimeLapse", doBindings, new P4TimeLapseItem(m_plugin, false), true);
m_commandRegistry.RegisterCommand("NiftyTimeLapseMain", doBindings, new P4TimeLapseItem(m_plugin, true), true);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyTimeLapseItem", doBindings, new P4TimeLapseItem(m_plugin, false), false);
if (doContextCommands) m_commandRegistry.RegisterCommand("NiftyTimeLapseItemMain", doBindings, new P4TimeLapseItem(m_plugin, true), false);
m_commandRegistry.RegisterCommand("NiftyRevisionGraph", doBindings, new P4RevisionGraphItem(m_plugin, false), true);
m_commandRegistry.RegisterCommand("NiftyRevisionGraphMain", doBindings, new P4RevisionGraphItem(m_plugin, true), true);
if (doContextCommands) m_commandRegistry.RegisterCommand("NiftyRevisionGraphItem", doBindings, new P4RevisionGraphItem(m_plugin, false), false);
if (doContextCommands) m_commandRegistry.RegisterCommand("NiftyRevisionGraphItemMain", doBindings, new P4RevisionGraphItem(m_plugin, true), false);
m_commandRegistry.RegisterCommand("NiftyRevert", doBindings, new P4RevertItem(m_plugin), true);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyRevertItem", doBindings, new P4RevertItem(m_plugin), false);
m_commandRegistry.RegisterCommand("NiftyShow", doBindings, new P4ShowItem(m_plugin), true);
if(doContextCommands) m_commandRegistry.RegisterCommand("NiftyShowItem", doBindings, new P4ShowItem(m_plugin), false);
m_plugin.AddFeature(new AutoAddDelete(m_plugin));
m_plugin.AddFeature(new AutoCheckoutProject(m_plugin));
m_plugin.AddFeature(new AutoCheckoutOnBuild(m_plugin));
m_plugin.AddFeature(new AutoCheckoutTextEdit(m_plugin));
m_plugin.AddFeature(new AutoCheckoutOnSave(m_plugin));
#if DEBUG
// Use this to track down event GUIDs.
//m_plugin.AddFeature(new FindEvents(m_plugin));
#endif
P4Operations.CheckInstalledFiles();
AsyncProcess.Init();
Log.DecIndent();
Log.Debug("Initialized...");
#if DEBUG
Log.Info("NiftyPerforce (Debug)");
#else
//Log.Info("NiftyPerforce (Release)");
#endif
// Show where we are and when we were compiled...
Log.Info("I'm running {0} compiled on {1}", Assembly.GetExecutingAssembly().Location, System.IO.File.GetLastWriteTime(Assembly.GetExecutingAssembly().Location));
}
