public static void SerializeConnect(IStreamWriter writer, ConnectCommand connect)
{
VersionSerializer.SerializeVersion(writer, connect.ProtocolVersion);
var realm = connect.Realm;
writer.WriteString(realm);
}
/// <summary>Initializes a new instance of the MatchViewModel class.</summary>
/// <param name="endpoint">EndPoint to connect to.</param>
public MatchViewModel(IPEndPoint endpoint)
{
var matchService = ServiceLocator.MatchService;
// realm
Entities = new ObservableCollection<object>();
Realm = new Realm(new IRealmBehavior[] {
new UpdatePlayerPositionRealmBehavior(),
new UpdateBallPositionRealmBehavior(),
new UpdateBulletPositionRealmBehavior()
});
// Commands
KeyPressCommand = new KeyPressCommand(matchService);
MouseMoveCommand = new MouseMoveCommand(matchService);
MouseLeftButtonDownCommand = new MouseLeftButtonDownCommand(matchService);
MouseRightButtonDownCommand = new MouseRightButtonDownCommand(matchService);
ConnectCommand = new ConnectCommand(matchService, endpoint);
// Behaviors
ConnectionStateChangedBehavior = new ConnectionStateChangedBehavior(this);
EntityModelStateChangedBehavior = new EntityModelStateChangedBehavior(this);
EntityViewModelStateChangedBehavior = new EntityViewModelStateChangedBehavior(this);
CameraFollowBehavior = new CameraFollowBehavior(this);
UpdateRealmBehavior = new UpdateRealmBehavior(this);
// MatchService events
matchService.ConnectionStateChanged += (s, e) => ConnectionStateChangedBehavior.Handle(e.ConnectionState);
matchService.EntityStateChanged += (s, e) => EntityModelStateChangedBehavior.Handle(e.Entity, e.EntityState);
Entities.CollectionChanged += (s, e) => { lock (Realm) { EntityViewModelStateChangedBehavior.Handle(e); } };
CompositionTarget.Rendering += (s, e) => { lock (Realm) { UpdateRealmBehavior.Handle(); } };
CompositionTarget.Rendering += (s, e) => CameraFollowBehavior.Handle(matchService.GetMyPlayer());
}
public void ConnectCommand_ExecuteRequest_2()
{
int returnCode = 0;
string configuration = "Some=Text";
Mock <IIrbisConnection> mock = GetConnectionMock();
mock.SetupGet(c => c.Connected).Returns(true);
IIrbisConnection connection = mock.Object;
ConnectCommand command = new ConnectCommand(connection)
{
Username = "******",
Password = "******"
};
ResponseBuilder builder = new ResponseBuilder()
.AppendAnsi(CommandCode.RegisterClient).NewLine()
.AppendAnsi("12345678").NewLine()
.AppendAnsi("1").NewLine()
.AppendAnsi("123").NewLine()
.AppendAnsi("64.2014").NewLine()
.NewLine()
.NewLine()
.NewLine()
.NewLine()
.NewLine()
.Append(returnCode).NewLine()
.AppendAnsi("30").NewLine()
.AppendAnsi(configuration);
TestingSocket socket = (TestingSocket)connection.Socket;
socket.Response = builder.Encode();
ClientQuery query = command.CreateQuery();
command.Execute(query);
}
public async Task ExecuteAsync_SwaggerOnlyWithNoBase_ShowsWarning()
{
string swaggerAddress = "https://localhost/v2/swagger.json";
string swaggerContent = @"{
""openapi"": ""3.0.0"",
""info"": {
""version"": ""v1""
},
""paths"": {
""/pets"": {
}
}
}";
ArrangeInputs(commandText: $"connect --swagger {swaggerAddress}",
baseAddress: null,
path: null,
urlsWithResponse: new Dictionary <string, string>()
{
{ swaggerAddress, swaggerContent }
},
out MockedShellState shellState,
out HttpState httpState,
out ICoreParseResult parseResult,
out _,
out IPreferences preferences);
ConnectCommand connectCommand = new ConnectCommand(preferences);
await connectCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);
Assert.Null(httpState.BaseAddress);
Assert.Contains(Resources.Strings.ConnectCommand_Status_NoBase, shellState.Output, StringComparer.Ordinal);
}
private async Task TimerCallbackAsync()
{
var rv = await CreateNewClientAsync(_settings.DeviceType, _settings.ApplicationID);
if (rv.IsError())
{
Error error = ((HueObjectCollectionBase <Error>)rv).Dictionary["0"];
if (error.Type == 101)
{
}
else
{
// some other error occured;
_messageHandler.HideMessageBox();
}
}
else
{
_messageHandler.HideMessageBox();
await LoginAsync(_settings.ApplicationID);
_context.Post(o => ExecuteGetLightsAsync(), this);
_context.Post(o => ExecuteGetGroupsAsync(), this);
IsConnecting = false;
RaisePropertyChanged("IsConnected");
ConnectCommand.RaiseCanExecuteChanged();
}
}
/// <summary>
///
/// </summary>
public void CheckAutoConnect()
{
if (!string.IsNullOrEmpty(ServerAddress))
{
ConnectCommand.Execute(null);
}
}
public async Task <bool> ConnectAsync()
{
IsConnecting = true;
ConnectCommand.RaiseCanExecuteChanged();
_bridge.Connect();
HueObjectBase rv = await LoginAsync(_settings.ApplicationID.Value);
if (rv.IsError())
{
EventHandler eventHandler = async(s, e) => await TimerCallbackAsync();
await _messageHandler.GetResponseAsync("Information", string.Format("Please press the Link button on your bridge."), 500, 30000, MessageBoxButtons.None, eventHandler);
return(false);
}
ExecuteGetLightsAsync();
ExecuteGetGroupsAsync();
IsConnecting = false;
RaisePropertyChanged("IsConnected");
ConnectCommand.RaiseCanExecuteChanged();
return(true);
}
public void AddToLog(ICommand command)
{
switch (command.CommandType)
{
case CommandType.Connect:
ConnectCommand <ServerPlayer> connectCommand = (ConnectCommand <ServerPlayer>)command;
break;
case CommandType.Goodbye:
break;
case CommandType.Disconnect:
break;
case CommandType.Movement:
break;
case CommandType.Location:
break;
case CommandType.Interact:
break;
default:
break;
}
}
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 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");
}
}
private void RefreshCommandExecuteStatus()
{
ConnectCommand.RaiseCanExecuteChanged();
ClearAlarmCommand.RaiseCanExecuteChanged();
SendGCodeFileCommand.RaiseCanExecuteChanged();
StartProbeCommand.RaiseCanExecuteChanged();
StartProbeHeightMapCommand.RaiseCanExecuteChanged();
StopCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
SoftResetCommand.RaiseCanExecuteChanged();
HomingCycleCommand.RaiseCanExecuteChanged();
FeedHoldCommand.RaiseCanExecuteChanged();
CycleStartCommand.RaiseCanExecuteChanged();
EmergencyStopCommand.RaiseCanExecuteChanged();
LaserOnCommand.RaiseCanExecuteChanged();
LaserOffCommand.RaiseCanExecuteChanged();
SpindleOnCommand.RaiseCanExecuteChanged();
SpindleOffCommand.RaiseCanExecuteChanged();
GotoFavorite1Command.RaiseCanExecuteChanged();
GotoFavorite2Command.RaiseCanExecuteChanged();
SetFavorite1Command.RaiseCanExecuteChanged();
SetFavorite2Command.RaiseCanExecuteChanged();
GotoWorkspaceHomeCommand.RaiseCanExecuteChanged();
SetWorkspaceHomeCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Connects this instance and properly sets the
/// client stream to Use Ssl if it is specified.
/// </summary>
public void Connect()
{
if (_client == null)
{
_client = new TcpClient();
} //If a previous quit command was issued, the client would be disposed of.
_client.ReceiveTimeout = (int)TimeSpan.FromMinutes(Timeout).TotalMilliseconds;
_client.SendTimeout = (int)TimeSpan.FromMinutes(Timeout).TotalMilliseconds;
if (_client.Connected)
{
return;
} //if the connection already is established no need to reconnect.
SetState(Pop3State.Unknown);
ConnectResponse response;
using (ConnectCommand command = new ConnectCommand(_client, Hostname, Port, UseSsl))
{
TraceCommand <ConnectCommand, ConnectResponse>(command);
response = command.Execute(CurrentState);
EnsureResponse(response);
}
SetClientStream(response.NetworkStream);
SetState(Pop3State.Authorization);
}
protected override void OnInitialized()
{
base.OnInitialized();
if (!MonitorSettings.ContainsKey(TfsBuildProviderBase.ProjectCredentialsSettingKey))
{
MonitorSettings[TfsBuildProviderBase.ProjectCredentialsSettingKey] = CredentialCache.DefaultCredentials;
}
SetDisplayName(MonitorSettings.SelectedBuildDefinitions);
UpdateSelectedCollection();
// ReSharper disable once ExplicitCallerInfoArgument
OnPropertyChanged(nameof(ProjectUrl));
ConnectCommand?.RaiseCanExecuteChanged();
if (!SupportsDefaultCredentials && SupportsPersonalAccessToken)
{
ShowPersonalAccessTokenInput = true;
if (MonitorSettings.ContainsKey(TfsBuildProviderBase.PersonalAccessTokenSettingsKey))
{
var token = MonitorSettings?.GetDefaultValueIfNotExists <String>(TfsBuildProviderBase.PersonalAccessTokenSettingsKey);
if (!String.IsNullOrWhiteSpace(token))
{
ShowPersonalAccessTokenInput = false;
}
}
}
}
public async Task Login(string name)
{
await this.client.ConnectAsync("127.0.0.1", 1234);
User = new User
{
Id = Guid.NewGuid(),
Nickname = name
};
IChatCommand command = new ConnectCommand
(
User,
DateTime.Now,
true
);
this.commandsQueue = this.commandsQueue.Enqueue(command);
Thread thread = new Thread(HandleCommands)
{
IsBackground = true
};
thread.Start();
}
public async Task ExecuteAsync_WithOnlyRoot_SendsTelemetry()
{
string rootAddress = "https://localhost/";
ArrangeInputs($"connect {rootAddress}",
out MockedShellState shellState,
out HttpState httpState,
out ICoreParseResult parseResult,
out IPreferences preferences,
fileContents: "");
TelemetryCollector telemetry = new TelemetryCollector();
ConnectCommand connectCommand = new ConnectCommand(preferences, telemetry);
await connectCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);
Assert.Single(telemetry.Telemetry);
TelemetryCollector.CollectedTelemetry collectedTelemetry = telemetry.Telemetry[0];
Assert.Equal("connect", collectedTelemetry.EventName, ignoreCase: true);
Assert.Equal("True", collectedTelemetry.Properties["RootSpecified"]);
Assert.Equal("False", collectedTelemetry.Properties["BaseSpecified"]);
Assert.Equal("False", collectedTelemetry.Properties["OpenApiSpecified"]);
Assert.Equal("False", collectedTelemetry.Properties["OpenApiFound"]);
}
public void Connect()
{
ConnectCommand._checkCanExecute = () => { return(false); };
ConnectCommand.RaiseCanExecuteChanged();
ConnectCommand._checkCanExecute = () => { return(!Connector.IsConnected); };
IsLoadingAnimationVisible = true;
Thread connectThread = new Thread(() =>
{
try
{
Connector.Connect();
}
catch
{
Connector.Status = "Fail";
}
System.Windows.Threading.Dispatcher.CurrentDispatcher.Invoke(() =>
{
IsLoadingAnimationVisible = false;
});
Application.Current.Dispatcher.Invoke(() =>
{
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
});
});
connectThread.Start();
}
public ViewModelBase()
{
connection = new Connection();
connectCommand = new ConnectCommand(this);
removeServiceCommand = new RemoveServiceCommand(this);
restartServiceCommand = new RestartServiceCommand(this);
updateServiceCommand = new UpdateServiceCommand(this);
upgradeApplicationCommand = new UpgradeApplicationCommand(this);
deleteApplicationCommand = new DeleteApplicationCommand(this);
refreshCommand = new RefreshCommand(this);
Applications = new ObservableCollection <ApplicationType>();
AppGridEnable = false;
ServiceGridEnable = false;
SFPowerShell.Initialize();
//ApplicationType ap = new ApplicationType("Id", "name", "TypeName", "version", "1");
//Service s = new Service("SId", "SName", "SType", "SVersion", "1", "1");
//ap.Services.Add(s);
//Parameter p = new Parameter("keykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykeykey", "valuevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevaluevalue");
//ap.ApplicationParameters.Add(p);
//Parameter p2 = new Parameter("key2", "value2");
//ap.ApplicationParameters.Add(p2);
//Applications.Add(ap);
//ApplicationType ap2 = new ApplicationType("Id2", "name2", "TypeName2", "version2", "1");
//Service s2 = new Service("SId2", "SName2", "SType2", "SVersion2", "1", "1");
//ap2.Services.Add(s2);
//Parameter p3 = new Parameter("key2", "value2");
//ap2.ApplicationParameters.Add(p3);
//Applications.Add(ap2);
}
private async void Connect_Execute(string arg)
{
try
{
AddUserCommand.RaiseCanExecuteChanged();
_isConnected = true;
Operation = OperProgress.Connecting.ToString();
ConnectCommand.RaiseCanExecuteChanged();
_model.CreateFirebaseApp(arg);
Users = new ObservableCollection <UserRecord>(await _model.GetUsers());
Users.CollectionChanged += Users_CollectionChanged;
}
catch (Exception e)
{
_isConnected = false;
MessageBox.Show(e.Message);
}
finally
{
ConnectCommand.RaiseCanExecuteChanged();
AddUserCommand.RaiseCanExecuteChanged();
Operation = OperProgress.Connect.ToString();
}
}
private void OnCasparCgConnectionStatusChanged(object sender, ConnectionEventArgs e)
{
RaisePropertyChanged(nameof(IsConnected));
ConnectCommand?.RaiseCanExecuteChanged();
DisconnectCommand?.RaiseCanExecuteChanged();
PlayCommand?.RaiseCanExecuteChanged();
VersionCommand?.RaiseCanExecuteChanged();
}
public void Should_Get_ConnectCommandHandler_When_Command_Is_Connect()
{
var command = new ConnectCommand();
var handler = CommandHandlerFactory.GetHandler(command);
Assert.IsAssignableFrom <ConnectCommandHandler>(handler);
}
public void ConnectCommand_CreateQuery_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
ConnectCommand command = new ConnectCommand(connection);
command.CreateQuery();
}
private void InitializeDefaults()
{
ItemList = new ObservableCollection <ListBoxItem>();
ConnectHub = new ConnectCommand(OnConnectButton);
SendMessage = new SendCommand(OnSendMessage);
isSendEnable = false;
isConnected = false;
}
private void Connect(ApplicationContext applicationContext, ConnectCommand connect)
{
applicationContext.Application.Server.Write(Components.LogType.Info, "connecting to " + connect.Server);
applicationContext.ServerContext = new ServerContext(connect.Server);
applicationContext.Application.Server.Write(Components.LogType.Info, "connected!");
}
private void InvalidateCommands()
{
RaisePropertyChanged(() => IsSessionActive);
CloseCommand.RaiseCanExecuteChanged();
ExportCommand.RaiseCanExecuteChanged();
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
}
public void ConnectCommand_Verify_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
ConnectCommand command = new ConnectCommand(connection);
Assert.IsFalse(command.Verify(false));
}
public FlightDisplayVM(IMainModel main, ISettingsModel settings)
{
MainModel = main;
SettingsModel = settings;
// connect the server and client upon initialization
ConnectCommand.Execute(null);
}
void InnerCommandPass(ConnectObjectFromClient clientData)
{
for (int i = 0; i < clientData.Commands.Length; i++)
{
ConnectCommand command = clientData.Commands[i];
PassCommand(command);
}
}
public void Disconnect()
{
//Connector.Stream = null;
Connector.Status = "Disconnected";
Connector.IsConnected = false;
ConnectCommand.RaiseCanExecuteChanged();
DisconnectCommand.RaiseCanExecuteChanged();
}
void InnerCommandPass(ConnectObjectFromServer serverData)
{
for (int i = 0; i < serverData.Commands.Length; i++)
{
ConnectCommand command = serverData.Commands[i];
PassCommand(command);
}
}
async Task Initialize()
{
var accounts = accountDataRepository?.GetAccounts();
if (accounts != null && accounts.Any())
{
Accounts = accounts;
if (accounts.Count == 1)
{
CurrentAccount = accounts[0];
#warning "Optimistic: any account/cookies is supposed valid, proper implementation needed (cookies timeout check)"
await ThreadUI.Invoke(() =>
{
Loc.NavigationService.Navigate(View.Connect);
Loc.Main.AccountManager.CurrentAccount.ConnectionErrorStatus = "Connecting";
Loc.Main.AccountManager.CurrentAccount.IsConnecting = true;
});
bool success = await CurrentAccount.BeginAuthentication(false);
if (success)
{
await ThreadUI.Invoke(() =>
{
Loc.Main.AccountManager.CurrentAccount.IsConnected = false;
Loc.NavigationService.Navigate(View.Main);
});
}
else
{
Debug.WriteLine("Login failed");
}
}
else
{
// Handle selection of one of the multi accounts
}
}
else
{
// navigate to connectpage
await ThreadUI.Invoke(() =>
{
CurrentAccount = new Account();
Loc.NavigationService.Navigate(View.Connect);
// Trying to detect login and password stored in RoamingSettings
if (ApplicationSettingsHelper.Contains(nameof(CurrentAccount.Pseudo), false) && ApplicationSettingsHelper.Contains(nameof(CurrentAccount.Password), false))
{
ToastHelper.Simple("Connexion automatique ...");
var pseudo = ApplicationSettingsHelper.ReadSettingsValue(nameof(CurrentAccount.Pseudo), false).ToString();
var password = ApplicationSettingsHelper.ReadSettingsValue(nameof(CurrentAccount.Password), false).ToString();
CurrentAccount.Pseudo = pseudo;
CurrentAccount.Password = password;
ConnectCommand.Execute(null);
}
});
}
}
public void ConnectCommand_Construciton_1()
{
Mock <IIrbisConnection> mock = GetConnectionMock();
IIrbisConnection connection = mock.Object;
ConnectCommand command = new ConnectCommand(connection);
Assert.AreSame(connection, command.Connection);
Assert.IsFalse(command.RequireConnection);
}
public void Connect()
{
var response = new ConnectCommand(_client.Username, _client.ConnectionId)
.Send(_commandBus);
if (response.FailedBecauseUserLimitReached)
_client.ConnectionFailedBecauseUserLimitReached();
else
ConnectionSucceed(response);
}
private void ConnectGluePoints(IDiagramPresenter diagramPresenter) {
foreach (Shape selectedShape in diagramPresenter.SelectedShapes) {
// find selectedShapes that own GluePoints
foreach (ControlPointId gluePointId in selectedShape.GetControlPointIds(ControlPointCapabilities.Glue)) {
Point gluePointPos = Point.Empty;
gluePointPos = selectedShape.GetControlPointPosition(gluePointId);
// find selectedShapes to connect to
foreach (Shape shape in FindVisibleShapes(diagramPresenter, gluePointPos.X, gluePointPos.Y, ControlPointCapabilities.Connect, diagramPresenter.GripSize)) {
if (diagramPresenter.SelectedShapes.Contains(shape)) {
// restore connections that were disconnected before
int targetPointId = shape.FindNearestControlPoint(gluePointPos.X, gluePointPos.Y, 0, ControlPointCapabilities.Connect);
if (targetPointId != ControlPointId.None)
selectedShape.Connect(gluePointId, shape, targetPointId);
} else {
ShapeAtCursorInfo shapeInfo = FindConnectionTarget(diagramPresenter, selectedShape, gluePointId, gluePointPos, true, true);
if (shapeInfo.ControlPointId != ControlPointId.None) {
ICommand cmd = new ConnectCommand(selectedShape, gluePointId, shapeInfo.Shape, shapeInfo.ControlPointId);
diagramPresenter.Project.ExecuteCommand(cmd);
}
//else if (shape.ContainsPoint(gluePointPos.X, gluePointPos.Y)) {
// ICommand cmd = new ConnectCommand(selectedShape, gluePointId, shape, ControlPointId.Reference);
// display.Project.ExecuteCommand(cmd);
//}
}
}
}
}
}