WebNode.cs

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Xml;
using Waher.Content.Html;
using Waher.Content.Markdown;
using Waher.Content.Xml;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Script;
using Waher.Service.IoTBroker.PubSub;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class WebNode : HttpSynchronousResource, IHttpGetMethod
    {
        private readonly CaseInsensitiveString nodeName;
 
        public WebNode(CaseInsensitiveString NodeName)
            : base("/" + NodeName)
        {
            this.nodeName = NodeName;
        }
 
        public override bool HandlesSubPaths => true;
        public override bool UserSessions => true;
        public bool AllowsGET => true;
 
        private static async Task<PubSubContent.Content> GetContent(PubSubItem Item)
        {
            if (!(Item.Tag is PubSubContent.Content Content))
            {
                XmlDocument Xml = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                Xml.LoadXml(Item.Payload);
 
                Content = await PubSubContent.Content.Deserialize(Xml.DocumentElement, Item.Publisher,
                    new PubSubContent.NodeReference[] { new PubSubContent.NodeReference(Item.Node, Item.Service) }, Item.ItemId);
                Item.Tag = Content;
            }
 
            return Content;
        }
 
        public async Task GET(HttpRequest Request, HttpResponse Response)
        {
            Variables v;
            MarkdownSettings Settings;
            MarkdownDocument Doc;
            CaseInsensitiveString ItemId = Request.SubPath;
            string Markdown;
            string HTML;
            string FileName;
 
            if (string.IsNullOrEmpty(ItemId) || ItemId == "/")
            {
                PubSubNode Node = await XmppServerModule.GetPubSubNodeAsync(this.nodeName)
                    ?? throw new NotFoundException();
 
                v = new Variables(new Variable("Node", Node));
                FileName = Path.Combine(Gateway.RootFolder, "PublicNode.md");
            }
            else
            {
                PubSubItem Item = await XmppServerModule.PubSub.LoadItem(CaseInsensitiveString.Empty, this.nodeName, ItemId);
 
                if (Item is null && ItemId.StartsWith("/"))
                    Item = await XmppServerModule.PubSub.LoadItem(CaseInsensitiveString.Empty, this.nodeName, ItemId.Substring(1));
 
                if (Item is null)
                {
                    string ItemId2 = HttpUtility.UrlDecode(ItemId);
 
                    if (ItemId != ItemId2)
                    {
                        ItemId = ItemId2;
                        Item = await XmppServerModule.PubSub.LoadItem(CaseInsensitiveString.Empty, this.nodeName, ItemId);
 
                        if (Item is null && ItemId.StartsWith("/"))
                            Item = await XmppServerModule.PubSub.LoadItem(CaseInsensitiveString.Empty, this.nodeName, ItemId.Substring(1));
                    }
 
                    if (Item is null)
                        throw new NotFoundException();
                }
 
                PubSubContent.Content Content = await GetContent(Item);
 
                v = new Variables(new Variable("Content", Content), new Variable("Item", Item), new Variable("ShowLink", false));
                FileName = Path.Combine(Gateway.RootFolder, "PublicItem.md");
            }
 
            Settings = PubSubContent.MarkdownContent.GetMarkdownSettings(v, true);
            Markdown = File.ReadAllText(FileName);
            Doc = await MarkdownDocument.CreateAsync(Markdown, Settings, FileName, string.Empty, Request.Header.GetURL());
            HTML = await Doc.GenerateHTML();
 
            Response.ContentType = HtmlCodec.DefaultContentType;
            await Response.Write(HTML);
        }
 
        public static async Task<string> GetItemTitle(PubSubContent.Content Content, PubSubItem Item)
        {
            string s;
 
            if (Content is null)
                return string.Empty;
 
            try
            {
                if (Content is PubSubContent.MarkdownContent MarkdownContent)
                {
                    s = await MarkdownContent.TryGetMetaDataValue("Title");
                    if (!string.IsNullOrEmpty(s))
                        return s;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            s = Content.ObjectOrItemId ?? string.Empty;
            int i = s.LastIndexOf('/');
            if (i >= 0)
                s = s.Substring(i + 1);
 
            StringBuilder sb = new StringBuilder();
            bool Capital = true;
 
            foreach (char ch in s)
            {
                if (ch == '_')
                {
                    sb.Append(' ');
                    Capital = true;
                }
                else if (Capital)
                {
                    sb.Append(char.ToUpper(ch));
                    Capital = false;
                }
                else
                    sb.Append(char.ToLower(ch));
            }
 
            return sb.ToString().Trim();
        }
 
        public static async Task<string> GetItemDescription(PubSubContent.Content Content, PubSubItem Item)
        {
            string s;
 
            try
            {
                if (Content is null)
                    return string.Empty;
 
                if (Content is PubSubContent.MarkdownContent MarkdownContent)
                {
                    s = await MarkdownContent.TryGetMetaDataValue("Description");
                    if (!string.IsNullOrEmpty(s))
                        return s;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            return "Item published on node " + Item?.Node;
        }
 
        public static async Task<string> GetItemDate(PubSubContent.Content Content, PubSubItem Item)
        {
            string s;
 
            if (Content is null)
                return string.Empty;
 
            try
            {
                if (Content is PubSubContent.MarkdownContent MarkdownContent)
                {
                    s = await MarkdownContent.TryGetMetaDataValue("Date");
                    if (!string.IsNullOrEmpty(s))
                        return s;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            if (Item is null)
                return string.Empty;
            else
                return XML.Encode(Item.Created, true);
        }
 
        public static async Task<string> GetItemAuthor(PubSubContent.Content Content, PubSubItem Item)
        {
            string s;
 
            if (Content is null)
                return string.Empty;
 
            try
            {
                if (Content is PubSubContent.MarkdownContent MarkdownContent)
                {
                    s = await MarkdownContent.TryGetMetaDataValue("Author");
                    if (!string.IsNullOrEmpty(s))
                        return s;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            return Item?.Publisher ?? string.Empty;
        }
 
        public static PubSubItem[] GetItems(CaseInsensitiveString Node, string From, int MaxCount, out bool More, out string Last)
        {
            Tuple<PubSubItem[], bool, string> T = GetItemsAsync(Node, From, MaxCount).Result;
 
            More = T.Item2;
            Last = T.Item3;
 
            return T.Item1;
        }
 
        public static async Task<Tuple<PubSubItem[], bool, string>> GetItemsAsync(CaseInsensitiveString Node, string From, int MaxCount)
        {
            PubSubNode PubSubNode = await XmppServerModule.PubSub.GetNodeAsync(CaseInsensitiveString.Empty, Node, null, XmppAddress.Empty, null);
            if (PubSubNode is null || !PubSubNode.PublishOnWeb)
                return new Tuple<PubSubItem[], bool, string>(null, false, string.Empty);
 
            Tuple<PubSubItem[], bool, string> Result = await XmppServerModule.PubSub.LoadItems(string.Empty, Node, From, MaxCount)
                ?? throw new NotFoundException();
 
            foreach (PubSubItem Item in Result.Item1)
                await GetContent(Item);
 
            return Result;
        }
 
    }
}