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);
}
