/// <summary> /// Creates a monitor for a mouse wheel binding /// </summary> /// <exception cref="ArgumentNullException">Thrown if binding or user are null</exception> public ICommandInputBindingMonitor CreateBindingMonitor( CommandMouseWheelInputBinding binding, ICommandUser user ) { Arguments.CheckNotNull( binding, "binding" ); Arguments.CheckNotNull( user, "user" ); return new CommandMouseWheelInputBindingMonitor( m_Control, binding, user ); }
/// <summary> /// Adds a list of input bindings to a control /// </summary> public void AddBindings( ICommandUser user, IEnumerable<CommandInputBinding> bindings ) { foreach ( CommandInputBinding binding in bindings ) { AddBinding( user, binding ); } }
public string CreateTokenString(ICommandUser commandUser) { SigningCredentials singingCridentials = new SigningCredentials(this.signingKey, SecurityAlgorithms.HmacSha256Signature, SecurityAlgorithms.Sha256Digest); EncryptingCredentials encryptingCridentials = new EncryptingCredentials(this.secutityKey, SecurityAlgorithms.Aes128KW, SecurityAlgorithms.Aes128CbcHmacSha256); ClaimsIdentity claimsIdentity = new ClaimsIdentity(new List <Claim>()); claimsIdentity.AddClaim(new Claim(ClaimTypes.PrimarySid, commandUser.ID)); claimsIdentity.AddClaim(new Claim(ClaimTypes.UserData, JsonConvert.SerializeObject(commandUser.UserData))); claimsIdentity.AddClaim(new Claim(ClaimTypes.Name, commandUser.Username)); claimsIdentity.AddClaim(new Claim(ClaimTypes.Role, JsonConvert.SerializeObject(commandUser.UserRoles))); SecurityTokenDescriptor tokenDiscriptor = new SecurityTokenDescriptor(); tokenDiscriptor.Subject = claimsIdentity; tokenDiscriptor.Issuer = this.issuer; tokenDiscriptor.SigningCredentials = singingCridentials; tokenDiscriptor.EncryptingCredentials = encryptingCridentials; tokenDiscriptor.Expires = DateTime.UtcNow.Add(TimeSpan.FromHours(1)); JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler(); JwtSecurityToken token = tokenHandler.CreateJwtSecurityToken(tokenDiscriptor); string tokenString = tokenHandler.WriteToken(token); return(tokenString); }
public override void Execute(CommandArguments args, ICommandUser sender) { var commands = CommandManager.Instance.Commands; foreach (var cmd in commands.Values.Distinct()) { var perm = cmd.RequiredPermission; if (sender != null && perm != null && !sender.HasPermission(perm)) { continue; } var cmd1 = cmd; var triggers = commands.Where(x => x.Value == cmd1).Select(x => x.Key).ToList(); var count = triggers.Count; for (var i = 0; i < count; i++) { Console.Write(triggers[i]); if (i < count - 1) { Console.Write("|"); } } Console.WriteLine(": {0}", cmd.Description); } }
/// <summary> /// Setup constructor /// </summary> /// <param name="control">Control to bind to</param> /// <param name="binding">Binding definition</param> /// <param name="user">Originating user</param> public CommandKeyInputBindingMonitor( Control control, CommandKeyInputBinding binding, ICommandUser user ) : base(binding, user) { m_Control = control; m_Key = ( Keys )Enum.Parse( typeof( Keys ), binding.KeyName, true ); MonitorState = binding.KeyState; }
/// <summary> /// Attaches this controller to a user /// </summary> /// <param name="user">User to attach to</param> /// <param name="camera">Camera to control. Can be null</param> public FirstPersonCameraController( ICommandUser user, FirstPersonCamera camera ) { Arguments.CheckNotNull( user, "user" ); user.CommandTriggered += HandleCommand; InteractionUpdateTimer.Instance.Update += OnInteractionUpdate; Camera = camera; }
public override void Execute(CommandArguments args, ICommandUser sender) { var commands = CommandManager.Instance.Commands; foreach (var cmd in commands.Values.Distinct()) { var perm = cmd.RequiredPermission; if (sender != null && perm != null && !sender.HasPermission(perm)) continue; var cmd1 = cmd; var triggers = commands.Where(x => x.Value == cmd1).Select(x => x.Key).ToList(); var count = triggers.Count; for (var i = 0; i < count; i++) { Console.Write(triggers[i]); if (i < count - 1) Console.Write("|"); } Console.WriteLine(": {0}", cmd.Description); } }
public override void Execute(CommandArguments args, ICommandUser sender) { Console.WriteLine("Executing this command will permanently drop the entire database. Continue? (Y/N)"); var answer = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture).ToCharArray().FirstOrDefault(); if (answer == 'Y') AccountApplication.Instance.AccountDbContext.PostAsync(x => x.Schema.Drop()); }
/// <summary> /// Adds a command binding to a control for a specific user /// </summary> public virtual void AddBinding( ICommandUser user, CommandInputBinding binding ) { ICommandInputBindingMonitor monitor = binding.CreateMonitor( m_MonitorFactory, user ); GetSafeMonitorList( user ).Add( monitor ); m_AllMonitors.Add( monitor ); if ( m_Started ) { monitor.Start( ); } }
/// <summary> /// Registers a user /// </summary> /// <param name="user">User to register</param> /// <exception cref="ArgumentNullException">Thrown if user is null</exception> /// <exception cref="ArgumentException">Thrown if user already exists in the registry</exception> public void Register( ICommandUser user ) { Arguments.CheckNotNull( user, "user" ); InteractionLog.Info( "Registering user \"{0}\" ({1})", user.Name, user.Id ); if ( m_Users.ContainsKey( user.Id ) ) { throw new ArgumentException( string.Format( "User (name: {0}, id: {1}) is already registered", user.Name, user.Id ), "user" ); } m_Users[ user.Id ] = user; }
public override void Execute(CommandArguments args, ICommandUser sender) { Console.WriteLine("Executing this command will permanently overwrite the entire database. Continue? (Y/N)"); var answer = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture).ToCharArray().FirstOrDefault(); if (answer == 'Y') { AccountApplication.Instance.AccountDbContext.PostAsync(x => x.Schema.Create()); } }
public override void Execute(CommandArguments args, ICommandUser sender) { var fileName = args.NextString(); if (string.IsNullOrEmpty(fileName)) { sender.Respond("No file name given."); return; } AccountApplication.Instance.AccountDbContext.PostAsync(x => x.Schema.Export(fileName)); }
/// <summary> /// Deserialization constructor /// </summary> public CommandTriggerData( SerializationInfo info, StreamingContext context ) { CommandSerializationContext commandContext = context.Context as CommandSerializationContext; if ( commandContext == null ) { throw new System.IO.IOException( "CommandTriggerData must be deserialized with a CommandSerializationContext present" ); } m_User = commandContext.Users.FindById( ( int )info.GetValue( "u", typeof( int ) ) ); m_Command = commandContext.Commands.FindById( ( int )info.GetValue( "c", typeof( int ) ) ); m_InputState = ( ICommandInputState )info.GetValue( "s", typeof( ICommandInputState ) ); }
public void ExecuteCommand(string[] fullCmd, ICommandUser sender) { Contract.Requires(fullCmd != null); Contract.Requires(fullCmd.Length > 0); var cmd = fullCmd.Take(1).Single(); if (string.IsNullOrWhiteSpace(cmd)) { return; } var command = GetCommand(cmd); if (command == null) { sender.Respond("Unknown command: {0}".Interpolate(cmd)); return; } if (command.RequiresSender && (sender == null || sender is ConsoleCommandUser)) { sender.Respond("Command {0} requires a sender.".Interpolate(cmd)); return; } var permission = command.RequiredPermission; if (sender != null && permission != null && permission != typeof(ConsolePermission) && !sender.HasPermission(permission)) { sender.Respond("Command {0} requires permission {1}.".Interpolate(cmd, permission)); return; } // Process all commands in a serial manner. Not asynchronously, though, as this would cause // problems with console cancellation. lock (_cmdLock) { try { command.Execute(new CommandArguments(fullCmd.Skip(1)), sender); } catch (CommandArgumentException ex) { sender.Respond("Argument error for command {0}: {1}".Interpolate(cmd, ex.Message)); } catch (Exception ex) { ExceptionManager.RegisterException(ex); return; } } }
public override void Execute(CommandArguments args, ICommandUser sender) { var condensedOpCode = args.NextUInt16(); var opCodes = OpCodeUtility.GetOpCodesForCondensedOpCode(condensedOpCode); if (opCodes.Count() == 0) { sender.Respond("No uncompressed opcodes found."); return; } sender.Respond("Found the following opcodes:"); foreach (var uncompressedOpCode in opCodes) sender.Respond("{0} ({0:X})".Interpolate(uncompressedOpCode)); }
public override void Execute(CommandArguments args, ICommandUser sender) { var condensedOpCode = args.NextUInt16(); var opCodes = OpCodeUtility.GetOpCodesForCondensedOpCode(condensedOpCode); if (opCodes.Count() == 0) { sender.Respond("No uncompressed opcodes found."); return; } sender.Respond("Found the following opcodes:"); foreach (var uncompressedOpCode in opCodes) { sender.Respond("{0} ({0:X})".Interpolate(uncompressedOpCode)); } }
public override void Execute(CommandArguments args, ICommandUser sender) { var opCode = args.NextUInt16(); if (opCode == 0) { sender.Respond("Invalid opcode given."); return; } var jamClient = OpCodeUtility.GetJamClientOpCode(opCode); sender.Respond(jamClient != null ? "JAM client opcode: {0} ({0:X})".Interpolate(jamClient) : "Could not calculate JAM client opcode."); var jamClientConn = OpCodeUtility.GetJamClientConnectionOpCode(opCode); sender.Respond(jamClientConn != null ? "JAM client connection opcode: {0} ({0:X})".Interpolate(jamClientConn) : "Could not calculate JAM client connection opcode."); }
public override void Execute(CommandArguments args, ICommandUser sender) { var opCode = args.NextUInt16(); if (opCode == 0) { sender.Respond("Invalid opcode given."); return; } var result = OpCodeUtility.CompressOpCode(opCode); if (result == null) { sender.Respond("Could not condense opcode."); return; } sender.Respond("Condensed opcode: {0}".Interpolate(result)); }
public override void Execute(CommandArguments args, ICommandUser sender) { var name = args.NextString(); var password = args.NextString(); var email = args.NextString(); var box = args.NextEnum <ClientBoxLevel>(ClientBoxLevel.Cataclysm); var locale = args.NextEnum <ClientLocale>(ClientLocale.English); if (string.IsNullOrEmpty(name)) { sender.Respond("No name given."); return; } if (name.Length < Constants.Accounts.MinNameLength || name.Length > Constants.Accounts.MaxNameLength) { sender.Respond("Name must be between {0} and {1} characters long.".Interpolate(Constants.Accounts.MinNameLength, Constants.Accounts.MaxNameLength)); return; } if (string.IsNullOrEmpty(password)) { sender.Respond("No password given."); return; } if (password.Length < Constants.Accounts.MinPasswordLength || password.Length > Constants.Accounts.MaxPasswordLength) { sender.Respond("Password must be between {0} and {1} characters long.".Interpolate(Constants.Accounts.MinPasswordLength, Constants.Accounts.MaxPasswordLength)); return; } if (string.IsNullOrEmpty(email)) { sender.Respond("No email given."); return; } AccountManager.Instance.PostAsync(x => x.CreateAccount(name, password, email, box, locale)); }
/// <summary> /// Creates a <see cref="WorkspaceCommandTriggerData"/> object /// </summary> public CommandTriggerData Create( ICommandUser user, Command command, ICommandInputState inputState ) { return new WorkspaceCommandTriggerData( m_Workspace, user, command, inputState ); }
/// <summary> /// Setup constructor /// </summary> /// <param name="user">User that triggered the command</param> /// <param name="command">Command that was triggered</param> /// <param name="inputState">Command input state</param> public CommandTriggerData( ICommandUser user, Command command, ICommandInputState inputState ) { m_User = user; m_Command = command; m_InputState = inputState; }
/// <summary> /// Creates a monitor for this binding. /// </summary> /// <remarks> /// A binding monitor is an object that monitors a particular input source (e.g. control) for input that /// matches this binding. /// </remarks> public virtual ICommandInputBindingMonitor CreateMonitor( ICommandInputBindingMonitorFactory factory, ICommandUser user ) { return factory.CreateBindingMonitor( this, user ); }
/// <summary> /// Setup constructor /// </summary> /// <param name="workspace">Workspace that the command was triggered in</param> /// <param name="user">User that triggered the command</param> /// <param name="command">Command that was triggered</param> /// <param name="inputState">Command input state</param> public WorkspaceCommandTriggerData( IWorkspace workspace, ICommandUser user, Command command, ICommandInputState inputState ) : base(user, command, inputState) { Arguments.CheckNotNull( workspace, "workspace" ); m_Workspace = workspace; }
/// <summary> /// Creates a monitor for an unknown binding type /// </summary> /// <exception cref="ArgumentNullException">Thrown if binding or user are null</exception> /// <exception cref="NotSupportedException">Always thrown</exception> public virtual ICommandInputBindingMonitor CreateBindingMonitor( CommandInputBinding binding, ICommandUser user ) { Arguments.CheckNotNull( binding, "binding" ); Arguments.CheckNotNull( user, "user" ); throw new NotSupportedException( "Unsupported binding type " + binding.GetType( ) ); }
/// <summary> /// Executes the command. /// </summary> /// <param name="args">The arguments to the command.</param> /// <param name="sender">The sender of the command (may be null in the case of the console).</param> /// <returns>Whether or not arguments were valid.</returns> public abstract void Execute(CommandArguments args, ICommandUser sender);
/// <summary> /// Creates the camera used by the main display /// </summary> private ICamera CreateCamera( ICommandUser user ) { FirstPersonCamera camera = new FirstPersonCamera( ); camera.PerspectiveZNear = 1.0f; camera.PerspectiveZFar = 15000.0f; Units.Metres cameraPos = BuilderState.Instance.SpherePlanet.PlanetModel.Radius; if ( BuilderState.Instance.SpherePlanet.PlanetModel.TerrainModel != null ) { cameraPos += BuilderState.Instance.SpherePlanet.PlanetModel.TerrainModel.MaximumHeight; } else { cameraPos += new Units.Metres( 1000000 ); } camera.Position = new UniPoint3( cameraPos.ToUniUnits, 0, 0 ); new FirstPersonCameraController( user, camera ); testDisplay.OnBeginRender += delegate { InteractionUpdateTimer.Instance.OnUpdate( ); }; CommandControlInputSource.StartMonitoring( user, testDisplay, FirstPersonCameraCommands.DefaultBindings ); return camera; }
public Command(ICommandUser commandUser) { this.commandUser = commandUser; }
/// <summary> /// Attaches this controller to a user /// </summary> /// <param name="user">User to attach to</param> public FirstPersonCameraController( ICommandUser user ) : this(user, null) { }
public override void Execute(CommandArguments args, ICommandUser sender) { Contract.Requires(args != null); }
public override void Execute(CommandArguments args, ICommandUser sender) { CommandConsole.StopConsole = true; }
/// <summary> /// Creates a CommandTriggerData object /// </summary> public CommandTriggerData Create( ICommandUser user, Command command, ICommandInputState inputState ) { return new CommandTriggerData( user, command, inputState ); }
public AddCommand(ICommandUser commandUser, int number) : base(commandUser) { this.number = number; }
/// <summary> /// Setup constructor /// </summary> /// <param name="control">Control to monitor for mouse wheel events</param> /// <param name="binding">Input binding</param> /// <param name="user">Command user</param> public CommandMouseWheelInputBindingMonitor( Control control, CommandMouseWheelInputBinding binding, ICommandUser user ) : base(binding, user) { m_Control = control; }
/// <summary> /// Returns true if a specified command's monitor is active for a specified user /// </summary> public bool IsCommandTriggered( Command cmd, ICommandUser user ) { return IsCommandActive( cmd, GetSafeMonitorList( user ) ); }
/// <summary> /// Setup constructor /// </summary> /// <param name="binding">Input binding</param> /// <param name="user">Command user</param> public CommandBinaryInputBindingMonitor( CommandInputBinding binding, ICommandUser user ) : base(binding, user) { }
private List<ICommandInputBindingMonitor> GetSafeMonitorList( ICommandUser user ) { List<ICommandInputBindingMonitor> monitors; if ( !m_UserMonitors.TryGetValue( user, out monitors ) ) { monitors = new List<ICommandInputBindingMonitor>( ); m_UserMonitors[ user ] = monitors; } return monitors; }
/// <summary> /// Setup constructor /// </summary> /// <param name="binding">Input binding</param> /// <param name="user">Command user</param> public CommandInputBindingMonitor( CommandInputBinding binding, ICommandUser user ) { m_Binding = binding; m_User = user; }
/// <summary> /// Setup constructor /// </summary> /// <param name="user">User controlling the camera</param> public TrackingCameraController( ICommandUser user ) { user.CommandTriggered += HandleCommand; }