Enter.cs

using System.Text;
using System.Threading.Tasks;
using Waher.IoTGateway;
using Waher.Networking.XMPP.DataForms;
using Waher.Networking.XMPP.MUC;
 
namespace Waher.Service.IoTBroker.Admin.Muc
{
    public class Enter : CommandTwoParameters
    {
        public Enter()
            : base()
        {
        }
 
        public override string Name => "Enter";
 
        public override bool AppliesTo(string CommandLine, string[] Arguments, out object Details)
        {
            Details = null;
            int c = Arguments.Length;
            return c == 2 || c == 3;
        }
 
        public override async Task Execute(ChatState State, string[] Arguments, string OrgMessage, ResponseCallbackHandler ResponseCallback)
        {
            if (Gateway.MucClient is null)
            {
                await ResponseCallback("Multi-User Chat disabled.", string.Empty);
                return;
            }
 
            ParseRoom(Arguments[0], out string RoomId, out string Domain);
 
            string NickName = Arguments[1];
            string Password = Arguments.Length > 2 ? Arguments[2] : string.Empty;
 
            await Execute(RoomId, Domain, NickName, Password, this.Permanent, true, ResponseCallback);
        }
 
        internal static Task Execute(string RoomId, string Domain, string NickName, string Password, bool Permanent,
            bool RegisterIfRequested, ResponseCallbackHandler ResponseCallback)
        {
            Gateway.MucClient.EnterRoom(RoomId, Domain, NickName, Password, async (Sender, e) =>
            {
                if (e.Ok)
                {
                    StringBuilder sb = new StringBuilder();
                    bool First = true;
 
                    sb.Append("Entered in `");
                    sb.Append(e.RoomId);
                    sb.Append('@');
                    sb.Append(e.Domain);
                    sb.Append("` as `");
                    sb.Append(e.NickName);
                    sb.Append("`.");
 
                    foreach (MucStatus Status in e.MucStatus)
                    {
                        if (First)
                        {
                            First = false;
                            sb.Append(" Status: ");
                        }
                        else
                            sb.Append(", ");
 
                        sb.Append('`');
                        sb.Append(Status.ToString());
                        sb.Append('`');
                    }
 
                    if (!First)
                        sb.Append(".");
 
                    await ResponseCallback(sb.ToString(), string.Empty);
                    await XmppServerModule.Instance.EnterRoom(RoomId, Domain, NickName, Password, Permanent);
 
                    if (e.Role == Role.None || e.Role == Role.Visitor)
                    {
                        await ResponseCallback("Requesting voice privileges...", string.Empty);
                        await Gateway.MucClient.RequestVoice(RoomId, Domain);
                    }
                }
                else if (e.StanzaError is Networking.XMPP.StanzaErrors.RegistrationRequiredException && RegisterIfRequested)
                {
                    await ResponseCallback("Room registration required.", string.Empty);
                    await ResponseCallback("Requesting registration form...", string.Empty);
 
                    await Gateway.MucClient.GetRoomRegistrationForm(RoomId, Domain, async (sender2, e2) =>
                    {
                        if (e2.Ok && !(e2.Form is null))
                        {
                            foreach (Field F in e2.Form.Fields)
                            {
                                switch (F.Var)
                                {
                                    case "muc#register_first":
                                        string s = IoTGateway.Setup.LegalIdentityConfiguration.Instance.FirstName;
                                        if (string.IsNullOrEmpty(s))
                                            s = "N/A";
 
                                        await F.SetValue(s);
                                        break;
 
                                    case "muc#register_last":
                                        s = IoTGateway.Setup.LegalIdentityConfiguration.Instance.LastName;
                                        if (string.IsNullOrEmpty(s))
                                            s = "N/A";
 
                                        await F.SetValue(s);
                                        break;
 
                                    case "muc#register_roomnick":
                                        await F.SetValue(NickName);
                                        break;
 
                                    case "muc#register_url":
                                    case "muc#register_faqentry":
                                        await F.SetValue(Gateway.GetUrl("/"));
                                        break;
 
                                    case "muc#register_email":
                                        await F.SetValue(Gateway.XmppClient.BareJID);
                                        break;
                                }
                            }
 
                            await ResponseCallback("Submitting registration form...", string.Empty);
                            await e2.Form.Submit();
                        }
                        else if (e2.AlreadyRegistered)
                            await ResponseCallback("Already registered with nick name `" + e2.UserName + "`", string.Empty);
                        else
                            await ResponseCallback(string.IsNullOrEmpty(e2.ErrorText) ? "Unable to get registration form." : e2.ErrorText, string.Empty);
 
                    }, (sender2, e2) =>
                    {
                        if (e2.Ok)
                            return ResponseCallback("Room registration submitted. You can enter the room as soon as the request has been approved...", string.Empty);
                        else
                            return ResponseCallback(string.IsNullOrEmpty(e2.ErrorText) ? "Unable to register with room." : e2.ErrorText, string.Empty);
                    }, null);
                }
                else
                    await ResponseCallback(string.IsNullOrEmpty(e.ErrorText) ? "Unable to enter room." : e.ErrorText, string.Empty);
            }, null);
 
            return Task.CompletedTask;
        }
 
        public virtual bool Permanent => false;
 
        internal static void ParseRoom(string s, out string RoomId, out string Domain)
        {
            int i = s.IndexOf('@');
 
            if (i < 0)
            {
                RoomId = s;
                Domain = Gateway.MucClient.ComponentAddress;
            }
            else
            {
                RoomId = s.Substring(0, i);
                Domain = s.Substring(i + 1);
            }
        }
 
        public override HelpItem[] GetHelp()
        {
            return new HelpItem[] { new HelpItem(this.Name + " " + this.ParameterName + " " + this.Parameter2Name + "[ PASSWORD]", this.HelpParagraphs) };
        }
 
        public override string ParameterName => "ROOM";
 
        public override string Parameter2Name => "NICKNAME";
 
        public override string[] HelpParagraphs => new string[]
        {
            "Temporarily enters a Multi-User Chat Room named `ROOM`, using the nick-name `NICKNAME`.",
            "You can leave the room issuing a `leave` command. The broker also leaves the room when it is restarted.",
            "An optional `PASSWORD` can be provided to enter password-protected rooms."
        };
    }
}