PopMessages.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Xmpp
{
    public class PopMessages : AgentXmppPostResource
    {
        public PopMessages()
            : base("Xmpp/PopMessages",
                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(PopMessages).Namespace + ".JSON.PopMessages.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(PopMessages).Namespace + ".XML.PopMessages.req");
 
        public override bool Synchronous => false;
 
        public override Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            int MaxCount = int.MaxValue;
 
            if (Parameters.TryGetValue("PMaxCount", out IElement E) && !(E is null) &&
                E.AssociatedObjectValue is double d2)
            {
                MaxCount = (int)d2;
            }
 
            Task _ = Task.Run(async () =>
            {
                try
                {
                    PersistenceLayer PersistenceLayer = XmppServerModule.PersistenceLayer ?? new PersistenceLayer();
                    NamedDictionary<string, object> Result = new NamedDictionary<string, object>("MessagesResult", AgentNamespace);
                    List<object> Messages2 = new List<object>();
                    IEnumerable<IOfflineMessage> Messages;
                    bool Found = false;
 
                    Messages = await PersistenceLayer.GetOfflineMessages(User.UserName, MaxCount);
 
                    if (!(Messages is null))
                    {
                        foreach (IOfflineMessage Message in Messages)
                        {
                            StringBuilder Xml = new StringBuilder();
                            Xml.Append("<message xmlns='");
                            Xml.Append(ClientConnection.C2SNamespace);
                            Xml.Append("'>");
                            Xml.Append(Message.ContentXml);
                            Xml.Append("</message>");
 
                            XmlDocument Doc = new XmlDocument()
                            {
                                PreserveWhitespace = true
                            };
                            Doc.LoadXml(Xml.ToString());
 
                            Messages2.Add(new Dictionary<string, object>()
                            {
                                { "id", Message.Id },
                                { "from", Message.From.Value },
                                { "to", Message.To.Value },
                                { "lang", Message.Language },
                                { "type", Message.Type },
                                { "timestamp", Message.Timestamp },
                                { "Content", Doc.DocumentElement.ChildNodes }
                            });
 
                            Found = true;
                            MaxCount--;
                            if (MaxCount <= 0)
                                break;
                        }
                    }
 
                    Result["Messages"] = Messages2.ToArray();
 
                    await Response.Return(Result);
 
                    if (Found)
                        await PersistenceLayer.DeleteOfflineMessages(Messages);
                }
                catch (XmlException ex)
                {
                    await Response.SendResponse(XML.AnnotateException(ex));
                }
                catch (Exception ex)
                {
                    await Response.SendResponse(ex);
                }
            });
 
            return Task.CompletedTask;
        }
    }
}