SendSubscriptionAccepted.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Server;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Xmpp
{
    public class SendSubscriptionAccepted : AgentXmppPostResource
    {
        public SendSubscriptionAccepted()
            : base("Xmpp/SendSubscriptionAccepted",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(SendSubscriptionAccepted).Namespace + ".JSON.SendSubscriptionAccepted.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(SendSubscriptionAccepted).Namespace + ".XML.SendSubscriptionAccepted.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            string To = (string)Parameters["PTo"].AssociatedObjectValue;
 
            if (string.IsNullOrEmpty(To))
                throw new BadRequestException("Missing recipient JID.");
 
            if (!IsValidBareJID(To))
                throw new BadRequestException("Recpient must be a Bare JID.");
            string Id = (string)Parameters["PId"]?.AssociatedObjectValue;
 
            if (string.IsNullOrEmpty(Id))
                Id = Guid.NewGuid().ToString();
 
            Dictionary<string, object> NewItem;
            bool Result;
 
            if (XmppServerModule.Server is null)
            {
                XmppClient Client = Gateway.XmppClient;
 
                if (Client is null)
                {
                    if (Types.TryGetModuleParameter("XMPP", out XmppClient Client2))
                        Client = Client2;
                }
 
                if (Client is null)
                    throw new ServiceUnavailableException("XMPP Client not available.");
 
                Networking.XMPP.Events.PresenceEventArgs e = Client.GetSubscriptionRequest(To)
                    ?? throw new NotFoundException("Presence subscription request not found.");
 
                Id = e.Id;
 
                await e.Accept();
                Result = true;
 
                Networking.XMPP.RosterItem Item = Client[To];
 
                NewItem = new Dictionary<string, object>()
                {
                    { "bareJid", Item?.BareJid ?? To },
                    { "pendingSubscription", (Item?.PendingSubscription ?? PendingSubscription.Subscribe) == PendingSubscription.Subscribe },
                    { "status", Item?.State ?? SubscriptionState.None },
                    { "name", Item?.Name ?? string.Empty },
                    { "Groups", Item?.Groups ?? Array.Empty<string>() }
                };
            }
            else
            {
                PersistenceLayer PersistenceLayer = XmppServerModule.PersistenceLayer ?? new PersistenceLayer();
                IRosterItem Item = await PersistenceLayer.GetRosterItem(User.UserName, To);
                SubscriptionStatus State = Item?.Subscription ?? SubscriptionStatus.none;
 
                switch (State)
                {
                    case SubscriptionStatus.none:
                        State = SubscriptionStatus.from;
                        break;
 
                    case SubscriptionStatus.to:
                        State = SubscriptionStatus.both;
                        break;
                }
 
                await PersistenceLayer.SetRosterItem(User.UserName, To,
                    Item?.Name ?? string.Empty, State, null, null);
 
                Result = await XmppServerModule.Server.Presence("subscribed", Id,
                    new XmppAddress(To),
                    new XmppAddress(User.UserName + "@" + XmppServerModule.Server.Domain),
                    string.Empty, string.Empty, XmppServerModule.Server);
 
                Item = await PersistenceLayer.GetRosterItem(User.UserName, To);
                NewItem = new Dictionary<string, object>()
                {
                    { "bareJid", Item.BareJid.Value },
                    { "pendingSubscription", Item.PendingSubscription },
                    { "status", Item.Subscription },
                    { "name", Item.Name },
                    { "Groups", Item.Groups }
                };
            }
 
            await Response.Return(new NamedDictionary<string, object>("SubscriptionAcceptedResult", AgentNamespace)
            {
                { "sent", Result },
                { "id", Id },
                { "RosterItem", NewItem }
            });
        }
    }
}