public void SyncValidator_FullPath_is_valid_if_is_valid_path() { var command = new SyncCommand(_validPath); _validator .ShouldNotHaveValidationErrorFor(t => t.FullPath, command); }
/// <summary> /// Event handler for sync menu entries /// </summary> private void OnSyncWithSafeVault(object sender, EventArgs e) { ToolStripItem item = (ToolStripItem)sender; SyncCommand syncCommand = (SyncCommand)Enum.Parse(typeof(SyncCommand), item.Name); SyncWithSafeVault(syncCommand); }
public (SyncSummary sum, List <PreSyncDetails> Changes) SyncDecr2andEncr1(Action <PreSyncDetails> onPreSyncDetails = null) { List <PreSyncDetails> changes = new List <PreSyncDetails>(); SyncOptions options = new SyncOptions { DecrDirectory = Decr2.DirectoryPath, EncrDirectory = Encr1.DirectoryPath, Password = "******", Initialize = true }; ConsoleEx console = new ConsoleEx { BeforeWriteLine = (o) => { if (o is PreSyncDetails preSync) { onPreSyncDetails?.Invoke(preSync); changes.Add(preSync); } System.Diagnostics.Debug.WriteLine(o); } }; var sum = SyncCommand.Sync(options, console, HelixFileVersion.UnitTest); return(sum, changes); }
public MainViewModel(FileService fileService) { _fileService = fileService; SelectSourcePathCommand = new SyncCommand(p => { SourcePath = _fileService.SelectPath(); }, p => CopyCommand.Task.IsNotRunning); SelectTargetPathCommand = new SyncCommand(p => { TargetPath = _fileService.SelectPath(); }, p => CopyCommand.Task.IsNotRunning); CopyCommand = new ProgressiveAsyncCommand <ProgressModel>( async(parameter, token, progress) => { Log = string.Empty; try { await _fileService.CopyFiles(SourcePath, TargetPath, progress, token); } catch (TaskCanceledException) { progress.Report(new ProgressModel("Cancelled.")); } }, progress => { CopyProgress = progress.ProgressValue; MaxProgress = progress.MaxProgress; Log += $"{progress.LogMessage}{Environment.NewLine}"; }, parameter => _fileService.PathIsValid(SourcePath) && _fileService.PathIsValid(TargetPath)); }
public SpeechesListViewModel() { SelectedItemCommand = new SyncCommand <int>(SpeakerSelected); Speeches = new ObservableCollection <Speech>(); ShowSpeakerCommand = new ReverseCommand <Speaker>(); LoadSpeeches(); }
public ICommand DefineSyncCommand(string name, Action OnExecute, Action OnCancel = null) { var cmd = new SyncCommand(name, task_manager, OnExecute, OnCancel); defined_cmds.Add(cmd.GetNameHash(), cmd); return(cmd); }
public TabItemViewModel(ViewModel viewModel, TabViewModel ownerViewModel) { _mainViewModel = viewModel; _ownerViewModel = ownerViewModel; CloseCommand = new SyncCommand(Close); Add(_mainViewModel); }
public void SyncValidator_InvalidPlatform() { var command_with_invalidPlatform = new SyncCommand(_validPath, "Invalid"); _validator .ShouldHaveValidationErrorFor(t => t.Platform, command_with_invalidPlatform); }
public async Task <SyncCommandResult> Sync(string syncKey, string folderId, ExchangeChangeSet changeset) { if (string.IsNullOrEmpty(syncKey)) { throw new ArgumentNullException(nameof(syncKey)); } if (string.IsNullOrEmpty(folderId)) { throw new ArgumentNullException(nameof(folderId)); } if (changeset == null) { throw new ArgumentNullException(nameof(changeset)); } LogService.Log("ActiveSyncServer", string.Format("Syncing key: {0} folder id: {1}", syncKey.TakeLast(5), folderId != null ? folderId.TakeLast(5) : "<none>")); SyncCommand command = new SyncCommand(new SyncCommandParameter(syncKey, folderId, changeset), this.settings); ResponseResult <SyncCommandResult> result = await command.Execute(); if (ActiveSyncErrorHelper.IsStatusProvisioningError(result.Data?.Status, result?.Error)) { await this.TryDoProvisioning(); result = await command.Execute(); } if (result.Error != null) { throw result.Error; } return(result.Data); }
private void HandleCameraSyncProposal(UserContext context, SyncCommand command) { // Client requests OTHER clients to sync to his camera // Re-send data to clients var users = command.Data.Users.ToObject <List <User> >(); //var users = (List<User>)JsonConvert.DeserializeObject<List<User>>(command.Data.Users.ToString()); var response = new SyncResponse(SyncResponse.ResponseTypes.ProposeSyncCameras); response.Data = command.Data; var responseString = response.ToString(); foreach (var user in users) { var conn = FindConnection(user); if (conn != null && conn.ClientAddress == context.ClientAddress.ToString()) { continue; // skip requesting user } if (conn != null) { conn.Context.Send(responseString); } } }
public async Task DoSimpleSyncT() { var syncCmd = new SyncCommand(); var packagesJson = new PackagesJson(); packagesJson.dependencies = new Dictionary <string, string>(); packagesJson.dependencies.Add("xunit.core", "2.4.1"); packagesJson.dependencies.Add("CommandLineParser", "2.3.0"); var packagesJsonPath = Path.Combine(_prjConfig.RootPath, _prjConfig.Nuget2BazelConfigName); await File.WriteAllTextAsync(packagesJsonPath, JsonConvert.SerializeObject(packagesJson)); await syncCmd.Do(_prjConfig); var readback = await File.ReadAllTextAsync(packagesJsonPath); var readbackJson = JsonConvert.DeserializeObject <PackagesJson>(readback); var filtered = readbackJson.dependencies.Select(y => y.Key).ToList(); Assert.Equal(18, filtered.Count); Assert.Contains("CommandLineParser", filtered); Assert.Contains("xunit.abstractions", filtered); Assert.Contains("xunit.core", filtered); Assert.Contains("xunit.extensibility.core", filtered); Assert.Contains("xunit.extensibility.execution", filtered); }
public DirectoryViewModel() { AnalizedFiles = new ObservableCollection <FileResult>(); OpenDirectoryCommand = new SyncCommand(OpenDirectory); AnalizeCommand = new AsyncCommand(async() => await AnalizeDirectory()); }
private void SetSyncStatus() { IsSynced = _modifiedProperties.Count == 0; SyncCommand.TriggerCanExecuteChanged(); RevertAllCommand.TriggerCanExecuteChanged(); }
public void SyncValidator_Path_is_valid_if_is_not_null_or_empty() { var command = new SyncCommand(_validPath); _validator .ShouldNotHaveValidationErrorFor(t => t.Path, command); }
/// <summary> /// Event handler for sync menu entries /// </summary> private void OnSyncWithGoogle(object sender, EventArgs e) { ToolStripItem item = (ToolStripItem)sender; SyncCommand syncCommand = (SyncCommand)Enum.Parse(typeof(SyncCommand), item.Name); syncWithGoogle(syncCommand, false); }
public void SyncValidator_FullPath_failed_if_is_invalid_path() { var command_with_invalid_path = new SyncCommand("invalidPath"); _validator .ShouldHaveValidationErrorFor(t => t.FullPath, command_with_invalid_path) .WithErrorMessage(StringRes.BadReqInvalidPath); }
public boolean equals(IQueueCommand obj) { SyncCommand oSyncCmd = (SyncCommand)obj; return(m_nCmdCode == oSyncCmd.m_nCmdCode && m_nCmdParam == oSyncCmd.m_nCmdParam && (m_strCmdParam == oSyncCmd.m_strCmdParam || (m_strCmdParam != null && oSyncCmd.m_strCmdParam != null && m_strCmdParam.equals(oSyncCmd.m_strCmdParam)))); }
public ProductVM(IStartUpData _productData) { productData = _productData; ShowProgressBar(); OpenAddProductWindow_Command = new SyncCommand(OpenAddProductWindow); Products = new ObservableCollection <ProductModel>(); Window_ContentRendered_Command = new SyncCommand(Window_ContentRendered); }
public AddInvoiceVM(IInvoiceData _invoiceData) { invoiceData = _invoiceData; SubmitForm_Command = new SyncCommand(SubmitForm); AddNewRow_Command = new SyncCommand(AddNewRow, ValidateInvoice); InvoiceDetailsCollection = new ObservableCollection <InvoiceDetailsModelUI>(); ValidateInput(); }
private void DatabindSyncTab() { var syncCmd = new SyncCommand(); syncsourceProviderBox.DataBindings.Add("Text", syncCmd, "SourceProvider", true, DataSourceUpdateMode.OnPropertyChanged); syncdestProviderBox.DataBindings.Add("Text", syncCmd, "DestProvider", true, DataSourceUpdateMode.OnPropertyChanged); _commands[Verb.sync] = syncCmd; }
public AddInvoiceDetailsVM(IStartUpData _productData) { productData = _productData; Products_EnterKeyUpAsync_Command = new AsyncCommand(Products_EnterKeyUpAsync); Products_DropDownClosingAsync_Command = new AsyncCommand(Products_DropDownClosingAsync); AddDetails_Command = new SyncCommand(AddDetails); GetProducts(); }
protected static IEnumerable <Tuple <SyncCommand, string> > SyncRequests(SyncCommand command, string path, SyncCommand command2, string path2, SyncCommand command3, string path3) { yield return(new Tuple <SyncCommand, string>(command, path)); yield return(new Tuple <SyncCommand, string>(command2, path2)); yield return(new Tuple <SyncCommand, string>(command3, path3)); }
public InvoiceVM(IInvoiceData _invoiceData) { ShowProgressBar(); invoiceData = _invoiceData; OpenAddInvoiceWindow_Command = new SyncCommand(OpenAddInvoiceWindow); DeleteInvoice_Command = new SyncCommand(DeleteInvoice, EnableDeleteButton); Invoices = new ObservableCollection <InvoiceModelUI>(); Window_ContentRendered_Command = new SyncCommand(Window_ContentRendered); }
public StartPageViewModel() { Customer = new CustomerModel(); SyncCommand = new SyncCommand(this); LocalRealmInitialization(); LoginToServerAsync(); }
/// <summary> /// Set user id /// </summary> /// <param name="command"></param> protected void HandleUserIdentifier(SyncCommand command) { UserId = (Guid.Empty != _currentUser.UserId) ? _currentUser.UserId : command.UserId; if (UserId == Guid.Empty) { throw new ArgumentNullException(nameof(UserId)); } }
internal void UpdateFilterStateWithAddOrChange(ISyncItemId itemId, bool calendar, bool recurring, ExDateTime endTime) { if (itemId == null) { throw new ArgumentNullException("itemId"); } DateTimeCustomSyncFilter.FilterState filterState = null; if (this.CustomFilterState == null) { this.CustomFilterState = new Dictionary <ISyncItemId, DateTimeCustomSyncFilter.FilterState>(); } try { if (!this.CustomFilterState.ContainsKey(itemId)) { filterState = new DateTimeCustomSyncFilter.FilterState(); this.CustomFilterState[itemId] = filterState; } else { filterState = this.CustomFilterState[itemId]; } filterState.IsCalendarItem = calendar; if (calendar) { filterState.IsRecurring = recurring; if (recurring) { if (endTime.Equals(ExDateTime.MinValue)) { filterState.DoesRecurrenceEnd = false; } else { filterState.DoesRecurrenceEnd = true; filterState.EndTime = endTime; } } else { filterState.EndTime = endTime; } } } catch (Exception ex) { if (ex is ObjectNotFoundException || !SyncCommand.IsItemSyncTolerableException(ex)) { throw; } if (filterState != null) { filterState.IsCalendarItem = false; } } }
void checkShowStatus(SyncCommand oSyncCmd) { boolean bShowStatus = oSyncCmd.m_bShowStatus && !this.isNoThreadedMode(); m_oSyncEngine.getNotify().enableReporting(bShowStatus); if (m_oSyncEngine.getNotify().isReportingEnabled()) { m_statusListener.createStatusPopup(RhoAppAdapter.getMessageText("syncronizing_data")); } }
public async Task Process() { var syncCommand = new SyncCommand(); syncCommand.SetCommandAction(_actions[1]); syncCommand.FinishedSyncEvent += () => { _processOutputLines.Add("Finished"); }; await syncCommand.Process(); Assert.Equal("Process action1|Finished", string.Join('|', _processOutputLines.ToArray())); }
public override void SendSyncRequest(SyncCommand command, int length) { var trace = new StackTrace((Exception)null, false); if (trace.GetFrames()[0].GetMethod().DeclaringType != typeof(AdbSocket)) { this.SyncRequests.Add(new Tuple <SyncCommand, string>(command, length.ToString())); } base.SendSyncRequest(command, length); }
/// <inheritdoc/> public virtual void SendSyncRequest(SyncCommand command, string path) { if (path == null) { throw new ArgumentNullException(nameof(path)); } byte[] pathBytes = AdbClient.Encoding.GetBytes(path); this.SendSyncRequest(command, pathBytes.Length); this.Write(pathBytes); }
public static SyncCommand ProposeSyncCameras(List<User> admins, CameraDetails camera) { var command = new SyncCommand(SyncCommand.CommandTypes.ProposeSyncCameras); command.Data = new { Users = admins, CameraDetails = camera, Force = false, ProposingAdmin = SyncManager.Instance.User.CustId }; return command; }
/// <summary> /// Gets the byte array that represents the <see cref="SyncCommand"/>. /// </summary> /// <param name="command"> /// The <see cref="SyncCommand"/> to convert. /// </param> /// <returns> /// A byte array that represents the <see cref="SyncCommand"/>. /// </returns> public static byte[] GetBytes(SyncCommand command) { if (!Values.ContainsKey(command)) { throw new ArgumentOutOfRangeException(nameof(command), $"{command} is not a valid sync command"); } string commandText = Values[command]; byte[] commandBytes = AdbClient.Encoding.GetBytes(commandText); return commandBytes; }
private void RegisterUser(UserContext context, SyncCommand command) { // Client is trying to register // Find his connection and link it to a new user var conn = FindConnection(context); if (conn != null) { if (!conn.IsRegistered) { var id = (int)command.Data.Id; var ssid = (long)command.Data.Ssid; var name = command.Data.Name.ToString(); var shortname = command.Data.ShortName.ToString(); var password = command.Data.Password.ToString(); // Check password if (password == _password) { // Check subsession ID if (ssid == _subSessionId) { // Check name length if (!string.IsNullOrWhiteSpace(name) && name.Length >= MIN_NAME_LENGTH) { // Try to find previously connected user var user = this.State.Users.FromId(id); if (user == null) { // New user user = new User(); user.CustId = id; this.State.Users.Add(user); UserColors.SetColor(user); } if (!user.IsConnected) { user.Name = name; user.ShortName = shortname; user.IsRegistered = true; user.IsConnected = true; user.IsHost = id == _adminId; // Link him to his connection conn.User = user; this.OnLog("User registered: " + name); var response = new SyncResponse(SyncResponse.ResponseTypes.Connect); response.Data = new { Success = true, User = user }; this.Reply(context, response); this.BroadcastUserlist(); this.SendState(context); } else { this.OnLog("Already connected: " + name); this.FailRegistration(context, "You are already connected."); } } else { this.OnLog("Name too short: " + name); this.FailRegistration(context, string.Format("Please choose a name with a minimum of {0} characters.", MIN_NAME_LENGTH)); } } else { this.OnLog("Incorrect session ID."); this.FailRegistration(context, "Incorrect subsession ID: you must join the same session as the server host."); } } else { this.OnLog("Incorrect password attempt: " + password); this.FailRegistration(context, "Incorrect password."); } } else { this.OnLog("Already registered: " + conn.Username); this.FailRegistration(context, "You are already registered."); } } else { this.OnLog("Unknown client tried to register: " + context.ClientAddress); this.FailRegistration(context, "Unknown client."); } }
public void SyncTaskCategories(TaskCategorySyncRequest syncRequest) { //var syncItems = syncRequest.TaskCategoryItems; //var commands = new List<ISyncCommand>(); foreach (var category in syncRequest.TaskCategoryItems) { if (category.ActionType == (int)EntityActionType.Create) { var syncCommand = new SyncCommand { //ActionTypeOwner = (AppType)syncRequest.AppType, SyncId = category.SyncId, //Data = new CreateTaskCategoryCommand //{ // Title = category.Title //} }; //syncService.SyncByCreate(syncCommand); //commands.Add(new SyncCommand<CreateTaskCategoryCommand> //{ // ActionTypeOwner = (AppType) syncRequest.AppType, // SyncId = category.SyncId, // Data = new CreateTaskCategoryCommand // { // Title = category.Title // } //}); } } //var syncCommands = syncItems.Select(i => new SyncCommand<TaskCategory> //{ // SyncId = i.SyncId, // ActionTypeOwner = (AppType) syncRequest.AppType, // Data =, //}); }
public void RepositionPlayer(SyncCommand command) { stage.CharacterExit((int)this.transform.position.x, (int)this.transform.position.z); this.transform.position = new Vector3((float)command.x, 1f, (float)command.z); }
void checkShowStatus(SyncCommand oSyncCmd) { boolean bShowStatus = oSyncCmd.m_bShowStatus && !this.isNoThreadedMode(); m_oSyncEngine.getNotify().enableReporting(bShowStatus); if (m_oSyncEngine.getNotify().isReportingEnabled()) m_statusListener.createStatusPopup(RhoAppAdapter.getMessageText("syncronizing_data")); }
public void SendSyncRequest(SyncCommand command, int length) { this.SyncRequests.Add(new Tuple<SyncCommand, string>(command, length.ToString())); }
/// <inheritdoc/> public virtual void SendSyncRequest(SyncCommand command, string path, int permissions) { this.SendSyncRequest(command, $"{path},0{permissions}"); }
private void ReceivedPong(UserContext context, SyncCommand command) { var conn = this.FindConnection(context); if (conn != null && conn.IsRegistered) { var user = conn.User; user.LastPongReceived = DateTime.Now.ToUniversalTime(); var ping = (user.LastPongReceived.GetValueOrDefault() - user.LastPingSent.GetValueOrDefault()).Ticks / 2f; user.Ping = (int)Math.Round(ping / 10000f); // ms } }
private void HandleCameraSyncProposal(UserContext context, SyncCommand command) { // Client requests OTHER clients to sync to his camera // Re-send data to clients var users = command.Data.Users.ToObject<List<User>>(); //var users = (List<User>)JsonConvert.DeserializeObject<List<User>>(command.Data.Users.ToString()); var response = new SyncResponse(SyncResponse.ResponseTypes.ProposeSyncCameras); response.Data = command.Data; var responseString = response.ToString(); foreach (var user in users) { var conn = FindConnection(user); if (conn != null && conn.ClientAddress == context.ClientAddress.ToString()) continue; // skip requesting user if (conn != null) { conn.Context.Send(responseString); } } }
public void SendSyncRequest(SyncCommand command, string path) { this.SyncRequests.Add(new Tuple<SyncCommand, string>(command, path)); }
/// <inheritdoc/> public virtual void SendSyncRequest(SyncCommand command, int length) { // The message structure is: // First four bytes: command // Next four bytes: length of the path // Final bytes: path byte[] commandBytes = SyncCommandConverter.GetBytes(command); byte[] lengthBytes = BitConverter.GetBytes(length); if (!BitConverter.IsLittleEndian) { // Convert from big endian to little endian Array.Reverse(lengthBytes); } this.Write(commandBytes); this.Write(lengthBytes); }
protected static IEnumerable<Tuple<SyncCommand, string>> SyncRequests(SyncCommand command, string path, SyncCommand command2, string path2, SyncCommand command3, string path3) { yield return new Tuple<SyncCommand, string>(command, path); yield return new Tuple<SyncCommand, string>(command2, path2); yield return new Tuple<SyncCommand, string>(command3, path3); }
private void StartSyncEvent(PhotonRPCModel model) { SyncCommand command = new SyncCommand(); command.x = (int)transform.position.x; command.z = (int)transform.position.z; PhotonRPCModel rpcmodel = new PhotonRPCModel(); rpcmodel.command = PhotonRPCCommand.SyncPosition; rpcmodel.senderId = gameObject.name; rpcmodel.message = JsonUtility.ToJson(command); PhotonRPCHandler.GetInstance().PostRPC(rpcmodel); }
private void HandleStateUpdate(UserContext context, SyncCommand command) { Debug.WriteLine(">> Received state update: " + command); var conn = this.FindConnection(context); if (conn != null && conn.IsRegistered) { var message = (SyncStateCommand)command; switch (message.StateUpdateType) { case SyncStateCommand.StateUpdateTypes.WatchedDriverChanged: this.UpdateWatchedDriver(conn, message); break; case SyncStateCommand.StateUpdateTypes.LiveStatusChanged: this.UpdateLiveStatus(conn, message); break; case SyncStateCommand.StateUpdateTypes.AddPenalty: this.AddPenalty(conn, message); break; case SyncStateCommand.StateUpdateTypes.EditPenalty: this.EditPenalty(conn, message); break; case SyncStateCommand.StateUpdateTypes.DeletePenalty: this.DeletePenalty(conn, message); break; case SyncStateCommand.StateUpdateTypes.AddEvent: this.AddEvent(conn, message); break; case SyncStateCommand.StateUpdateTypes.Offtracks: this.UpdateOfftracks(conn, message); break; case SyncStateCommand.StateUpdateTypes.ClearOfftracks: this.ClearOfftracks(); break; } // Save state to file this.SaveState(); // Broadcast the new state to all clients this.BroadcastState(); } }
/// <inheritdoc/> public virtual void SendSyncRequest(SyncCommand command, string path) { if (path == null) { throw new ArgumentNullException(nameof(path)); } this.SendSyncRequest(command, path.Length); byte[] pathBytes = AdbClient.Encoding.GetBytes(path); this.Write(pathBytes); }
private void HandleCameraStateRequest(SyncCommand command) { // Client requests camera state of one other user // Obtain camera details and then }
public override void SendSyncRequest(SyncCommand command, string path) { this.SyncRequests.Add(new Tuple<SyncCommand, string>(command, path)); base.SendSyncRequest(command, path); }
/// <summary> /// Places a sync command onto the buffer /// and resets the buffer timer. /// </summary> /// <param name="syncCommand">The command to be pushed onto the buffer</param> /// <param name="objectID">The ID of the object which to manipulate (not used for Create command)</param> /// <param name="objectType">The type of the object to act on (not used for Execute command).</param> /// <param name="data"> /// Object structure if Update or Create, command if Execute, otherwise empty. /// </param> private void Buffer(SyncCommand syncCommand, uint objectID, string objectType, string data) { // create query string switch (syncCommand) { case SyncCommand.Execute: syncInBuffer[Tuple.Create<SyncCommand, uint, string>(syncCommand, objectID, objectType)] = data; break; case SyncCommand.Create: syncInBuffer[Tuple.Create<SyncCommand, uint, string>(syncCommand, 0, objectType)] = data; break; case SyncCommand.Delete: var updateTuple = Tuple.Create<SyncCommand, uint, string>(syncCommand, objectID, objectType); // remove any updates if (syncInBuffer.ContainsKey(updateTuple)) syncInBuffer.Remove(updateTuple); syncInBuffer[Tuple.Create<SyncCommand, uint, string>(syncCommand, objectID, objectType)] = ""; break; case SyncCommand.Update: syncInBuffer[Tuple.Create<SyncCommand, uint, string>(syncCommand, objectID, objectType)] = data; break; default: return; } if (syncInDelay != null) syncInDelay.Dispose(); syncInDelay = new Timer(PerformSyncIn, null, 500, Timeout.Infinite); }
public override void SendSyncRequest(SyncCommand command, int length) { StackTrace trace = new StackTrace(false); if (trace.GetFrame(1).GetMethod().DeclaringType != typeof(AdbSocket)) { this.SyncRequests.Add(new Tuple<SyncCommand, string>(command, length.ToString())); } base.SendSyncRequest(command, length); }
public static SyncCommand Pong() { var command = new SyncCommand(SyncCommand.CommandTypes.Pong); return command; }
public void SendSyncRequest(SyncCommand command, string path, int permissions) { this.SyncRequests.Add(new Tuple<SyncCommand, string>(command, $"{path},{permissions}")); }
public async void SendCommand(SyncCommand command) { if (this.Status == ConnectionStatus.Connected && this.User != null) { try { await Task.Run(() => _client.Send(command.ToString())); } catch (Exception) { } } }
private IEnumerable<SyncCommand> ExtractCommands(string rawString) { // split into commands var commandStrings = rawString.Split(new string[] { SYMBOL_commandSeparator }, StringSplitOptions.RemoveEmptyEntries); // format commands return commandStrings.Select(cs => { var command = new SyncCommand(); // split command and parameters var commandParts = cs.Split(new string[] { SYMBOL_parametersSeparator }, StringSplitOptions.RemoveEmptyEntries); // add command text command.Command = commandParts[0]; // format parameters var parameters = new List<object>(); if(commandParts.Length>1) { // split parameters var parameterParts = commandParts[1].Split(new string[] { SYMBOL_paramSeparator}, StringSplitOptions.RemoveEmptyEntries); // format each pairs foreach(var parameter in parameterParts) { var kvp = parameter.Split(new string[] { SYMBOL_paramKeyValueSeparator }, StringSplitOptions.None); parameters.Add(kvp[1]); // hack: quick test with string } } command.Parameters = parameters.ToArray(); // return command return command; }); }
private void HandleCameraStateRequest(SyncCommand command) { // Client requests camera state of one other user var clientAddress = (string)command.Data.UserAddress; }
private void OnConnected(UserContext context) { // Connected - send registration command var command = new SyncCommand(SyncCommand.CommandTypes.Register); command.Data = new { Id = _custid, Name = _name, ShortName = _shortname, Password = _password, Ssid = _subSessionId }; _client.Send(command.ToString()); }