public static Node GetNode(NodeVm node) { return(node == null ? null : new Node { About = node.About, Country = node.Country, Id = node.Id, Name = node.Name, Photo = node.Photo, Startday = node.StartDay, Storage = node.Storage, Routing = node.Routing, Tag = node.Tag, Visible = node.Visible, DomainNodes = node.Domains ?.Select(domain => new DomainNode { NodeId = node.Id, Domain = domain }) .ToList(), ClientsPort = node.ClientsPort, NodesPort = node.NodesPort, AdminEmail = node.AdminEmail, SupportEmail = node.SupportEmail, PermanentlyDeleting = node.PermanentlyDeleting, EncryptionType = node.EncryptionType, RegistrationMethod = node.RegistrationMethod, UserRegistrationAllowed = node.UserRegistrationAllowed }); }
void Display(NodeVm rootNodeVm) { var tvis = rootNodeVm.ToTreeViewItem(); TreeViewItems.Clear(); TreeViewItems.Add(tvis); }
public async void CreateOrUpdateNodeInformationAsync(NodeVm nodeInfo) { try { using (MessengerDbContext context = contextFactory.Create()) { Node node = await context.Nodes .Include(opt => opt.DomainNodes) .Include(opt => opt.Ipnodes) .FirstOrDefaultAsync(opt => opt.Id == nodeInfo.Id) .ConfigureAwait(false); if (node == null) { node = NodeConverter.GetNode(nodeInfo); await context.Nodes.AddAsync(node).ConfigureAwait(false); } else { node = NodeConverter.GetNode(node, nodeInfo); context.Nodes.Update(node); } await context.SaveChangesAsync().ConfigureAwait(false); } } catch (Exception ex) { Logger.WriteLog(ex); } }
public static Node GetNode(Node changedNode, NodeVm newNode) { if (newNode == null || changedNode == null) { return(null); } changedNode.Id = newNode.Id; changedNode.Name = newNode.Name; changedNode.Photo = newNode.Photo; changedNode.Routing = newNode.Routing; changedNode.Startday = newNode.StartDay; changedNode.Storage = newNode.Storage; changedNode.Tag = newNode.Tag; changedNode.Visible = newNode.Visible; changedNode.About = newNode.About; changedNode.Country = newNode.Country; changedNode.DomainNodes = newNode.Domains ?.Select(domain => new DomainNode { NodeId = newNode.Id, Domain = domain }) .ToList(); changedNode.NodesPort = newNode.NodesPort; changedNode.ClientsPort = newNode.ClientsPort; changedNode.SupportEmail = newNode.SupportEmail; changedNode.AdminEmail = newNode.AdminEmail; changedNode.EncryptionType = newNode.EncryptionType; changedNode.PermanentlyDeleting = newNode.PermanentlyDeleting; changedNode.RegistrationMethod = newNode.RegistrationMethod; changedNode.UserRegistrationAllowed = newNode.UserRegistrationAllowed; return(changedNode); }
public async Task NewOrEditNodeAsync(NodeVm targetNode) { try { using (MessengerDbContext context = contextFactory.Create()) { var node = await context.Nodes.FindAsync(targetNode.Id).ConfigureAwait(false); if (node == null) { node = NodeConverter.GetNode(targetNode); await context.AddAsync(node).ConfigureAwait(false); } else { node = NodeConverter.GetNode(targetNode); context.Update(node); } await context.SaveChangesAsync().ConfigureAwait(false); } } catch (Exception ex) { Logger.WriteLog(ex); } }
internal void DoClicked(NodeVm vm) { if (Clicked != null && vm != null) { Clicked(this, new NodeVmArgs(vm)); } }
void Load() { // load node graph from db Node rootNode = TreeServiceClient.GetRootNode(); // convert node objects to vm objects NodeVm rootNodeVm = rootNode.ToNodeVm(); // add effective behaviour ClientBL.AddEffectiveBehavior(rootNodeVm, null, _implementedCommands); // WPF-specific display logic Display(rootNodeVm); }
public async Task <Response> CreateResponseAsync() { if (request.NodesId == null || !request.NodesId.Any()) { NodeVm node = await nodesService.GetAllNodeInfoAsync(NodeSettings.Configs.Node.Id).ConfigureAwait(false); return(new NodesResponse(request.RequestId, node)); } else { List <NodeVm> nodes = await nodesService.GetNodesAsync(request.NodesId).ConfigureAwait(false); return(new NodesResponse(request.RequestId, nodes)); } }
public Node(NodeVm node) { Id = node.Id; Name = node.Name; Tag = node.Tag; About = node.About; Photo = node.Photo; Country = node.Country; Startday = node.StartDay; Visible = node.Visible; Storage = node.Storage; Routing = node.Routing; ClientsPort = node.ClientsPort; NodesPort = node.NodesPort; }
public static void AddEffectiveBehavior(NodeVm nodeVm, User user, Dictionary <string, ICommand> implementedCommands) { foreach (var node in nodeVm.ToList()) { List <string> allpossibleCommands = TreeServiceClient.GetPossibleCommandsByNodeTypeId(node.NodeTypeId); foreach (var possibleCommand in allpossibleCommands) { if (IsCommandAllowedForUserAndNode(possibleCommand, user, node)) { if (IsCommandImplemented(possibleCommand, implementedCommands)) { AddCommandImplementationToNode(implementedCommands, possibleCommand, node); } else { AddNotImplementedCommandToNode(implementedCommands, possibleCommand, node); } } } } }
public async Task <NodeVm> EditNodeAsync(NodeVm node) { if (!await TryConnectAsync().ConfigureAwait(false)) { throw new LicensorException("Unable to establish connection with licensor."); } EditNodeRequest request = new EditNodeRequest(node); await SendRequestAsync(request).ConfigureAwait(false); var response = await GetResponseAsync(request).ConfigureAwait(false); if (response is EditNodeResponse editResponse) { NodeSettings.Configs.LicensorSign = editResponse.LicensorSign; return(editResponse.Node); } else if (response is ResultResponse resultResponse) { throw new ResponseException($"Failed to edit node. Response error message: {resultResponse.ErrorMessage}"); } throw new ResponseException($"Unknown response type: {response.ResponseType}"); }
protected override void OnAfterAddChild(NodeVm node) { Items.Add(node); }
static void AddCommandImplementationToNode(IReadOnlyDictionary <string, ICommand> implementedCommands, string possibleCommand, NodeVm node) { if (node.NodeBehavior == null) { node.NodeBehavior = new NodeBehavior(node); } node.NodeBehavior.AddCommand(possibleCommand, implementedCommands[possibleCommand]); }
public async Task <bool> AuthAsync(bool recursive = false) { if (string.IsNullOrWhiteSpace(NodeSettings.Configs.LicensorUrl)) { return(false); } if (webSocket.State != WebSocketState.Open) { try { await ConnectAndListenAsync().ConfigureAwait(false); } catch (Exception ex) { throw new LicensorException("No connection.", ex); } } try { AuthRequest request = new AuthRequest(NodeData.Instance.NodeKeys.PublicKey, NodeSettings.Configs.Node.Id); await SendRequestAsync(request).ConfigureAwait(false); var response = await GetResponseAsync(request).ConfigureAwait(false); if (response is AuthResponse authResponse) { symmetricKey = Encryptor.AsymmetricDecryptKey( authResponse.EncryptedKey, NodeData.Instance.NodeKeys.PrivateKey, authResponse.LicensorSignPublicKey, NodeData.Instance.NodeKeys.Password).Data; var nodeDecryptedData = Encryptor.SymmetricDataDecrypt( authResponse.EncryptedNode, authResponse.LicensorSignPublicKey, symmetricKey, NodeData.Instance.NodeKeys.Password).DecryptedData; var tokenDecryptedData = Encryptor.SymmetricDataDecrypt( authResponse.EncryptedAccessToken, authResponse.LicensorSignPublicKey, symmetricKey, NodeData.Instance.NodeKeys.Password).DecryptedData; NodeVm node = ObjectSerializer.ByteArrayToObject <NodeVm>(nodeDecryptedData); var licensorSign = authResponse.LicensorSign; node.StartDay = node.StartDay.ToUniversalTime(); var nodeJson = ObjectSerializer.ObjectToJson(node); licensorPublicKey = authResponse.LicensorPublicKey; licensorSignPublicKey = authResponse.LicensorSignPublicKey; expiredAt = DateTime.UtcNow.AddDays(7).ToUnixTime(); bool isValid = Encryptor.CheckSign( licensorSign.Sign, licensorSignPublicKey, Encoding.UTF8.GetBytes(nodeJson), NodeData.Instance.NodeKeys.Password); if (isValid) { NodeSettings.Configs.LicensorSign = licensorSign; } return(true); } else if (response is ResultResponse resultResponse) { if (resultResponse.ErrorCode == ObjectsLibrary.LicensorResponseClasses.ErrorCode.KeyNotFound || resultResponse.ErrorCode == ObjectsLibrary.LicensorResponseClasses.ErrorCode.IdNotFound) { if (!recursive) { var nodeKeys = await AppServiceProvider.Instance.KeysService.GetActualNodeKeysAsync(NodeSettings.Configs.Node.Id).ConfigureAwait(false); await AddNewKeyAsync(nodeKeys.PublicKey, nodeKeys.SignPublicKey, nodeKeys.KeyId, nodeKeys.ExpirationTime, nodeKeys.GenerationTime, false).ConfigureAwait(false); await AuthAsync(recursive : true).ConfigureAwait(false); return(true); } } throw new ResponseException($"Authorization failed. Response error message: {resultResponse.ErrorMessage}"); } return(false); } catch (Exception ex) { Logger.WriteLog(ex); return(false); } }
protected override void OnClicked(NodeVm vm) { ToolBarTray.DoClicked(vm); }
protected abstract override void OnClicked(NodeVm vm);
protected override void OnClicked(NodeVm vm) { this.RibbonPage.Ribbon.DoClicked(vm); }
static void AddNotImplementedCommandToNode(Dictionary <string, ICommand> implementedCommands, string possibleCommand, NodeVm node) { if (node.NodeBehavior == null) { node.NodeBehavior = new NodeBehavior(node); } node.NodeBehavior.AddCommand(possibleCommand, NotImplementedCommand); }
public async Task <IActionResult> Get(string id) { try { var fileInfo = await filesService.GetFileInfoAsync(id).ConfigureAwait(false); if (fileInfo == null) { var nodeConnections = connectionsService.GetNodeConnections().Where(conn => conn.NodeWebSocket.State == WebSocketState.Open); foreach (var nodeConnection in nodeConnections) { var filesInfo = await nodeRequestSender.GetFilesInformationAsync(new List <string> { id }, nodeConnection.Node.Id).ConfigureAwait(false); if (!filesInfo.Any()) { continue; } Uri fileUri = new Uri($"https://{nodeConnection.Node.Domains.FirstOrDefault()}:{nodeConnection.Node.NodesPort}/api/Files/{id}"); var fileRequest = WebRequest.CreateHttp(fileUri); fileRequest.Method = HttpMethods.Get; var fileResponse = (HttpWebResponse)await fileRequest.GetResponseAsync().ConfigureAwait(false); var contentDisposition = fileResponse.Headers["content-disposition"]; string filename = id; if (contentDisposition != null) { System.Net.Mime.ContentDisposition disposition = new System.Net.Mime.ContentDisposition(contentDisposition); filename = disposition.FileName; } return(File(fileResponse.GetResponseStream(), MediaTypeNames.Application.Octet, filename)); } return(StatusCode(StatusCodes.Status404NotFound)); } if (fileInfo.Storage == "Local" || string.IsNullOrWhiteSpace(fileInfo.Storage)) { LocalFileStorage localFileStorage = new LocalFileStorage(); if (fileInfo != null && fileInfo.Url != null) { return(File(await localFileStorage.GetStreamAsync(fileInfo.Url).ConfigureAwait(false), MediaTypeNames.Application.Octet, fileInfo.FileName)); } else if (fileInfo != null && fileInfo.Url == null && fileInfo.NodeId != NodeSettings.Configs.Node.Id) { NodeVm nodeInformation = await nodesService.GetAllNodeInfoAsync(fileInfo.NodeId).ConfigureAwait(false); Uri fileUri = new Uri($"https://{nodeInformation.Domains.FirstOrDefault()}:{nodeInformation.NodesPort}/api/Files/{fileInfo.Id}"); var fileRequest = WebRequest.CreateHttp(fileUri); fileRequest.Method = HttpMethods.Get; var fileResponse = await fileRequest.GetResponseAsync().ConfigureAwait(false); return(File(fileResponse.GetResponseStream(), MediaTypeNames.Application.Octet, fileInfo.FileName)); } else { return(NotFound()); } } else if (!string.IsNullOrWhiteSpace(fileInfo.Storage)) { var stream = await fileStorage.GetStreamAsync(fileInfo.Id).ConfigureAwait(false); return(File(stream, MediaTypeNames.Application.Octet, fileInfo.FileName)); } else { return(NotFound()); } } catch (DownloadFileException ex) { if (ex.InnerException is WebException webException) { Console.WriteLine(ex.InnerException.ToString()); return(StatusCode(StatusCodes.Status503ServiceUnavailable)); } return(StatusCode(StatusCodes.Status500InternalServerError)); } catch (ObjectDoesNotExistsException) { return(NotFound()); } catch (Exception ex) { Logger.WriteLog(ex); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
internal void RemoveFromItems(NodeVm node) { Items.Remove(node); }