ServerConnections.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Networking.XMPP.Server;
using Waher.Networking.XMPP.Server.Statistics;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.Connections
{
    public class ServerConnections : INode
    {
        public ServerConnections()
        {
        }
 
        public string LocalId => "S2S";
        public string LogId => "S2S";
        public string NodeId => "S2S";
        public string SourceId => "Connections";
        public string Partition => string.Empty;
        public bool ChildrenOrdered => false;
        public bool IsReadable => false;
        public bool IsControllable => false;
        public bool HasCommands => false;
        public INode Parent => null;
        public DateTime LastChanged => DateTime.MinValue;
        public Task<IEnumerable<ICommand>> Commands => null;
 
        public NodeState State
        {
            get
            {
                return NodeState.None;
            }
        }
 
        public Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is ServerConnection);
        }
 
        public Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(false);
        }
 
        public Task AddAsync(INode Child)
        {
            throw new NotSupportedException();
        }
 
        public Task<bool> CanAddAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanEditAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return XmppServerModule.IsAdmin(Caller.From);
        }
 
        public Task DestroyAsync()
        {
            throw new NotSupportedException();
        }
 
        public async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Parameters = new LinkedList<Parameter>();
 
            Parameters.AddLast(new Int32Parameter("NrConnections", await Language.GetStringAsync(typeof(XmppServerModule), 10, "#Connections"), XmppServerModule.Server.NrServerConnections));
 
            return Parameters;
        }
 
        public bool HasChildren => XmppServerModule.Server.NrServerConnections > 0;
 
        public Task<IEnumerable<INode>> ChildNodes
        {
            get
            {
                S2sEndpointStatistics[] Statistics = XmppServerModule.GetServerConnectionStatistics();
                int i, c = Statistics.Length;
                ServerConnection[] Result = new ServerConnection[c];
 
                for (i = 0; i < c; i++)
                {
                    S2sEndpointStatistics Stat = Statistics[i];
 
                    if (!XmppServerModule.Server.TryGetS2sEndpoint(Stat.Name, out IS2SEndpoint Endpoint))
                        Endpoint = null;
 
                    Result[i] = new ServerConnection(this, Stat, Endpoint);
                }
 
                return Task.FromResult<IEnumerable<INode>>(Result);
            }
        }
 
        public Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Message>>(null);
        }
 
        public Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 20, "S2S Connections");
        }
 
        public Task<bool> MoveDownAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> MoveUpAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task UpdateAsync()
        {
            return Task.CompletedTask;
        }
 
        public Task<bool> RemoveAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
    }
}