//protected override Selector GetSelectorForItemOverride(object item)
//{
// return new SelectorView();
//}
protected override object GetNewNode(Type desiredType)
{
//return new NodeVM();
NodeVM nodevm = new NodeVM();
return(nodevm);
}
public NodeVM GetNameById(string idName)
{
List <NodeVM> names = GetNames();
NodeVM name = names.FirstOrDefault(_ => _.Key == idName);
return(name);
}
private void CommandSetNodePosition_Execute(object sender, ExecutedRoutedEventArgs e)
{
SetNodePositionParameters p = e.Parameter as SetNodePositionParameters;
NodeVM nodeVM = FindNodeVMFromSetNodePositionParameters(p);
nodeVM.PositionX = p.NewPositionX;
nodeVM.PositionY = p.NewPositionY;
}
/// <summary>
/// The execute expand collapse command.
/// </summary>
/// <param name="nodeVm">
/// The node vm.
/// </param>
internal void ExecuteExpandCollapseCommand(NodeVM nodeVm)
{
ExpandCollapseParameter parameter = new ExpandCollapseParameter {
Node = nodeVm, IsUpdateLayout = true
};
(this.Info as IGraphInfo).Commands.ExpandCollapse.Execute(parameter);
}
public JsonResult AddNewNode(NodeVM nodeVm)
{
if (!string.IsNullOrEmpty(nodeVm.Name))
{
var newNodeId = _nodeRepository.AddNode(nodeVm);
return(Json(new { success = true, nodeName = nodeVm.Name, newNodeId, nodeParentId = nodeVm.ParentNodeId }));
}
return(Json(new { success = true, message = "Name cannot be empty!" }));
}
public IHttpActionResult ListByNode(NodeVM model)
{
try
{
var result = _service.ListByNode(model.Node);
return(Ok(result));
}
catch { throw; }
}
public ActionResult Basic(int id)
{
Node node = NodeService.GetNode(id);
if (node == null)
{
return(new HttpNotFoundResult("Node not found"));
}
NodeVM vm = NodeVM.FromModel(node);
return(new JsonNetResult(vm));
}
public NodeVM FindNodeVMFromSetNodePositionParameters(SetNodePositionParameters p)
{
if (p.Node != null)
{
return(p.Node);
}
// Find closed by name
NodeVM node = Class.Methods.FirstOrDefault(m => m.Name == p.Node.Method.Name)?.
Nodes.FirstOrDefault(n => n.Name == p.Node.Name);
return(node);
}
private void CommandSelectNode_Execute(object sender, ExecutedRoutedEventArgs e)
{
// Try to find the MethodVM corresponding to the passed NodeVM
// and set its selected node
NodeVM node = e.Parameter as NodeVM;
MethodVM method = Class?.Methods.FirstOrDefault(m => m.Nodes.Contains(node));
if (method != null)
{
method.SelectedNode = node;
}
}
public int AddNode(NodeVM nodeVM)
{
var node = new Node
{
Name = nodeVM.Name,
ParentNodeId = nodeVM.ParentNodeId
};
_appDbContext.Nodes.Add(node);
_appDbContext.SaveChanges();
return(node.Id);
}
public ActionResult Edit(int?id)
{
if (id.HasValue)
{
Node node = NodeService.GetNode(id.Value);
if (node == null)
{
return(new HttpNotFoundResult("Node not found"));
}
NodeVM vm = NodeVM.FromModel(node).Fill();
return(View(vm));
}
return(View(NodeVM.FromModel().Fill()));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
new Thread(() =>
{
// Get Neighbor Command
AddLog("Fetching neighbors...");
var _getNeighbors = new GetNeighborsCommand($"{_baseUrl}/Node/Neighbors");
List <NodeVM> _neighbors = mediator.Send(_getNeighbors).Result;
AddLog("{0} neighbor/s found", _neighbors.Count());
List <TranSiteVM> _transites = new List <TranSiteVM>();
foreach (var _node in _neighbors)
{
AddLog("Connecting node..");
IPEndPoint _nodeEndpoint = new IPEndPoint(IPAddress.Parse(_node.IPAddress), _node.Port);
TryConnectNodeCommand _connectCmd = new TryConnectNodeCommand(_nodeEndpoint);
TcpClient _client = mediator.Send(_connectCmd).Result;
if (_client.Connected)
{
NodeVM _connectedNode = new NodeVM
{
Client = _client,
};
this.Dispatcher.Invoke(() =>
{
(this.DataContext as MainWindowVM).AddConnectedNode(_connectedNode);
});
var _r = mediator.Send(new ListenMessageCommand(_connectedNode, (string msg) =>
{
AddLog($"Message: {msg}");
})).Result;
AddLog("Connected!");
}
}
}).Start();
}
private void Append(List <NodeVM> buffer, int length, int currentLevel, int levels, string prefix)
{
if (currentLevel > levels)
{
return;
}
string prefixLocal = (currentLevel == 0) && (levels == 0) ? string.Empty : "L" + currentLevel.ToString();
for (int i = 0; i < length; i++)
{
NodeVM node = new NodeVM();
node.Key = $"{prefix ?? string.Empty}{prefixLocal}K{i}";
node.Value = $"{prefixLocal}V{i}";
this.Append(node.Nodes, length, currentLevel + 1, levels, prefix);
buffer.Add(node);
}
}
private void CommandSelectNode_Execute(object sender, ExecutedRoutedEventArgs e)
{
// Try to find the MethodVM corresponding to the passed NodeVM
// and set its selected node
// TODO: Make selection nicer. Finding the corresponding method view model seems wrong since
// we have to search in all possible places that have methods.
NodeVM node = e.Parameter as NodeVM;
MethodVM method = Class?.Methods.FirstOrDefault(m => m.Nodes.Contains(node)) ??
Class?.Variables?.FirstOrDefault(v => v.HasGetter && v.GetterMethod.Nodes.Contains(node))?.GetterMethod ??
Class?.Variables?.FirstOrDefault(v => v.HasSetter && v.SetterMethod.Nodes.Contains(node))?.SetterMethod;
if (method != null)
{
method.SelectedNodes = new[] { node };
}
}
public List <NodeVM> GetNames()
{
List <NodeVM> namesVM = new List <NodeVM>();
Dictionary <string, string> ListName = new Dictionary <string, string>();
ListName.Add("1", "Akuma");
ListName.Add("2", "Ken");
ListName.Add("3", "Ryo");
foreach (KeyValuePair <string, string> name in ListName)
{
NodeVM nameVM = new NodeVM();
nameVM.Key = name.Key;
nameVM.Value = name.Value;
namesVM.Add(nameVM);
}
return(namesVM);
}
private void CommandDelete_Executed(object sender, ExecutedRoutedEventArgs e)
{
// Delete the currently selected node in the currently open method
// Only delete the node if it is not an entry or return node
if (methodEditor?.Method?.SelectedNode != null &&
!(methodEditor.Method.SelectedNode.Node is EntryNode) &&
!(methodEditor.Method.SelectedNode.Node is ReturnNode))
{
NodeVM deletedNode = methodEditor.Method.SelectedNode;
methodEditor.Method.SelectedNode = null;
// Remove the node from its method
// This will trigger the correct events in MethodVM
// so everything gets disconnected properly
deletedNode.Method.Nodes.Remove(deletedNode.Node);
}
}
void SelectedSymbol_DoubleTapped(object sender, Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e)
{
if (this.SelectedDiagram.SelectedItems != null && ((this.SelectedDiagram.SelectedItems as SelectorVM).Nodes as ICollection <object>).Count > 0)
{
((this.SelectedDiagram.SelectedItems as SelectorVM).Nodes as ICollection <object>).Clear();
}
NodeVM node = new NodeVM();
IGraphInfo graph = this.SelectedDiagram.Info as IGraphInfo;
node.OffsetX = (SelectedDiagram.ScrollSettings.ScrollInfo.ViewportWidth) / 2;
node.OffsetY = (SelectedDiagram.ScrollSettings.ScrollInfo.ViewportHeight) / 2;
node.UnitWidth = 100;
node.UnitHeight = 100;
node.Content = Stencil.SelectedSymbol.Content;
node.ContentTemplate = Stencil.SelectedSymbol.ContentTemplate;
node.IsSelected = true;
this.SelectedDiagram.NodeCollection.Add(node);
e.Handled = true;
}
public List <NodeVM> GetProfessionsByPeaples([FromBody] List <NodeVM> names)
{
List <NodeVM> namesProfession = new List <NodeVM>();
Dictionary <string, string> professions = new Dictionary <string, string>();
professions.Add("1", "Developer");
professions.Add("2", "Engineer");
professions.Add("3", "Support");
foreach (KeyValuePair <string, string> profession in professions)
{
NodeVM nameProfession = new NodeVM();
NodeVM name = names.FirstOrDefault(_ => _.Key == profession.Key);
nameProfession.Key = name.Value;
nameProfession.Value = profession.Value;
namesProfession.Add(nameProfession);
}
return(namesProfession);
}
private async Task AddNodes(int level, NodeVM parent, string folderIdentifier)
{
try
{
var children = (await this.client.Files.GetFolderItemsAsync(folderIdentifier)).ToArray();
var insertafter = parent;
var folders = new List <NodeVM>();
foreach (var item in children)
{
var vm = new NodeVM(this.client, level, item);
if (parent == null)
{
this.items.Add(vm);
}
else
{
var index = this.items.IndexOf(insertafter);
this.items.Insert(index, vm);
insertafter = vm;
}
if (item.Type == EntityType.Folder)
{
folders.Add(vm);
}
}
foreach (var folder in folders)
{
await this.AddNodes(level + 1, folder, folder.Item.Identifier);
}
}
catch (Exception e)
{
await this.DisplayAlert("FileList", e.Message, "OK");
}
finally
{
this.IsBusy = false;
}
}
public async Task <JsonResult> Register([FromBody] NodeVM node)
{
NodeVM _model = new NodeVM
{
ID = node.ID,
Port = node.Port,
Geolocation = node.Geolocation,
IPAddress = node.IPAddress
};
SaveNodeCommand _saveNodeCommand = new SaveNodeCommand(_model);
var _nodeID = await mediator.Send(_saveNodeCommand);
FetchAllNodeCommand fetchAllNode = new FetchAllNodeCommand();
var response = await mediator.Send(fetchAllNode);
return(Json(response));
}
public async Task <string> Handle(SendSelfCommand request, CancellationToken cancellationToken)
{
NodeVM _myNode = new NodeVM
{
ID = Guid.NewGuid(),
IPAddress = request.myEndpoint.Address.ToString(),
Port = request.myEndpoint.Port
};
var _json = JsonConvert.SerializeObject(_myNode);
using (var _client = new HttpClient())
using (var _data = new StringContent(_json, Encoding.UTF8, "application/json"))
{
_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var _response = _client.PostAsync(request.serverUrl, _data).Result;
return("Success");
}
}
public ActionResult Edit(NodeVM vm)
{
if (!ModelState.IsValid || !vm.IsValid(ModelState))
{
return(View(vm));
}
var node = NodeVM.ToModel(vm);
node.UpdateAt = DateTime.Now;
if (node.NodeId == 0)
{
node.NodeId = SequenceService.Next(Constants.SEQUENCE_SETTINGS_NODE, 1);
node.CreateAt = node.UpdateAt;
}
if (vm.Deleted)
{
node.DeleteAt = node.UpdateAt;
if (!NodeService.DeleteNode(node))
{
ModelState.AddModelError(string.Empty, "Failed to delete, other users may have edited the data during your processing");
return(View(vm));
}
Info = "Delete successfully";
return(RedirectToAction("Group", "Node"));
}
else
{
if (!NodeService.SaveNode(node))
{
ModelState.AddModelError(string.Empty, "Failed to save, other users may have edited the data during your processing");
return(View(vm));
}
Info = "Saved successfully";
return(RedirectToAction("Edit", new { id = node.NodeId }));
}
}
public void EditNode(NodeVM nodeVM)
{
Node node = _appDbContext.Nodes.Single(x => x.Id == nodeVM.Id);
if (nodeVM.Name != null)
{
node.Name = nodeVM.Name;
}
if (nodeVM.ParentNodeId != null)
{
if (nodeVM.ParentNodeId == 0)
{
node.ParentNodeId = null;
}
else
{
node.ParentNodeId = nodeVM.ParentNodeId;
}
}
_appDbContext.Update(node);
_appDbContext.SaveChanges();
}
private bool RemoveNodeFromTabs(NodeVM node)
{
return(RemoveFileFromTabs(node.AbsolutePath));
}
private TabItem GetTab(NodeVM toOpen)
{
return(GetTab(toOpen.AbsolutePath));
}
public void AddConnectedNode(NodeVM node)
{
ConnectedNodes.Add(node);
OnPropertyChanged(new PropertyChangedEventArgs("ConnectedNode"));
}
/// <summary>
/// This command executes when an item gets deleted.
/// </summary>
/// <param name="param">
/// The param.
/// </param>
private void ItemDeletingCommandExecute(object param)
{
int val = ((this.SelectedItems as FlowChartSelectorVm).Connectors as IEnumerable <object>).Count();
if (val == 0)
{
NodeVM deletingNode = (param as ItemDeletingEventArgs).Item as NodeVM;
if ((param as ItemDeletingEventArgs).Item is NodeVM &&
(deletingNode.Info as INodeInfo).InConnectors != null &&
(deletingNode.Info as INodeInfo).OutConnectors != null)
{
if ((deletingNode.Info as INodeInfo).InConnectors.Count() > 1 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() > 1 ||
(deletingNode.Info as INodeInfo).InConnectors.Count() == 1 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() == 0 ||
(deletingNode.Info as INodeInfo).InConnectors.Count() == 0 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() == 1 ||
(deletingNode.Info as INodeInfo).InConnectors.Count() == 0 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() > 1 ||
(deletingNode.Info as INodeInfo).InConnectors.Count() > 1 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() == 0)
{
(param as ItemDeletingEventArgs).DeleteDependentConnector = true;
}
else
{
(param as ItemDeletingEventArgs).DeleteDependentConnector = false;
if ((deletingNode.Info as INodeInfo).InConnectors.Count() == 1 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() == 1)
{
NodeVM newtargetNode = null;
ConnectorVM outconnector =
(deletingNode.Info as INodeInfo).OutConnectors.ToList()[0] as ConnectorVM;
newtargetNode = outconnector.TargetNode as NodeVM;
this.ConnectorCollection.Remove(outconnector);
ConnectorVM inconnector =
(deletingNode.Info as INodeInfo).InConnectors.ToList()[0] as ConnectorVM;
inconnector.TargetNode = newtargetNode;
if (inconnector.SourceNode == inconnector.TargetNode)
{
this.ConnectorCollection.Remove(inconnector);
}
}
else if ((deletingNode.Info as INodeInfo).InConnectors.Count() > 1 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() == 1)
{
NodeVM newtargetNode = null;
ConnectorVM outconnector =
(deletingNode.Info as INodeInfo).OutConnectors.ToList()[0] as ConnectorVM;
newtargetNode = outconnector.TargetNode as NodeVM;
this.ConnectorCollection.Remove(outconnector);
IEnumerable <IConnector> inConnectorsCollction =
(deletingNode.Info as INodeInfo).InConnectors;
foreach (ConnectorVM connector in inConnectorsCollction.ToList())
{
connector.TargetNode = newtargetNode;
}
}
else if ((deletingNode.Info as INodeInfo).InConnectors.Count() == 1 &&
(deletingNode.Info as INodeInfo).OutConnectors.Count() > 1)
{
NodeVM newtargetNode = null;
ConnectorVM inconnector =
(deletingNode.Info as INodeInfo).InConnectors.ToList()[0] as ConnectorVM;
newtargetNode = inconnector.SourceNode as NodeVM;
this.ConnectorCollection.Remove(inconnector);
IEnumerable <IConnector> outConnectorsCollection =
(deletingNode.Info as INodeInfo).OutConnectors;
foreach (ConnectorVM connector in outConnectorsCollection.ToList())
{
connector.SourceNode = newtargetNode;
}
}
}
}
}
}
public SetNodePositionParameters(NodeVM node, double newPositionX, double newPositionY)
{
Node = node;
NewPositionX = newPositionX;
NewPositionY = newPositionY;
}
/// <summary>
/// Creates a node selection message to deselect all previous
/// nodes and select the given node.
/// </summary>
/// <param name="node">Node to select.</param>
public NodeSelectionMessage(NodeVM node)
{
Nodes = new[] { node };
DeselectPrevious = true;
}
private async Task <bool> RemoveNodeFromTabs(NodeVM node)
{
return(await RemoveFileFromTabs(node.AbsolutePath));
}
