MultiGetResource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Multipart;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.HeaderFields;
using Waher.Networking.HTTP.TransferEncodings;
using Waher.Script;
using Waher.Security;
 
namespace Waher.Networking.XMPP.NeuroLedger.Web
{
    public class MultiGetResource : HttpAsynchronousResource, IHttpPostMethod
    {
        private readonly XmppClient client;
        private readonly HttpServer webServer;
        private readonly string userVariable;
        private readonly string[] userPrivileges;
 
        public MultiGetResource(string ResourceName, XmppClient Client, HttpServer WebServer, string UserVariable,
            params string[] UserPrivileges)
            : base(ResourceName)
        {
            this.client = Client;
            this.webServer = WebServer;
            this.userVariable = UserVariable;
            this.userPrivileges = UserPrivileges;
        }
 
        public override bool HandlesSubPaths => false;
 
        public override bool UserSessions => false;
 
        public bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            string s = Request.RemoteEndPoint;
            int i = s.IndexOf('/');
            if (i > 0)
                s = s[..i];
 
            RosterItem Item = this.client[s];
            bool Forbidden = false;
 
            if (Item is null)
            {
                string HttpSessionID = GetSessionId(Request, Response);
 
                if (string.IsNullOrEmpty(HttpSessionID))
                    Forbidden = true;
                else
                {
                    Variables Session = this.webServer.GetSession(HttpSessionID, false);
                    if (Session is null ||
                        !Session.TryGetVariable(this.userVariable, out Variable v) ||
                        !(v.ValueObject is IUser User))
                    {
                        Forbidden = true;
                    }
                    else
                    {
                        foreach (string Privilege in this.userPrivileges)
                        {
                            if (!User.HasPrivilege(Privilege))
                            {
                                Forbidden = true;
                                break;
                            }
                        }
                    }
                }
            }
            else
            {
                if (Item.State != SubscriptionState.Both && Item.State != SubscriptionState.From)
                    Forbidden = true;
            }
 
            if (Forbidden)
            {
                await Response.SendResponse(new ForbiddenException(Request, "Access to resources not granted."));
                return;
            }
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException("No data."));
                return;
            }
 
            ContentResponse Data = await Request.DecodeDataAsync();
 
            if (Data.HasError)
            {
                await Response.SendResponse(Data.Error);
                return;
            }
 
            if (!(Data.Decoded is string[][] Records) || !this.HasColumns(Records, 2))
            {
                await Response.SendResponse(new UnsupportedMediaTypeException("Data must be encoded as text/csv, each record two columns, first=resource, second=Accept header."));
                return;
            }
 
            HttpFieldAccept Accept = Request.Header.Accept;
            if (!(Accept is null) && !Accept.IsAcceptable("multipart/mixed"))
            {
                await Response.SendResponse(new NotAcceptableException());
                return;
            }
 
            this.Process(Request, Response, Records);
        }
 
        private bool HasColumns(string[][] Records, int Nr)
        {
            foreach (string[] Record in Records)
            {
                if (Record.Length != Nr)
                    return false;
            }
 
            return true;
        }
 
        private async void Process(HttpRequest Request, HttpResponse Response, string[][] Records)
        {
            try
            {
                Uri OrgUri = new Uri(Request.Header.GetURL(false, false));
                List<EmbeddedContent> Items = new List<EmbeddedContent>();
                StringBuilder Header = new StringBuilder();
                HttpRequestHeader H = Request.Header;
 
                foreach (string[] Record in Records)
                {
                    try
                    {
                        if (!Uri.TryCreate(OrgUri, Record[0], out Uri ItemUri))
                        {
                            await Response.SendResponse(new BadRequestException("Invalid URI: " + Record[0]));
                            return;
                        }
 
                        if (ItemUri.Scheme != OrgUri.Scheme || ItemUri.Authority != OrgUri.Authority)
                        {
                            await Response.SendResponse(new ForbiddenException(Request, "Cross-domain requests not permitted."));
                            return;
                        }
 
                        if (NetworkingModule.Stopping)
                        {
                            await Response.SendResponse(new ServiceUnavailableException("Service is shutting down. Please try again later.",
                                new KeyValuePair<string, string>("Retry-After", "300")));
                        }
 
                        string ResourcePath = ItemUri.LocalPath;
                        if (!this.webServer.TryGetResource(ref ResourcePath, out HttpResource Resource, out string SubPath) ||
                            !(Resource is IHttpGetMethod GetMethod))
                        {
                            await Response.SendResponse(new NotFoundException("Resource not found."));
                            return;
                        }
 
                        using MemoryStream ms = new MemoryStream();
                        StringBuilder sb = new StringBuilder();
                        HttpFieldReferer Referer = Request.Header.Referer;
                        HttpFieldHost Host = Request.Header.Host;
 
                        sb.Append("GET ");
                        sb.Append(ItemUri.PathAndQuery);
                        sb.AppendLine(" HTTP/1.1");
 
                        if (!(Host is null))
                        {
                            sb.Append("Host: ");
                            sb.AppendLine(Host.Value);
                        }
 
                        if (!(Referer is null))
                        {
                            sb.Append("Referer: ");
                            sb.AppendLine(Referer.Value);
                        }
 
                        sb.Append("Accept: ");
                        sb.AppendLine(Record[1]);
 
                        HttpRequest Request2 = new HttpRequest(this.webServer, new HttpRequestHeader(sb.ToString(),
                            this.webServer.VanityResources, ItemUri.Scheme), null, Request.RemoteEndPoint, Request.LocalEndPoint)
                        {
                            Session = Request.Session,
                            SubPath = SubPath,
                            Resource = Resource
                        };
 
                        InternalTransfer InternalTransfer = new InternalTransfer(ms);
                        HttpResponse Response2 = new HttpResponse(InternalTransfer, this.webServer, Request2);
 
                        this.webServer.RequestReceived(Request2, Request.RemoteEndPoint, Resource, SubPath);
                        await GetMethod.GET(Request2, Response2);
 
                        await InternalTransfer.WaitUntilSent(10000);
 
                        byte[] Bin = ms.ToArray();
 
                        Items.Add(new EmbeddedContent()
                        {
                            ContentType = Response2.ContentType,
                            Size = Bin.Length,
                            Raw = Encoding.ASCII.GetBytes(Convert.ToBase64String(Bin)),
                            TransferEncoding = "base64",
                            Description = Response2.StatusCode.ToString()
                        });
                    }
                    catch (HttpException ex)
                    {
                        byte[] Bin = Encoding.UTF8.GetBytes(ex.Message);
                        Items.Add(new EmbeddedContent()
                        {
                            ContentType = "text/plain; charset=utf-8",
                            Size = Bin.Length,
                            Raw = Encoding.ASCII.GetBytes(Convert.ToBase64String(Bin)),
                            TransferEncoding = "base64",
                            Description = ex.StatusCode.ToString()
                        });
                    }
                    catch (Exception ex)
                    {
                        byte[] Bin = Encoding.UTF8.GetBytes(ex.Message);
                        Items.Add(new EmbeddedContent()
                        {
                            ContentType = "text/plain; charset=utf-8",
                            Size = Bin.Length,
                            Raw = Encoding.ASCII.GetBytes(Convert.ToBase64String(Bin)),
                            TransferEncoding = "base64",
                            Description = "500"
                        });
                    }
                }
 
                await Response.Return(new MixedContent(Items.ToArray()));
            }
            catch (Exception ex)
            {
                await Response.SendResponse(ex);
            }
        }
 
    }
}