XmppProtocol.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Networking.XMPP.Server;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.DisplayableParameters;
using Waher.Service.IoTBroker.Sources.Protocols.Commands;
 
namespace Waher.Service.IoTBroker.Sources.Protocols
{
    public class XmppProtocol : INode
    {
        private readonly XmppServer server;
        
        public XmppProtocol(XmppServer Server)
        {
            this.server = Server;
        }
 
        public string LocalId => this.NodeId;
        public string LogId => this.NodeId;
        public string NodeId => "XMPP";
        public string SourceId => "Protocols";
        public string Partition => string.Empty;
        public bool HasChildren => false;
        public bool ChildrenOrdered => false;
        public bool IsReadable => false;
        public bool IsControllable => false;
        public INode Parent => null;
        public DateTime LastChanged => DateTime.MinValue;
        public Task<IEnumerable<INode>> ChildNodes => null;
 
        public NodeState State
        {
            get
            {
                return NodeState.None;  // TODO: Check XMPP Server state.
            }
        }
 
        public Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        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 StringParameter("XmppPorts", await Language.GetStringAsync(typeof(XmppServerModule), 6, "C2S Ports"), HttpProtocol.PortsToString(this.server.OpenC2SPorts)));
            Parameters.AddLast(new StringParameter("XmppsPorts", await Language.GetStringAsync(typeof(XmppServerModule), 7, "S2S Ports"), HttpProtocol.PortsToString(this.server.OpenS2SPorts)));
 
            return Parameters;
        }
 
        public Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Message>>(null);
        }
 
        public Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 40, "XMPP Protocol");
        }
 
        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);
        }
 
        public bool HasCommands => true;
 
        public Task<IEnumerable<ICommand>> Commands
        {
            get
            {
                return Task.FromResult<IEnumerable<ICommand>>(new ICommand[]
                {
                    new XmppStatistics()
                });
            }
        }
    }
}