MultiGetResource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
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.Substring(0, 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)
                throw new ForbiddenException("Access to resources not granted.");
 
            if (!Request.HasData)
                throw new BadRequestException("No data.");
 
            object Data = await Request.DecodeDataAsync();
 
            if (!(Data is string[][] Records) || !this.HasColumns(Records, 2))
                throw new UnsupportedMediaTypeException("Data must be encoded as text/csv, each record two columns, first=resource, second=Accept header.");
 
            HttpFieldAccept Accept = Request.Header.Accept;
            if (!(Accept is null) && !Accept.IsAcceptable("multipart/mixed"))
                throw new NotAcceptableException();
 
            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))
                            throw new BadRequestException("Invalid URI: " + Record[0]);
 
                        if (ItemUri.Scheme != OrgUri.Scheme || ItemUri.Authority != OrgUri.Authority)
                            throw new ForbiddenException("Cross-domain requests not permitted.");
 
                        if (NetworkingModule.Stopping)
                        {
                            throw new ServiceUnavailableException("Service is shutting down. Please try again later.",
                                new KeyValuePair<string, string>("Retry-After", "300"));
                        }
 
                        if (!this.webServer.TryGetResource(ItemUri.LocalPath, out HttpResource Resource, out string SubPath) ||
                            !(Resource is IHttpGetMethod GetMethod))
                        {
                            throw new NotFoundException("Resource not found.");
                        }
 
                        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);
            }
        }
 
    }
}