SparqlResultSetImageEncoder.cs

using System;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Images;
using Waher.Content.Semantic;
using Waher.Content.Text;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Markdown.GraphViz
{
    public class SparqlResultSetImageEncoder : IContentEncoder
    {
        public SparqlResultSetImageEncoder()
        {
        }
 
        public string[] ContentTypes => Array.Empty<string>();
 
        public string[] FileExtensions => Array.Empty<string>();
 
        public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes)
        {
            if (Object is SparqlResultSet &&
                (InternetContent.IsAccepted(ImageCodec.ContentTypeSvg, AcceptedContentTypes) ||
                InternetContent.IsAccepted(ImageCodec.ContentTypePng, AcceptedContentTypes) ||
                InternetContent.IsAccepted(GraphVizCodec.DefaultContentType, AcceptedContentTypes)))
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public async Task<ContentResponse> EncodeAsync(object Object, Encoding Encoding, ICodecProgress Progress, params string[] AcceptedContentTypes)
        {
            if (!(Object is SparqlResultSet Result))
                return new ContentResponse(new ArgumentException("Unable to encode object.", nameof(Object)));
 
            if ((Result.Variables?.Length ?? 0) != 3)
                return new ContentResponse(new ArgumentException("Graphs can only be generated for semantic-triple result sets.", nameof(Object)));
 
            InMemorySemanticCube Cube = new InMemorySemanticCube();
            string SubjectVariable = Result.Variables[0];
            string PredicateVariable = Result.Variables[1];
            string ObjectVariable = Result.Variables[2];
 
            foreach (ISparqlResultRecord Record in Result.Records)
            {
                ISemanticElement Subject = Record[SubjectVariable];
                ISemanticElement Predicate = Record[PredicateVariable];
                ISemanticElement Object2 = Record[ObjectVariable];
 
                if (Subject is null || Predicate is null || Object2 is null)
                    return new ContentResponse(new ArgumentException("Graphs can only be generated for semantic-triple result sets.", nameof(Object)));
 
                Cube.Add(Subject, Predicate, Object2);
            }
 
            string Graph = GraphVizUtilities.GenerateGraph(Cube, string.Empty);
            string ContentType;
            byte[] Bin;
 
            if (InternetContent.IsAccepted(ImageCodec.ContentTypeSvg, AcceptedContentTypes))
            {
                Bin = await GraphVizUtilities.DotToImage(Graph, ResultType.Svg);
                ContentType = ImageCodec.ContentTypeSvg;
            }
            else if (InternetContent.IsAccepted(ImageCodec.ContentTypePng, AcceptedContentTypes))
            {
                Bin = await GraphVizUtilities.DotToImage(Graph, ResultType.Png);
                ContentType = ImageCodec.ContentTypePng;
            }
            else if (InternetContent.IsAccepted(GraphVizCodec.DefaultContentType, AcceptedContentTypes))
            {
                if (Encoding is null)
                {
                    ContentType = GraphVizCodec.DefaultContentType + "; charset=utf-8";
                    Encoding = Encoding.UTF8;
                }
                else
                    ContentType = GraphVizCodec.DefaultContentType + "; charset=" + Encoding.WebName;
 
                Bin = Encoding.GetBytes(Graph);
            }
            else
                return new ContentResponse(new ArgumentException("Requestd Content-Type not acceptable.", nameof(AcceptedContentTypes)));
 
            return new ContentResponse(ContentType, Object, Bin);
        }
 
        public bool TryGetContentType(string FileExtension, out string ContentType)
        {
            ContentType = null;
            return false;
        }
 
        public bool TryGetFileExtension(string ContentType, out string FileExtension)
        {
            FileExtension = null;
            return false;
        }
    }
}