private void RaiseButtonCanExecuteEvent()
{
AppraisalCommand.RaiseCanExecuteChanged();
UsersCommand.RaiseCanExecuteChanged();
ReportCommand.RaiseCanExecuteChanged();
SetupCommand.RaiseCanExecuteChanged();
}
public void ShouldFetchMaxLibVersionOnlyOnce()
{
var setupCommand = new SetupCommand(_packageRepositoryFactory.Object);
var maxLibVersion = setupCommand.MaxLibVersion;
maxLibVersion = setupCommand.MaxLibVersion; // call again, just for fun!
Assert.AreEqual(Version, maxLibVersion.ToString());
_packageRepositoryFactory.Verify(factory => factory.CreateRepository(SetupCommand.NugetEndpoint), Times.Once);
}
private void frmMain_Load(object sender, EventArgs e)
{
ConfigureAnnunciators();
var clientStatusObservable = Observable.FromEventPattern <EventHandler <EventArgs>, EventArgs>(
handler => SharedResources.ConnectionManager.ClientStatusChanged += handler,
handler => SharedResources.ConnectionManager.ClientStatusChanged -= handler);
clientStatusSubscription = clientStatusObservable.ObserveOn(SynchronizationContext.Current)
.Subscribe(ObserveClientStatusChanged);
ObserveClientStatusChanged(null); // This sets the initial UI state before any notifications arrive
SetupCommand.AttachCommand(ExecuteSetupDialog, CanSetup);
this.EnsureVisible();
}
public void LoadAllCommands()
{
//OrderCommand order = new OrderCommand();
CommandsCommand help = new CommandsCommand();
EnterCommand enter = new EnterCommand();
CheckinCommand checkin = new CheckinCommand();
CheckoutCommand checkout = new CheckoutCommand();
CurrentSetupCommand currentsetup = new CurrentSetupCommand();
SetupCommand setup = new SetupCommand();
this.Commands = new Collection <ICommand>()
{
help, enter, checkin, checkout, currentsetup, setup
};
}
/// <summary>
/// Genericized function to send commands to a Particle device in listening mode
/// </summary>
/// <param name="setupCommand">The SetupCommand to use</param>
/// <param name="data">Any extra data to send with the command</param>
/// <returns></returns>
private static async Task <string> SendSoftAPCommandAsync(SetupCommand setupCommand, string data = null)
{
string hostname = "192.168.0.1";
string command;
switch (setupCommand)
{
case SetupCommand.Version:
command = "version";
break;
case SetupCommand.DeviceId:
command = "device-id";
break;
case SetupCommand.ScanAP:
command = "scan-ap";
break;
case SetupCommand.PublicKey:
command = "public-key";
break;
case SetupCommand.ConfigureAP:
command = "configure-ap";
break;
case SetupCommand.ConnectAP:
command = "connect-ap";
break;
case SetupCommand.Set:
command = "set";
break;
default:
return(null);
}
int dataLength = 0;
if (data != null)
{
dataLength = data.Length;
}
using (Sockets.Plugin.TcpSocketClient socket = new Sockets.Plugin.TcpSocketClient())
{
try
{
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(5000);
await socket.ConnectAsync(hostname, 5609, false, cancellationTokenSource.Token);
var dataToSend = $"{command}\n{dataLength}\n\n";
if (data != null)
{
dataToSend += data;
}
var bytes = Encoding.UTF8.GetBytes(dataToSend);
await socket.WriteStream.WriteAsync(bytes, 0, bytes.Length);
await socket.WriteStream.FlushAsync();
var buffer = new byte[2048];
var cancellationTokenSourceRead = new CancellationTokenSource();
cancellationTokenSourceRead.CancelAfter(10000);
int count = await socket.ReadStream.ReadAsync(buffer, 0, buffer.Length, cancellationTokenSourceRead.Token);
var receivedData = "";
if (count > 0)
{
receivedData = Encoding.UTF8.GetString(buffer, 0, count);
}
if (string.IsNullOrWhiteSpace(receivedData))
{
return(null);
}
return(receivedData);
}
catch (Exception exception)
{
throw exception;
}
return(null);
}
}
//----------------------------[ Actions ]------------------
private void updateCommand()
{
UtilitiesCommand.raiseCanExecuteActionChanged();
SetupCommand.raiseCanExecuteActionChanged();
}
public async Task <ActionResult <Authenticator> > Setup([FromBody] SetupCommand command)
{
return(await Mediator.Send(command));
}
public SetupCommandTests()
{
_sut = new SetupCommand(_clientMock.Object, _jobMock.Object,
new LoggerMock <SetupCommand>(), _updaterMock.Object);
}
/// <summary>
/// Genericized function to send commands to a Particle device in listening mode
/// </summary>
/// <param name="setupCommand">The SetupCommand to use</param>
/// <param name="data">Any extra data to send with the command</param>
/// <returns></returns>
private static async Task <string> SendSoftAPCommandAsync(SetupCommand setupCommand, string data = null)
{
HostName hostname = new HostName("192.168.0.1");
string command;
switch (setupCommand)
{
case SetupCommand.Version:
command = "version";
break;
case SetupCommand.DeviceId:
command = "device-id";
break;
case SetupCommand.ScanAP:
command = "scan-ap";
break;
case SetupCommand.PublicKey:
command = "public-key";
break;
case SetupCommand.ConfigureAP:
command = "configure-ap";
break;
case SetupCommand.ConnectAP:
command = "connect-ap";
break;
case SetupCommand.Set:
command = "set";
break;
default:
return(null);
}
int dataLength = 0;
if (data != null)
{
dataLength = data.Length;
}
using (StreamSocket socket = new StreamSocket())
using (DataWriter writer = new DataWriter(socket.OutputStream))
using (DataReader reader = new DataReader(socket.InputStream))
{
reader.InputStreamOptions = InputStreamOptions.Partial;
try
{
var socketOperation = socket.ConnectAsync(hostname, "5609");
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(5000);
Task socketTask = socketOperation.AsTask(cancellationTokenSource.Token);
await socketTask;
writer.WriteString($"{command}\n{dataLength}\n\n");
if (data != null)
{
writer.WriteString(data);
}
string receivedData = "";
await writer.StoreAsync();
uint count = await reader.LoadAsync(2048);
if (count > 0)
{
receivedData = reader.ReadString(count);
}
if (string.IsNullOrWhiteSpace(receivedData))
{
return(null);
}
return(receivedData);
}
catch (TaskCanceledException)
{
}
catch (Exception exception)
{
switch (SocketError.GetStatus(exception.HResult))
{
case SocketErrorStatus.HostNotFound:
break;
default:
break;
}
}
return(null);
}
}
