/// <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 fileName = args.NextString();
if (string.IsNullOrEmpty(fileName))
{
sender.Respond("No file name given.");
return;
}
AccountApplication.Instance.AccountDbContext.PostAsync(x => x.Schema.Export(fileName));
}
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));
}
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 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.");
}
/// <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 override void Execute(CommandArguments args, ICommandUser sender)
{
Contract.Requires(args != null);
}
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;
}
public override void Execute(CommandArguments args, ICommandUser sender)
{
CommandConsole.StopConsole = true;
}
/// <summary>
/// Setup constructor
/// </summary>
/// <param name="user">User controlling the camera</param>
public TrackingCameraController( ICommandUser user )
{
user.CommandTriggered += HandleCommand;
}
/// <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);
