InternetContentSource.cs

using System;
using System.Collections.Generic;
using System.Runtime.ExceptionServices;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Semantic;
using Waher.Content.Text;
using Waher.Content.Xml;
using Waher.Runtime.Inventory;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Things;
 
namespace Waher.Script.Persistence.SPARQL.Sources
{
    public class InternetContentSource : IGraphSource
    {
        public InternetContentSource()
        {
        }
 
        public Grade Supports(Uri Source)
        {
            if (!Source.IsAbsoluteUri || 
                LocalContentSource.IsLocal(Source) ||
                !InternetContent.CanGet(Source, out Grade _, out _))
            {
                return Grade.NotAtAll;
            }
            else
                return Grade.Barely;
        }
 
        public async Task<ISemanticCube> LoadGraph(Uri Source, ScriptNode Node, bool NullIfNotFound,
            RequestOrigin Caller)
        {
            object Result = null;
            string XmlString = null;
 
            try
            {
                // TODO: Include caller credentials in request, if available.
 
                if (!Types.TryGetModuleParameter("X509", out X509Certificate Certificate))
                    Certificate = null;
 
                ContentResponse Content = await InternetContent.GetAsync(Source, Certificate,
                    new KeyValuePair<string, string>("Accept", "text/turtle, application/x-turtle, application/rdf+xml;q=0.9, application/ld+json;q=0.8, text/xml;q=0.2, " + PlainTextCodec.DefaultContentType + ";q=0.1"));
 
                if (NullIfNotFound && Content.HasError)
                    return null;
                else
                    Content.AssertOk();
 
                Result = Content.Decoded;
                if (Result is ISemanticCube Cube)
                    return Cube;
 
                if (Result is ISemanticModel Model)
                    return await InMemorySemanticCube.Create(Model);
 
                if (Result is XmlDocument Xml)
                    return new RdfDocument(Xml);
 
                if (Result is string s)
                {
                    if (XML.IsValidXml(s))
                    {
                        Xml = XML.ParseXml(XmlString = s, true);
                        return new RdfDocument(Xml);
                    }
                    else
                        return new TurtleDocument(s);
                }
 
            }
            catch (XmlException ex)
            {
                if (NullIfNotFound)
                    return null;
                else
                    throw XML.AnnotateException(ex, XmlString);
            }
            catch (Exception ex)
            {
                if (NullIfNotFound)
                    return null;
                else
                    ExceptionDispatchInfo.Capture(ex).Throw();
            }
 
            if (NullIfNotFound)
                return null;
            else
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append("Graph not a semantic cube or semantic model: ");
                sb.Append(Source.ToString());
                sb.Append(" Type of content returned: ");
                sb.Append(Result?.GetType().FullName);
 
                throw new ScriptRuntimeException(sb.ToString(), Node);
            }
        }
    }
}