public async Task IgnoresPasswordIfNotPremium() { var messenger = Substitute.For <INetworkMessenger>(); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); NetworkMessenger.Override(messenger); var settings = new UserSettings { AdministratorPassword = "******", IsPremium = false }; // We're not in the trial period var installationDateFetcher = Substitute.For <IInstallationDateFetcher>(); installationDateFetcher.GetInstallationDate().Returns(DateTimeOffset.MinValue); var clock = Substitute.For <IClock>(); clock.Now.Returns(DateTimeOffset.MinValue + AppConstants.TrialTime); var vm = new ConnectionViewModel(settings, () => "192.168.1.2", installationDateFetcher, clock); vm.Activator.Activate(); await vm.ConnectCommand.ExecuteAsync(); messenger.Received().ConnectAsync("192.168.1.1", settings.Port, new Guid(), null); }
public ConnectionData() { var aNodeViewModel = new NodeViewModel(100, 150, "A") { CanChange = false }; var bNodeViewModel = new NodeViewModel(300, 150, "B") { CanChange = false }; points.Add(aNodeViewModel); points.Add(bNodeViewModel); var connection = new ConnectionViewModel(aNodeViewModel, bNodeViewModel); connections.Add(connection); using (var values = Values().GetEnumerator()) { Observable.Interval(TimeSpan.FromSeconds(2)) .ObserveOn(App.Current.Dispatcher) .Subscribe(p => { values.MoveNext(); aNodeViewModel.Y = (int)(values.Current.x * 10); bNodeViewModel.Y = (int)(values.Current.y * 10); }); } }
public async Task DoesntTryToDiscoverServerWithCustomIpAddressIfSet() { var settings = new UserSettings { ServerAddress = "192.168.1.3" }; bool discoverServerSubscribed = false; var messenger = Substitute.For <INetworkMessenger>(); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()) .Returns(Observable.Defer(() => Observable.Start(() => discoverServerSubscribed = true).Select(_ => string.Empty))); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); await vm.ConnectCommand.ExecuteAsync(); Assert.False(discoverServerSubscribed); }
public async Task SmokeTest() { var messenger = Substitute.For <INetworkMessenger>(); messenger.IsConnected.Returns(false); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(); vm.Activator.Activate(); Assert.True(vm.ConnectCommand.CanExecute(null)); await vm.ConnectCommand.ExecuteAsync(); messenger.IsConnected.Returns(true); messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected")); Assert.False(vm.ConnectCommand.CanExecute(null)); messenger.Received(1).ConnectAsync("192.168.1.1", NetworkConstants.DefaultPort, Arg.Any <Guid>(), null); }
/// <summary> /// Searches for loops in a network. /// A loop is a connection sequence that starts and ends at the same node. /// </summary> /// <param name="network">the network to search for loops.</param> /// <returns>an enumeration of connections involved in loops</returns> public static IEnumerable <ConnectionViewModel> FindLoops(NetworkViewModel network) { Stack <NodeViewModel> nodesToCheck = new Stack <NodeViewModel>(network.Nodes); Dictionary <NodeViewModel, NodeState> nodeStates = new Dictionary <NodeViewModel, NodeState>(nodesToCheck.Count); while (nodesToCheck.Count > 0) { NodeViewModel currentNode = nodesToCheck.Peek(); NodeState state; if (!nodeStates.TryGetValue(currentNode, out state)) { state = NodeState.Ready; } if (state == NodeState.Error) { nodesToCheck.Pop(); continue; } ConnectionViewModel recursiveConnection = FindLoops(nodeStates, currentNode); if (recursiveConnection != null) { yield return(recursiveConnection); } nodesToCheck.Pop(); } }
public void SetConnectionString_IsSearching() { var policies = new Subject <EndpointDescription[]>(); var discovery = Substitute.For <IDiscoveryService>(); discovery.GetEndpoints("url").Returns(policies); var blobCache = BlobCache.InMemory; var vm = new ConnectionViewModel(null, TestChannelService.Silent, discovery, blobCache); vm.ConnectionString = "url"; vm.StartDiscover(); vm.IsSearchingForSecurityPolicies .Should().BeTrue(); policies.OnNext(_testEndpoints1); policies.OnCompleted(); vm.IsSearchingForSecurityPolicies .Should().BeFalse(); vm.AvailableEndpoints .Should().BeEquivalentTo(_testEndpoints1); }
public void TestSetUp() { if (TestContext.Properties.Contains("WitsmlStoreUrl")) { _validWitsmlUri = TestContext.Properties["WitsmlStoreUrl"].ToString(); } if (TestContext.Properties.Contains("EtpServerUrl")) { _validEtpUri = TestContext.Properties["EtpServerUrl"].ToString(); } _bootstrapper = new BootstrapperHarness(); _runtime = new TestRuntimeService(_bootstrapper.Container); _witsmlConnection = new Connection() { Name = "Witsml", Uri = _validWitsmlUri, Username = "******" }; _etpConnection = new Connection() { Name = "Etp", Uri = _validEtpUri, Username = "******" }; _witsmlConnectionVm = new ConnectionViewModel(_runtime, ConnectionTypes.Witsml); _etpConnectionVm = new ConnectionViewModel(_runtime, ConnectionTypes.Etp); DeletePersistenceFolder(); }
/// <summary> /// Called when the user has started to drag out a connector, thus creating a new connection. /// </summary> public ConnectionViewModel ConnectionDragStarted(ConnectorViewModel draggedOutConnector, Point curDragPoint) { // // Create a new connection to add to the view-model. // var connection = new ConnectionViewModel(); if (draggedOutConnector.Type == ConnectorType.Output) { // // The user is dragging out a source connector (an output) and will connect it to a destination connector (an input). // connection.SourceConnector = draggedOutConnector; connection.DestConnectorHotspot = curDragPoint; } else { // // The user is dragging out a destination connector (an input) and will connect it to a source connector (an output). // connection.DestConnector = draggedOutConnector; connection.SourceConnectorHotspot = curDragPoint; } // // Add the new connection to the view-model. // Network.Connections.Add(connection); return(connection); }
public void AppDoeNotDieWhenDeactivatingViewModelBeforeCommandThrows() { var settings = new UserSettings { ServerAddress = "192.168.1.1" }; var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Observable.Never <ConnectionResultContainer>().ToTask()); messenger.IsConnected.Returns(false); NetworkMessenger.Override(messenger); new TestScheduler().With(sched => { ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); vm.ConnectCommand.Execute(null); vm.Activator.Deactivate(); sched.AdvanceByMs(ConnectionViewModel.ConnectCommandTimeout.TotalMilliseconds + 10); }); }
public async Task ConnectsWithCustomIpAddressIfSet() { var settings = new UserSettings { ServerAddress = "192.168.1.3" }; var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(Task.FromResult(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")))); NetworkMessenger.Override(messenger); ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); ConnectionResultContainer result = await vm.ConnectCommand.ExecuteAsync(); Assert.Equal(ConnectionResult.Successful, result.ConnectionResult); Assert.Equal(new Version("99.99.99"), result.ServerVersion);; messenger.Received(1).ConnectAsync(settings.ServerAddress, NetworkConstants.DefaultPort, settings.UniqueIdentifier, null); }
// Event raised while the user is dragging a connection. private void networkControl_ConnectionDragging(object sender, ConnectionDraggingEventArgs e) { System.Windows.Point curDragPoint = Mouse.GetPosition(networkControl); ConnectionViewModel connection = (ConnectionViewModel)e.Connection; ViewModel.ConnectionDragging(curDragPoint, connection); }
public void Construction02() { var uri = new Uri("http://microsoft.com"); var conn = Substitute.For <IConnection>(); conn.Uri.Returns(uri); conn.Name.Returns("name"); conn.Path.Returns("path"); conn.RCommandLineArguments.Returns("arg"); conn.IsRemote.Returns(true); var cm = new ConnectionViewModel(conn, Substitute.For <IConnectionManager>(), new TestImageService()); cm.IsUserCreated.Should().BeFalse(); conn.IsUserCreated.Returns(true); cm = new ConnectionViewModel(conn, Substitute.For <IConnectionManager>(), new TestImageService()); conn.IsRemote.Should().BeTrue(); cm.IsUserCreated.Should().BeTrue(); cm.IsEditing.Should().BeFalse(); cm.IsTestConnectionSucceeded.Should().BeFalse(); cm.Name.Should().Be(conn.Name); cm.Path.Should().Be(conn.Path); cm.RCommandLineArguments.Should().Be(conn.RCommandLineArguments); }
public void InputFieldTooltips(string name, string path, FieldState expectedNameState, FieldState expectedPathState) { string nameTooltip = null; string pathTooltip = null; switch (expectedNameState) { case FieldState.Missing: nameTooltip = Resources.ConnectionManager_ShouldHaveName; break; case FieldState.Invalid: nameTooltip = Resources.ConnectionManager_InvalidName; break; } switch (expectedPathState) { case FieldState.Missing: pathTooltip = Resources.ConnectionManager_ShouldHavePath; break; case FieldState.Invalid: pathTooltip = Resources.ConnectionManager_InvalidPath; break; } var saveTooltip = nameTooltip ?? (pathTooltip ?? Resources.ConnectionManager_Save); var conn = Substitute.For <IConnection>(); conn.Name.Returns(name); conn.Path.Returns(path); var cm = new ConnectionViewModel(conn, Substitute.For <IConnectionManager>(), new TestImageService()); cm.NameTextBoxTooltip.Should().Be(nameTooltip); cm.PathTextBoxTooltip.Should().Be(pathTooltip); cm.SaveButtonTooltip.Should().Be(saveTooltip); cm.IsNameValid.Should().Be(expectedNameState == 0); cm.IsPathValid.Should().Be(expectedPathState == 0); cm.IsValid.Should().Be(cm.IsNameValid && cm.IsPathValid); }
public void Render(ConnectionViewModel viewModel) { this.SuspendLayout(); if (viewModel == null) { this.nameValueLabel.Text = ""; this.parentValueLabel.Text = ""; this.userNameValueLabel.Text = ""; this.addressValueLabel.Text = ""; this.RenderState(null); this.tunnelsGridView.DataSource = this.tunnelViewModels = new TunnelViewModel[0]; } else { var parentName = viewModel.Info.Parent == null ? "-" : viewModel.Info.Parent.Name; this.nameValueLabel.Text = viewModel.Info.Name; this.parentValueLabel.Text = parentName; this.userNameValueLabel.Text = viewModel.Info.UserName; this.addressValueLabel.Text = string.Format("{0}:{1}", viewModel.Info.HostName, viewModel.Info.Port); this.RenderState(viewModel); this.tunnelViewModels = viewModel.Info.Tunnels.Select(t => new TunnelViewModel(t)).ToArray(); this.tunnelsGridView.DataSource = this.tunnelViewModels; } this.ResumeLayout(true); }
private void CreateBlockingNode(NetworkViewModel model, NodeViewModel previous_node) { // Create blocking node and add it to the graph BlockingCutNodeViewModel blocking_node = new BlockingCutNodeViewModel(Cut); model.Nodes.Edit(x => x.Add(blocking_node)); // Set the blocking node's position to where this cut node was blocking_node.Position = (System.Windows.Point)(Position - new System.Windows.Point(150, 0)); // Move this cut node forward to not overlap the blocking node Position = new System.Windows.Point(Position.X + 450, Position.Y); ConnectionViewModel previous_to_blocking = new ConnectionViewModel( model, blocking_node.Inputs.Items.First(), previous_node.Outputs.Items.First()); ConnectionViewModel blocking_to_current = new ConnectionViewModel( model, Inputs.Items.First(), blocking_node.Outputs.Items.First()); // Add the connections to the node network. model.Connections.Edit(x => x.Add(previous_to_blocking)); model.Connections.Edit(x => x.Add(blocking_to_current)); }
public void AddProperty() { PendingConnectionViewModel pending = Parent.PendingConnection; if (pending == null || pending.Output == null || !(pending.Output.Parent is SubstanceNodeViewModel)) { return; } SubstanceNodeViewModel sub_view = pending.Output.Parent as SubstanceNodeViewModel; NodeInputViewModel new_prop_input = new NodeInputViewModel(); new_prop_input.Connections.Connect() .Subscribe(change => { OnPropertyInputChanged(change); }); Inputs.Edit(x => x.Add(new_prop_input)); ConnectionViewModel new_prop_connection = new ConnectionViewModel( Parent, new_prop_input, sub_view.Outputs.Items.First()); Parent.Connections.Edit(x => x.Add(new_prop_connection)); }
public static void FillConnectionsFromButtonsOfChatNode(NodeViewModel node) { if (node.Network != null) { foreach (var btn in node.ChatNode.Buttons) { if (!string.IsNullOrWhiteSpace(btn.NextNodeId)) { var destNode = node.Network.Nodes.FirstOrDefault(x => x.ChatNode.Id == btn.NextNodeId); if (destNode != null) { var conn = new ConnectionViewModel { SourceConnector = node.OutputConnectors.FirstOrDefault(x => x.Button._id == btn._id), DestConnector = destNode.InputConnectors.FirstOrDefault() }; conn.ConnectionChanged += ConnectionViewModelConnectionChanged; if (conn.SourceConnector == null || conn.DestConnector == null) { continue; } node.Network.Connections.Add(conn); } } } } }
public void SetConnectionString_OneFalling() { var discovery = Substitute.For <IDiscoveryService>(); discovery.GetEndpoints("url1").Returns(Observable.Return(_testEndpoints1)); discovery.GetEndpoints("badurl").Returns(Observable.Throw <EndpointDescription[]>(new ServiceResultException(StatusCodes.BadArgumentsMissing))); discovery.GetEndpoints("url2").Returns(Observable.Return(_testEndpoints2)); var blobCache = BlobCache.InMemory; var vm = new ConnectionViewModel(null, TestChannelService.Silent, discovery, blobCache); vm.ConnectionString = "url1"; vm.StartDiscover(); vm.AvailableEndpoints .Should().BeEquivalentTo(_testEndpoints1); vm.ConnectionString = "badurl"; vm.StartDiscover(); vm.AvailableEndpoints .Should().BeNullOrEmpty(); vm.ExecutionError .Should().NotBeNullOrEmpty(); vm.ConnectionString = "url2"; vm.StartDiscover(); vm.AvailableEndpoints .Should().BeEquivalentTo(_testEndpoints2); vm.ExecutionError .Should().BeNullOrEmpty(); }
/// <summary> /// Called when the user has finished dragging out the new connection. /// </summary> public void ConnectionDragCompleted(ConnectionViewModel newConnection, ConnectorViewModel connectorDraggedOut, ConnectorViewModel connectorDraggedOver) { if (connectorDraggedOver == null) { // // The connection was unsuccessful. // Maybe the user dragged it out and dropped it in empty space. // this.Network.Connections.Remove(newConnection); return; } // // The user has dragged the connection on top of another valid connector. // var existingConnection = connectorDraggedOver.AttachedConnection; if (existingConnection != null) { // // There is already a connection attached to the connector that was dragged over. // Remove the existing connection from the view-model. // this.Network.Connections.Remove(existingConnection); } // // Finalize the connection by attaching it to the connector // that the user dropped the connection on. // newConnection.DestConnector = connectorDraggedOver; }
public ValidationResult Validate(ConnectionViewModel model) { ValidationResult result = new ValidationResult(); if (String.IsNullOrWhiteSpace(model.Host)) { result.Messages.Add("Host cannot be empty"); } if (!model.Port.HasValue || model.Port.Value <= 0) { result.Messages.Add("Port must have a numeric value"); } if (String.IsNullOrWhiteSpace(model.Database)) { result.Messages.Add("Database cannot be empty"); } if (String.IsNullOrWhiteSpace(model.ActiveCollection)) { result.Messages.Add("Active collection cannot be empty"); } if (String.IsNullOrWhiteSpace(model.CompletedCollection)) { result.Messages.Add("Completed collection cannot be empty"); } if (model.Password != model.PasswordConfirm) { result.Messages.Add("Password and confirmation password do not match"); } return(result); }
/// <summary> /// A function to conveniently populate the view-model with test data. /// </summary> private void PopulateWithTestData() { // // Create a network, the root of the view-model. // this.Network = new NetworkViewModel(); // // Create some nodes and add them to the view-model. // var node1 = CreateNode("Node1", new Point(10, 10)); var node2 = CreateNode("Node2", new Point(200, 10)); // // Create a connection between the nodes. // var connection = new ConnectionViewModel(); connection.SourceConnector = node1.Connectors[1]; connection.DestConnector = node2.Connectors[3]; // // Add the connection to the view-model. // this.Network.Connections.Add(connection); }
public ActionResult AddEditProjectConnection(int projectId, int connectionId = 0) { ConnectionViewModel model = new ConnectionViewModel(); model.ProjectId = projectId; ProjectMappingModel projectMapping; bool isAssigned = new ProjectBL().IsProjectAssignedToUser(projectId, CurrentUser.Pfid, out projectMapping); if (!isAssigned) { TempData["ErrorMessage"] = "Project not found"; return(RedirectToAction("Dashboard", "Project")); } model.ProjectDetails = GetProjectDetailsViewModel(projectMapping); if (connectionId > 0) { ConnectionModel connectionModel = new ConnectionBL().GetConnectionById(connectionId); if (connectionModel != null) { model.Id = connectionModel.Id; model.ConnectionName = connectionModel.ConnectionName; model.ProjectId = connectionModel.ProjectId; model.SID = connectionModel.SID; model.IpAddress = connectionModel.IpAddress; model.PortNumber = connectionModel.PortNumber; model.ConnectionUsername = connectionModel.ConnectionUsername; } } return(View(model)); }
/// <summary> /// Called when the user has started to drag out a connector, thus creating a new connection. /// </summary> public ConnectionViewModel ConnectionDragStarted(ConnectorViewModel draggedOutConnector, Point curDragPoint) { if (draggedOutConnector.AttachedConnection != null) { // // There is an existing connection attached to the connector that has been dragged out. // Remove the existing connection from the view-model. // this.Network.Connections.Remove(draggedOutConnector.AttachedConnection); } // // Create a new connection to add to the view-model. // var connection = new ConnectionViewModel(); // // Link the source connector to the connector that was dragged out. // connection.SourceConnector = draggedOutConnector; // // Set the position of destination connector to the current position of the mouse cursor. // connection.DestConnectorHotspot = curDragPoint; // // Add the new connection to the view-model. // this.Network.Connections.Add(connection); return(connection); }
public async Task IsFalseWhileConnectCommandExecutesWithPassword() { var messenger = Substitute.For <INetworkMessenger>(); messenger.ConnectAsync(Arg.Any <string>(), Arg.Any <int>(), Arg.Any <Guid>(), Arg.Any <string>()) .Returns(x => { messenger.IsConnected.Returns(true); messenger.PropertyChanged += Raise.Event <PropertyChangedEventHandler>(messenger, new PropertyChangedEventArgs("IsConnected")); return(new ConnectionResultContainer(ConnectionResult.Successful, NetworkAccessPermission.Admin, new Version("99.99.99")).ToTaskResult()); }); messenger.IsConnected.Returns(false); messenger.DiscoverServerAsync(Arg.Any <string>(), Arg.Any <int>()).Returns(Observable.Return("192.168.1.1")); NetworkMessenger.Override(messenger); var settings = new UserSettings { AdministratorPassword = "******" }; ConnectionViewModel vm = Helpers.CreateDefaultConnectionViewModel(settings); vm.Activator.Activate(); var coll = messenger.WhenAnyValue(x => x.IsConnected).CreateCollection(); await vm.ConnectCommand.ExecuteAsync(); Assert.Equal(new[] { false, true }, coll); }
/// <summary> /// Called as the user continues to drag the connection. /// </summary> public void ConnectionDragging(ConnectionViewModel connection, Point curDragPoint) { // // Update the destination connection hotspot while the user is dragging the connection. // connection.DestConnectorHotspot = curDragPoint; }
public async Task <JsonResult> GetConnectionSingleByMID(string ID) { try { var data = ConnectionServices.GetByMemberSingleID(ID); var vmModel = new List <ConnectionViewModel>(); foreach (var model in data) { var temp = new ConnectionViewModel() { ID = model.ID.ToString(), GroupName = model.ConnectionName }; foreach (var member in model.Members) { //assign userinformationmodel var vm = new UserInformationViewModel() { User = member.UserID.ToString() }; temp.PushMembers(member, vm); } vmModel.Add(temp); } return(Json(new { success = true, data = vmModel }, JsonRequestBehavior.AllowGet)); } catch (Exception e) { Console.Write(e); return(Json(new { success = false, message = MessageUtility.ServerError() }, JsonRequestBehavior.AllowGet)); } }
public JsonResult TestConnection(ConnectionViewModel connectionViewModel) { if (ModelState.IsValid) { ConnectionModel connection = new ConnectionModel { IpAddress = connectionViewModel.IpAddress, PortNumber = connectionViewModel.PortNumber, SID = connectionViewModel.SID, ConnectionUsername = connectionViewModel.ConnectionUsername, ConnectionPassword = connectionViewModel.ConnectionPassword, }; try { int result = new ConnectionBL().TestConnection(connection); return(Json(new { Success = true, Message = "Database connection tested successfully." })); } catch (Exception) { return(Json(new { Success = false, Message = "Unable to connect to database." })); } } return(Json(new { Success = false, Message = "There are validation errors on page." })); }
private void OnGraphControlConnectionDragging(object sender, ConnectionDraggingEventArgs e) { Point currentDragPoint = Mouse.GetPosition(GraphControl); ConnectionViewModel connection = (ConnectionViewModel)e.Connection; ViewModel.OnConnectionDragging(currentDragPoint, connection); }
public ActionResult AddEditConnection(int connectionId = 0) { ConnectionViewModel model = new ConnectionViewModel(); if (connectionId > 0) { ConnectionModel connectionModel = new ConnectionBL().GetConnectionById(connectionId); if (connectionModel != null) { model.Id = connectionModel.Id; model.ConnectionName = connectionModel.ConnectionName; model.ProjectId = connectionModel.ProjectId; model.SID = connectionModel.SID; model.IpAddress = connectionModel.IpAddress; model.PortNumber = connectionModel.PortNumber; model.ConnectionUsername = connectionModel.ConnectionUsername; } } var projects = new ProjectBL().GetProjectList().Where(p => p.IsActive == 1).ToList(); List <SelectListItem> selectListItems = new List <SelectListItem>(); foreach (var project in projects) { selectListItems.Add(new SelectListItem { Text = project.ProjectName, Value = project.Id.ToString(), Selected = model.ProjectId > 0 ? (project.Id == model.ProjectId) : false }); } model.ProjectList = new SelectList(selectListItems, "Value", "Text"); return(View(model)); }
/// <summary> /// A function to conveniently populate the view-model with test data. /// </summary> private void PopulateWithTestData() { // // Create a network, the root of the view-model. // Network = new NetworkViewModel(); // // Create some nodes and add them to the view-model. // var node1 = CreateNode("Node1", new Point(100, 60), false); var node2 = CreateNode("Node2", new Point(350, 80), false); // // Create a connection between the nodes. // var connection = new ConnectionViewModel(); connection.SourceConnector = node1.OutputConnectors[0]; connection.DestConnector = node2.InputConnectors[0]; // // Add the connection to the view-model. // Network.Connections.Add(connection); }
/// <summary> /// Creates the type graph. /// </summary> /// <returns>The graph view model.</returns> public AGraphViewModel CreateTypeGraph() { GraphViewModel lGraph = new GraphViewModel(); NodeViewModel lNode0 = new TypeNodeViewModel(typeof(SampleClass)); lGraph.AddNode(lNode0); NodeViewModel lNode1 = new TypeNodeViewModel(typeof(SampleClass1VeryTooMuchLong)); lGraph.AddNode(lNode1); NodeViewModel lNode2 = new NodeViewModel(); lNode2.DisplayString = "Empty node"; lGraph.AddNode(lNode2); int i = 0; foreach (NodeViewModel lNode in lGraph.Nodes) { lNode.X = 300 * i; lNode.Y = 100 * i; i++; } ConnectionViewModel lConnectionViewModel = new ConnectionViewModel(); lConnectionViewModel.Output = lGraph.Nodes.ElementAt(0).Ports.FirstOrDefault(pPort => pPort.Direction == PortDirection.Output); lConnectionViewModel.Input = lGraph.Nodes.ElementAt(1).Ports.FirstOrDefault(pPort => pPort.Direction == PortDirection.Input); lGraph.AddConnection(lConnectionViewModel); return(lGraph); }
public void Execute(object parameter) { var shell = IoC.Get<IShell>(); var context = IoC.Get<EnvironmentExplorerViewModel>().GetCurrentContext(); var viewModel = default(ConnectionViewModel); if (context.Service is AzureService || context.Service is AzureRMService) viewModel = new ConnectionViewModel(new ConnectionModelProxy(new Vendor.Azure.Connection(), context)); else viewModel = new ConnectionViewModel(new ConnectionModelProxy(new SMA.Connection(), context)); shell.OpenDocument(viewModel); }
public void PropertiesTests() { var modelMock = Mock.Create<ExpressionConnection>(); var sourceMock = Mock.Create<IConnectableItemViewModel>(); var destinationMock = Mock.Create<IConnectableItemViewModel>(); var diagramMock = Mock.Create<IDiagramViewModel>(); var vm = new ConnectionViewModel<ExpressionConnection>(modelMock, sourceMock, destinationMock, diagramMock); TestsHelper.TestPublicDeclaredPropertiesGetSet(vm, true, x=>x.X1, x=>x.Y1, x=>x.X2, x=>x.Y2); Assert.AreSame(vm.Model, modelMock); Assert.AreSame(vm.Connection, modelMock); vm.Source = null; vm.Source = sourceMock; Assert.AreSame(sourceMock, vm.Source); vm.Destination = null; vm.Destination = destinationMock; Assert.AreSame(destinationMock, vm.Destination); Assert.AreSame(modelMock, vm.Connection); Assert.AreSame(modelMock, vm.Item); Assert.IsTrue(vm.IsValid); Assert.IsFalse(vm.CanConnectTo(null, null).CanConnect); Assert.IsNull(vm.CreateConnectionTo(null)); Assert.IsTrue(string.IsNullOrWhiteSpace(vm.ValidationMessage)); Assert.IsFalse(vm.IsConnectedTo(Mock.Create<IDiagramItemViewModel>())); Assert.IsNotNull(vm.GetConnectors()); }
public ConnectionCommand(ConnectionViewModel ViewModel) { _ViewModel = ViewModel; }
public void ArcRadius_Is0_ByDefault() { var modelMock = Mock.Create<ExpressionConnection>(); var sourceMock = Mock.Create<IConnectableItemViewModel>(); var destinationMock = Mock.Create<IConnectableItemViewModel>(); var diagramMock = Mock.Create<IDiagramViewModel>(); var vm = new ConnectionViewModel<ExpressionConnection>(modelMock, sourceMock, destinationMock, diagramMock); vm.ConnectorType = ConnectorTypes.Default; //Assert Assert.AreEqual(0, vm.Y2); vm.ConnectorType = ConnectorTypes.DecisionOut; //Assert Assert.AreEqual(0, vm.ArcRadius); }
public void ItemPropertyChanged_WhenRaised_RaisePropertyChanged() { var modelMock = Mock.Create<ExpressionConnection>(); var sourceMock = Mock.Create<IConnectableItemViewModel>(); var sourceItem = Mock.Create<IDiagramItem>(); Mock.Arrange(() => sourceMock.Item).Returns(sourceItem); var destinationMock = Mock.Create<IConnectableItemViewModel>(); var diagramMock = Mock.Create<IDiagramViewModel>(); var vm = new ConnectionViewModel<ExpressionConnection>(modelMock, sourceMock, destinationMock, diagramMock); var propertyChanged = false; vm.PropertyChanged += (o, args) => { propertyChanged = true; }; Mock.Raise(() => sourceItem.PropertyChanged += null, new PropertyChangedEventArgs(string.Empty)); Assert.IsTrue(propertyChanged); }
public void RenderState(ConnectionViewModel viewModel) { if (viewModel == null) { this.stateValueLabel.Text = ""; this.stateValueLabel.ForeColor = Color.Black; } else { this.stateValueLabel.Text = viewModel.State.ToString(); this.stateValueLabel.ForeColor = viewModel.StateColor; } }
private void btnConnectClick(object sender, RoutedEventArgs e) { var conDialog = new wpf_testing.ConnectionDialog();//Application.ActiveWorkbook, _conn.ConnectionString, _xlHelper); var vm = new ConnectionViewModel(_conn, "No Workbook Selected"); conDialog.DataContext = vm; var dialogRes = conDialog.ShowDialog(); if (!(conDialog.DialogResult.HasValue && conDialog.DialogResult.Value)) return; RegistryHelper.SaveServerListToRegistry(vm.DataSource,vm.RecentServers); _conn = vm.Connection; _conn.ShowHiddenObjects = true; RefreshDatabaseList(); }
public void Select(ConnectionViewModel connection) { var bindingSource = (BindingSource)this.connectionsGridView.DataSource; var index = bindingSource.IndexOf(connection); bindingSource.Position = index; bindingSource.ResetItem(index); }
public MainViewModel(ConnectionViewModel connectionViewModel, SettingsViewModel settingsViewModel) { SettingsViewModel = settingsViewModel; ConnectionViewModel = connectionViewModel; }
private void OnDisconnected() { Content = new ConnectionViewModel(_cacheClient, OnConnected); }
public MainViewModel(ICacheClient cacheClient) { _cacheClient = cacheClient; _content = new ConnectionViewModel(_cacheClient, OnConnected); }
public Fullstack() { InitializeComponent(); DataContext = new ConnectionViewModel("TEST"); }