ContractSchemasGetter.cs

using System;
using System.Collections.Generic;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml.Text;
using Waher.Content.Xsl;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Runtime.Temporary;
 
namespace Waher.Networking.XMPP.Contracts
{
    public class ContractSchemasGetter : IContentGetter, IContentHeader
    {
        public ContractSchemasGetter()
        {
        }
 
        public string[] UriSchemes => new string[] { "urn" };
 
        public bool CanGet(Uri Uri, out Grade Grade)
        {
            if (string.IsNullOrEmpty(UriToResource(Uri)))
            {
                Grade = Grade.NotAtAll;
                return false;
            }
            else
            {
                Grade = Grade.Excellent;
                return true;
            }
        }
 
        private static string UriToResource(Uri Uri)
        {
            string SchemaName;
 
            switch (Uri.OriginalString)
            {
                case "urn:nf:iot:e2e:1.0":
                    SchemaName = "E2E.xsd";
                    break;
 
                case "urn:nf:iot:leg:id:1.0":
                    SchemaName = "LegalIdentities.xsd";
                    break;
 
                case "urn:nf:iot:p2p:1.0":
                    SchemaName = "P2P.xsd";
                    break;
 
                case "urn:nf:iot:leg:sc:1.0":
                    SchemaName = "SmartContracts.xsd";
                    break;
 
                default:
                    return null;
            }
 
            return typeof(ContractsClient).Namespace + ".Schema." + SchemaName;
        }
 
        public Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            params KeyValuePair<string, string>[] Headers)
        {
            string SchemaName = UriToResource(Uri);
            if (string.IsNullOrEmpty(SchemaName))
                return Task.FromResult(new ContentResponse(new Exception("URI not recognized.")));
 
            return Task.FromResult(new ContentResponse(XmlCodec.SchemaContentType, XSL.LoadSchema(SchemaName), Array.Empty<byte>()));
        }
 
        public Task<ContentResponse> GetAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, TemporaryStream Destination, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, InternetContent.DefaultTimeout, Destination, Headers);
        }
 
        public Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, null, Headers);
        }
 
        public async Task<ContentStreamResponse> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator, int TimeoutMs, TemporaryStream Destination,
            params KeyValuePair<string, string>[] Headers)
        {
            string SchemaName = UriToResource(Uri);
            if (string.IsNullOrEmpty(SchemaName))
                return new ContentStreamResponse(new Exception("URI not recognized."));
 
            byte[] Bin = Resources.LoadResource(SchemaName);
 
            Destination ??= new TemporaryStream();
            await Destination.WriteAsync(Bin, 0, Bin.Length);
 
            return new ContentStreamResponse(XmlCodec.DefaultContentType, Destination);
        }
 
        public bool CanHead(Uri Uri, out Grade Grade)
        {
            Grade = Grade.NotAtAll;
            return false;
        }
 
        public Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, Headers);
        }
 
        public Task<ContentResponse> HeadAsync(Uri Uri, X509Certificate Certificate, EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator,
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
        }
    }
}