public void ExecuteConnect()
{
if (!IsConnected)
{
_serialPort.PortName = ComPort;
_serialPort.BaudRate = 9600;
_serialPort.Parity = Parity.None;
_serialPort.StopBits = StopBits.One;
_serialPort.DataBits = 8;
_serialPort.Handshake = Handshake.None;
_serialPort.DataReceived += SerialPortDataReceivedHandler;
_serialPort.ReceivedBytesThreshold = Vallox.TelegramLength;
_serialPort.ReadBufferSize = 1024;
_serialPort.Open();
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
SetFanSpeedCommand.RaiseCanExecuteChanged();
ReadVariableCommand.RaiseCanExecuteChanged();
WriteVariableCommand.RaiseCanExecuteChanged();
RaisePropertyChanged("IsConnected");
}
}
public void Connected(string deviceId, PositionControllerResponse status)
{
Id = deviceId;
if (deviceId != null && this.positionController.IsOkStatus(status.Status))
{
maxPosition = 0;
IsConnected = true;
PacketsTotalNumber = 0;
PacketsFailuresNumber = 0;
PacketsCrcFailuresNumber = 0;
ConnectDisconnectTitle = TITLE_DISCONNECT;
}
else
{
maxPosition = 0;
IsConnected = false;
ConnectDisconnectTitle = TITLE_CONNECT;
}
SetStatus("Connection attempt", PositionControllerCommand.NONE, status);
DisconnectCommand.UpdateCanExecute();
EmergencyStopCommand.UpdateCanExecute();
ResetPositionControllerCommand.UpdateCanExecute();
CalibratePositionControllerCommand.UpdateCanExecute();
}
public QueueVM()
{
User = new User()
{
Id = 112,
Login = "******",
isActive = true,
isSendingData = false
};
QueueView = new QueueViewData();
QueueData = new QueueData();
QueueService = new QueueService(QueueData, User);
_connectCommand = new ConnectCommand(this);
_disconnectCommand = new DisconnectCommand(this);
//QueueView.AdditionalMessage = "Lorem ipsum loros dalej nie pamietam jak to leciało, ale potrzebuje troche wiecej tekstu";
QueueData.PropertyChanged += QueueData_PropertyChanged;
//QueueView.AdditionalMessage = "Lorem ipsum loros dalej nie pamietam jak to leciało, ale potrzebuje troche wiecej tekstu";
if (DesignerProperties.GetIsInDesignMode(new System.Windows.DependencyObject()))
{
QueueView.QueueNoMessage = "PB123456";
QueueView.AdditionalMessage = "Lorem ipsum loros dalej nie pamietam jak to leciało, ale potrzebuje troche wiecej tekstu";
}
}
public void SendDisconnectCommand(Client destination, DisconnectCommand command)
{
if (OnDisconnectCommand != null)
{
OnDisconnectCommand.Invoke(destination, command);
}
}
public async Task Should_Invoke_Disconnect_Domain_Event_On_Disconnect_User()
{
// arrange
Guid expectedConnectionUid = Guid.NewGuid();
Client expectedClient = new Client()
{
ConnectionUid = expectedConnectionUid
};
Client actualClient = null;
DisconnectCommand actualCommand = null;
ClientRepositoryMock.Setup(mock => mock.GetByUidAsync(expectedConnectionUid)).Returns(Task.FromResult(expectedClient));
DomainEvents.OnDisconnectCommand += (client, command) =>
{
actualClient = client;
actualCommand = command as DisconnectCommand;
return(Task.CompletedTask);
};
// act
await ChatFacade.DisconnectAsync(expectedConnectionUid);
// assert
Assert.IsNotNull(actualCommand);
Assert.AreEqual(expectedClient, actualClient);
}
private void Connect()
{
DisconnectCommand.Execute();
_mySocket = new WebSocket(WSEndPoint);
var observer = Observable
.Using(
() => _mySocket,
ws =>
Observable
.FromEventPattern <EventHandler <MessageEventArgs>, MessageEventArgs>(
handler => ws.OnMessage += handler,
handler => ws.OnMessage -= handler));
_myDisposable = observer.Subscribe(ep =>
{
Status = "WS Recieved";
ReceivedMessage = "received:" + ep.EventArgs.Data;
});
_mySocket.Connect();
Status = "WS Connected.";
}
public static void InitAllCommands()
{
ConnectIPCommand = new ConnectIPCommand();
PressPushButtonCommand = new PressPushButtonCommand();
PressRockerSwitchCommand = new PressRockerSwitchUpCommand();
SetHICommand = new SetHICommand();
PressRockerSwitchUpCommand = new PressRockerSwitchUpCommand();
PressRockerSwitchDownCommand = new PressRockerSwitchDownCommand();
CheckLEDStatusCommand = new CheckLEDStatusCommand();
DetectAudioShoeCommand = new DetectAudioShoeCommand();
UndetectAudioShoeCommand = new UndetectAudioShoeCommand();
DetectTCoilCommand = new DetectTCoilCommand();
UndetectTCoilCommand = new UndetectTCoilCommand();
EndlessVcUpCommand = new EndlessVcUpCommand();
EndlessVcDownCommand = new EndlessVcDownCommand();
GetRaspiConfigCommand = new GetRaspiConfigCommand();
SetReceiverCommand = new SetReceiverCommand();
ToggleRPIListViewCommand = new ToggleRPIListViewCommand();
ConnectPinsCommand = new ConnectPinsCommand();
ResetMuxCommand = new ResetMuxCommand();
ReadPinCommand = new ReadPinCommand();
WritePinCommand = new WritePinCommand();
ResetPinCommand = new ResetPinCommand();
AddRPCommand = new AddRPCommand();
RefreshRPListCommand = new RefreshRPListCommand();
DisconnectCommand = new DisconnectCommand();
}
public void OnBusyChanged(bool isBusy)
{
DisconnectCommand.UpdateCanExecute();
EmergencyStopCommand.UpdateCanExecute();
ResetPositionControllerCommand.UpdateCanExecute();
CalibratePositionControllerCommand.UpdateCanExecute();
}
public void DisconnectCommand_Verify_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
DisconnectCommand command = new DisconnectCommand(connection);
Assert.IsTrue(command.Verify(false));
}
private void InvalidateCommands()
{
RaisePropertyChanged(() => IsSessionActive);
CloseCommand.RaiseCanExecuteChanged();
ExportCommand.RaiseCanExecuteChanged();
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
}
public void DisconnectCommand_Construciton_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
DisconnectCommand command = new DisconnectCommand(connection);
Assert.AreSame(connection, command.Connection);
}
private void OnCasparCgConnectionStatusChanged(object sender, ConnectionEventArgs e)
{
RaisePropertyChanged(nameof(IsConnected));
ConnectCommand?.RaiseCanExecuteChanged();
DisconnectCommand?.RaiseCanExecuteChanged();
PlayCommand?.RaiseCanExecuteChanged();
VersionCommand?.RaiseCanExecuteChanged();
}
public override void Run()
{
Workbench wb = Workbench.Instance;
if (wb != null && !DisconnectCommand.CancelDisconnect())
{
wb.Close();
}
}
public async Task ExecuteTest()
{
var mockFileServer = new Mock <IServer>();
var client = new TcpClient();
var command = new DisconnectCommand(mockFileServer.Object, client);
await command.Execute();
mockFileServer.Verify(m => m.RequestDisconnection(client));
}
public void DisconnectCommand_CreateQuery_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
DisconnectCommand command = new DisconnectCommand(connection);
ClientQuery query = command.CreateQuery();
Assert.IsNotNull(query);
}
internal Field(Model.Field modelField, PropertyMatcherViewModel viewModel, ConnectionDirection direction)
{
ModelField = modelField;
ViewModel = viewModel;
Direction = direction;
_selectionStatus = SelectionStatus.NotSelected;
Disconnect = new DisconnectCommand(this);
}
public void Disconnect()
{
_room.RemoveConnection(_client.ConnectionId);
var response = new DisconnectCommand(_client.ConnectionId)
.Send(_commandBus);
if (response.UserLeavesChatRoom)
_room.NotifyLeaveRoom(_client.Username, response.Timestamp);
}
public async Task <IActionResult> Disconnect()
{
var result = await _bus.Send(DisconnectCommand.Create());
if (result)
{
return(Ok());
}
return(BadRequest(result.FailureReason));
}
private void HandleSelectedDevice(DeviceListItemViewModel device)
{
var config = new ActionSheetConfig();
if (device.IsConnected)
{
config.Add("Details", () =>
{
ShowViewModel <ServiceListViewModel>(new MvxBundle(new Dictionary <string, string> {
{ DeviceIdKey, device.Device.Id.ToString() }
}));
});
config.Add("Update RSSI", async() =>
{
try
{
_userDialogs.ShowLoading();
await device.Device.UpdateRssiAsync();
device.RaisePropertyChanged(nameof(device.Rssi));
_userDialogs.HideLoading();
_userDialogs.Toast($"RSSI updated {device.Rssi}", TimeSpan.FromSeconds(1000));
}
catch (Exception ex)
{
_userDialogs.HideLoading();
await _userDialogs.AlertAsync($"Failed to update rssi. Exception: {ex.Message}");
}
});
config.Destructive = new ActionSheetOption("Disconnect", () => DisconnectCommand.Execute(device));
}
else
{
config.Add("Connect", async() =>
{
if (await ConnectDeviceAsync(device))
{
var navigation = Mvx.Resolve <IMvxNavigationService>();
await navigation.Navigate <ServiceListViewModel, MvxBundle>(new MvxBundle(new Dictionary <string, string> {
{ DeviceIdKey, device.Device.Id.ToString() }
}));
}
});
config.Add("Connect & Dispose", () => ConnectDisposeCommand.Execute(device));
}
config.Add("Copy GUID", () => CopyGuidCommand.Execute(device));
config.Cancel = new ActionSheetOption("Cancel");
config.SetTitle("Device Options");
_userDialogs.ActionSheet(config);
}
public void Update()
{
ModuleName = service.Name;
appMapper.UpdateCollection(service.Applications.SelectMany(app => app.Instances.Select(inst => Tuple.Create(app, inst))), Applications);
RefreshCommand.UpdateState();
ConnectCommand.UpdateState();
DisconnectCommand.UpdateState();
DeregisterApplicationsCommand.UpdateState();
}
public void DisconnectCommand_CheckResponse_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
DisconnectCommand command = new DisconnectCommand(connection);
ResponseBuilder builder = new ResponseBuilder();
builder.Append(0).NewLine();
byte[] bytes = builder.Encode();
ServerResponse response = new ServerResponse(connection, bytes, bytes, true);
command.CheckResponse(response);
}
public void ExecuteDisconnect()
{
if (IsConnected)
{
_serialPort.Close();
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
SetFanSpeedCommand.RaiseCanExecuteChanged();
ReadVariableCommand.RaiseCanExecuteChanged();
WriteVariableCommand.RaiseCanExecuteChanged();
}
}
public void Execute(DisconnectCommand _)
{
if (Connection == null)
{
Console.WriteLine("There is no connection to server!");
return;
}
Connection.Disconect();
Connection = null;
Console.WriteLine("Disconnected");
}
/// <summary>
/// toggles between the states of enable/disable of the connect/disconnect command buttons, with a slight delay to prevent connection spamming
/// </summary>
/// <param name="delay"></param>
private async void ToggleBlockConnectionCommands(bool delay)
{
if (delay)
{
await Task.Factory.StartNew(() => Thread.Sleep(1000));
}
BlockConnectionCommands = !BlockConnectionCommands;
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
SendTextCommand.RaiseCanExecuteChanged();
RollDiceCommand.RaiseCanExecuteChanged();
}
public void CreateDisconnectCommand()
{
// Arrange
const int commandId = 3;
// Act
var disconnectCommand = new DisconnectCommand(commandId);
// Assert
Assert.AreEqual(commandId, disconnectCommand.Id);
Assert.AreEqual(
string.Format(
"{{\"command\":\"disconnect\",\"seq\":{0},\"type\":\"request\",\"arguments\":null}}",
commandId),
disconnectCommand.ToString());
}
public async Task SendMessageViaDebuggerClient()
{
// Arrange
var connectionMock = new Mock <IDebuggerConnection>();
var messageEventArgs = new MessageEventArgs(Resources.NodeDisconnectResponse);
connectionMock.Setup(p => p.SendMessage(It.IsAny <string>()))
.Raises(f => f.OutputMessage += null, messageEventArgs);
var client = new DebuggerClient(connectionMock.Object);
var disconnectCommand = new DisconnectCommand(10);
// Act
await client.SendRequestAsync(disconnectCommand);
// Assert
Assert.IsTrue(disconnectCommand.Running);
}
public DoctorsWindowVM(IQueueServiceAPI queueServiceApi)
{
_queueServiceApi = queueServiceApi;
_user = new User()
{
Id = 1,
Login = "******",
FirstName = "Piotr",
LastName = "Bakun",
isActive = true,
Email = "*****@*****.**"
};
//Create new QueueData with default values and initials in
_queueData = new QueueDataBuilder().WithUserInitials(String.Concat(_user.FirstName.First(), _user.LastName.First())).WithRoomNo(12).Build();
//Call QueueSystem service
_queueServiceApi.SetData(_queueData, _user);
//Commands
_connectCommand = new ConnectCommand(this);
_disconnectCommand = new DisconnectCommand(this);
_nextPersonCommand = new NextPersonCommand(this);
_previousPersonCommand = new PreviousPersonCommand(this);
_forceNewPersonCommand = new ForceNewPersonCommand(this);
_breakCommand = new BreakCommand(this);
_sendAdditionalMessageCommand = new SendAdditionalMessageCommand(this);
_clearRichTextBoxCommand = new ClearRichTextBoxCommand(this);
//Initiate data for View (UI)
ViewData = new DoctorsViewData();
_queueData.PropertyChanged += _queueData_PropertyChanged;
//Generate UI stuff for designing xaml
if (DesignerProperties.GetIsInDesignMode(new System.Windows.DependencyObject()))
{
_queueData = new QueueData()
{
QueueNoMessage = "PB01",
AdditionalMessage = "Some additional Message",
Owner = "piotr.bakun",
};
}
}
public void DisconnectCommand_ExecuteRequest_1()
{
int returnCode = 0;
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
DisconnectCommand command = new DisconnectCommand(connection);
ResponseBuilder builder = new ResponseBuilder()
.StandardHeader(CommandCode.UnregisterClient, 123, 456)
.NewLine()
.Append(returnCode)
.NewLine();
TestingSocket socket = (TestingSocket)connection.Socket;
socket.Response = builder.Encode();
ClientQuery query = command.CreateQuery();
ServerResponse response = command.Execute(query);
Assert.AreEqual(returnCode, response.ReturnCode);
}
public void Connected(string deviceId, bool isConnected)
{
Id = deviceId;
if (isConnected)
{
IsConnected = true;
ConnectDisconnectTitle = TITLE_DISCONNECT;
}
else
{
IsConnected = false;
ConnectDisconnectTitle = TITLE_CONNECT;
}
DisconnectCommand.UpdateCanExecute();
ResetLineSensorCommand.UpdateCanExecute();
ResetWirelessLineSensorCommand.UpdateCanExecute();
}
public ConnectionViewModel()
{
DisconnectCommand = IsConnected.CombineLatest(IsConnecting, (a, b) => a || b).ToAsyncReactiveCommand();
DisconnectCommand.Subscribe(() => Disconnect()).AddTo(Disposable);
DisplayText = ConnectionName.CombineLatest(Host, Port, IsConnecting,
(name, host, port, isConnecting) =>
{
var hostport = host + (port == null ? "" : $":{port}");
var status = "";
if (isConnecting)
{
status = $" - {Resources.Connection_ConnectingText}";
}
var identity = string.IsNullOrWhiteSpace(name)
? hostport
: $"{name} ({hostport})";
return(identity + status);
}).ToReactiveProperty();
}
private void HandleSelectedDevice(DeviceListItemViewModel device, int type)
{
//type = 1 if slave, type = 2 if master.
var config = new ActionSheetConfig();
if (device.IsConnected)
{
config.Destructive = new ActionSheetOption("Disconnect", () => DisconnectCommand.Execute(device));
}
else
{
config.Add("Connect", async() => {
if (await ConnectDeviceAsync(device))
{
switch (type)
{
case 1:
device.IsSlave = true;
GraphViewModel.SlaveDeviceId = device.Device.Id;
var ServiceSlave = await device.Device.GetServiceAsync(Guid.Parse("0000180d-0000-1000-8000-00805f9b34fb"));
var CharacteristicSlave = await ServiceSlave.GetCharacteristicAsync(Guid.Parse("00002a37-0000-1000-8000-00805f9b34fb"));
await CharacteristicSlave.StartUpdatesAsync();
break;
case 2:
device.IsMaster = true;
GraphViewModel.MasterDeviceId = device.Device.Id;
var ServiceMaster = await device.Device.GetServiceAsync(Guid.Parse("0000180d-0000-1000-8000-00805f9b34fb"));
var CharacteristicMaster = await ServiceMaster.GetCharacteristicAsync(Guid.Parse("00002a37-0000-1000-8000-00805f9b34fb"));
await CharacteristicMaster.StartUpdatesAsync();
break;
}
}
});
}
config.Cancel = new ActionSheetOption("Cancel");
config.SetTitle("Device Options");
_userDialogs.ActionSheet(config);
}
private void DisconnectGluePoints(IDiagramPresenter diagramPresenter) {
foreach (Shape selectedShape in diagramPresenter.SelectedShapes) {
foreach (ControlPointId ptId in selectedShape.GetControlPointIds(ControlPointCapabilities.Connect | ControlPointCapabilities.Glue)) {
// disconnect GluePoints if they are moved together with their targets
bool skip = false;
foreach (ShapeConnectionInfo ci in selectedShape.GetConnectionInfos(ptId, null)) {
if (ci.OwnPointId != ptId) throw new NShapeInternalException("Fatal error: Unexpected ShapeConnectionInfo was returned.");
if (diagramPresenter.SelectedShapes.Contains(ci.OtherShape)) {
skip = false;
break;
}
}
if (skip) continue;
// otherwise, compare positions of the GluePoint with it's targetPoint and disconnect if they are not equal
if (selectedShape.HasControlPointCapability(ptId, ControlPointCapabilities.Glue)) {
Shape previewShape = FindPreviewOfShape(selectedShape);
if (selectedShape.GetControlPointPosition(ptId) != previewShape.GetControlPointPosition(ptId)) {
bool isConnected = false;
foreach (ShapeConnectionInfo sci in selectedShape.GetConnectionInfos(ptId, null)) {
if (sci.OwnPointId == ptId) {
isConnected = true;
break;
} else throw new NShapeInternalException("Fatal error: Unexpected ShapeConnectionInfo was returned.");
}
if (isConnected) {
ICommand cmd = new DisconnectCommand(selectedShape, ptId);
diagramPresenter.Project.ExecuteCommand(cmd);
}
}
}
}
}
}
