BlockListResource.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Json;
using Waher.Content.Xml;
using Waher.Content.Xml.Text;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.HeaderFields;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Persistence.NeuroLedger;
using Waher.Persistence.NeuroLedger.Registry;
using Waher.Script;
using Waher.Security;
 
namespace Waher.Networking.XMPP.NeuroLedger.Web
{
    public class BlockListResource : HttpAsynchronousResource, IHttpGetMethod
    {
        private readonly XmppClient client;
        private readonly HttpServer webServer;
        private readonly string userVariable;
        private readonly string[] userPrivileges;
 
        public BlockListResource(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 AllowsGET => true;
 
        public async Task GET(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 block list not granted."));
                return;
            }
 
            HttpFieldAccept Accept = Request.Header.Accept;
            string Alternative = Accept?.GetBestAlternative(XmlCodec.DefaultContentType,
                XmlCodec.SchemaContentType, JsonCodec.DefaultContentType, "text/x-json");
 
            if (Alternative is null)
            {
                await Response.SendResponse(new NotAcceptableException("List can be returned in XML or JSON formats only. Choose which one using the Accept header."));
                return;
            }
 
            string[] AllowedCollections = Item?.Groups;
            int MaxCount = int.MaxValue;
 
            if (!Request.Header.TryGetQueryParameter("Last", out string Last))
                Last = null;
 
            if (Request.Header.TryGetQueryParameter("Max", out s))
            {
                if (!int.TryParse(s, out i) || i <= 0)
                {
                    await Response.SendResponse(new BadRequestException("Invalid maximum number of references to return."));
                    return;
                }
 
                MaxCount = i;
            }
 
            if (Request.Header.TryGetQueryParameter("Collections", out s))
            {
                string[] RequestedCollections = s.Split(',');
 
                if (!(AllowedCollections is null))
                {
                    foreach (string Collection in RequestedCollections)
                    {
                        if (Array.IndexOf(AllowedCollections, Collection) < 0)
                        {
                            await Response.SendResponse(new ForbiddenException(Request, "Access to collection " + Collection + " denied."));
                            return;
                        }
                    }
                }
 
                AllowedCollections = RequestedCollections;
            }
 
            if (!(AllowedCollections is null) && AllowedCollections.Length == 0)
            {
                await Response.SendResponse(new ForbiddenException(Request, "Access to block list not granted."));
                return;
            }
 
            this.ProcessRequest(Response, Alternative, AllowedCollections, Last, MaxCount);
        }
 
        private async void ProcessRequest(HttpResponse Response, string Alternative, string[] AllowedCollections,
            string Last, int MaxCount)
        {
            try
            {
                IEnumerable<BlockReference> Blocks;
 
                if (AllowedCollections is null)
                {
                    if (string.IsNullOrEmpty(Last))
                        Blocks = await Database.Find<BlockReference>(0, MaxCount, "ObjectId");
                    else
                        Blocks = await Database.Find<BlockReference>(0, MaxCount, new FilterFieldGreaterThan("ObjectId", Last), "ObjectId");
                }
                else
                {
                    Dictionary<string, bool> Collections = new Dictionary<string, bool>();
 
                    foreach (string Collection in AllowedCollections)
                        Collections[Collection] = true;
 
                    FilterCustom<BlockReference> CollectionFilter = new FilterCustom<BlockReference>(
                        (Ref) => Collections.ContainsKey(Ref.Collection));
 
                    if (string.IsNullOrEmpty(Last))
                        Blocks = await Database.Find<BlockReference>(0, MaxCount, CollectionFilter, "ObjectId");
                    else
                    {
                        Blocks = await Database.Find<BlockReference>(0, MaxCount,
                            new FilterAnd(new FilterFieldGreaterThan("ObjectId", Last), CollectionFilter), "ObjectId");
                    }
                }
 
                StringBuilder sb = new StringBuilder();
 
                switch (Alternative)
                {
                    case XmlCodec.DefaultContentType:
                    case XmlCodec.SchemaContentType:
                        Response.StatusCode = 200;
                        Response.StatusMessage = "OK";
                        Response.ContentType = Alternative;
 
                        sb.Append("<blockReferences xmlns=\"");
                        sb.Append(NeuroLedgerClient.NeuroLedgerNamespace);
                        sb.Append("\">");
 
                        await Response.Write(sb.ToString());
 
                        foreach (BlockReference Ref in Blocks)
                        {
                            sb.Clear();
 
                            sb.Append("<ref id='");
                            sb.Append(Ref.ObjectId);
 
                            sb.Append("' d='");
                            sb.Append(Convert.ToBase64String(Ref.Digest));
                            sb.Append("' s='");
                            sb.Append(Convert.ToBase64String(Ref.Signature));
 
                            if (!(Ref.Link is null))
                            {
                                sb.Append("' l='");
                                sb.Append(Convert.ToBase64String(Ref.Link));
                            }
 
                            sb.Append("' cn='");
                            sb.Append(XML.Encode(Ref.Collection));
                            sb.Append("' cr='");
                            sb.Append(XML.Encode(Ref.Creator));
                            sb.Append("' ct='");
                            sb.Append(XML.Encode(Ref.Created));
 
                            if (Ref.Updated != DateTime.MinValue)
                            {
                                sb.Append("' u='");
                                sb.Append(XML.Encode(Ref.Updated));
                            }
 
                            if (Ref.Expires != DateTime.MaxValue)
                            {
                                sb.Append("' x='");
                                sb.Append(XML.Encode(Ref.Expires));
                            }
 
                            if (Ref.Status != BlockStatus.Valid)
                            {
                                sb.Append("' t='");
                                sb.Append(Ref.Status.ToString());
                            }
 
                            sb.Append("' r='");
                            sb.Append("httpx://");
                            sb.Append(this.client.BareJID);
                            sb.Append("/NL/B/");
                            sb.Append(Base64Url.Encode(Ref.Digest));
                            sb.Append("' b='");
                            sb.Append(Ref.Bytes.ToString());
                            sb.Append("'/>");
 
                            await Response.Write(sb.ToString());
                        }
 
                        await Response.Write("</blockReferences>");
                        await Response.SendResponse();
                        break;
 
                    case JsonCodec.DefaultContentType:
                    case "text/x-json":
                        Response.StatusCode = 200;
                        Response.StatusMessage = "OK";
                        Response.ContentType = Alternative;
 
                        List<KeyValuePair<string, object>> Properties = new List<KeyValuePair<string, object>>();
                        bool First = true;
 
                        await Response.Write("[");
 
                        foreach (BlockReference Ref in Blocks)
                        {
                            Properties.Clear();
                            Properties.Add(new KeyValuePair<string, object>("id", Ref.ObjectId));
                            Properties.Add(new KeyValuePair<string, object>("d", Convert.ToBase64String(Ref.Digest)));
                            Properties.Add(new KeyValuePair<string, object>("s", Convert.ToBase64String(Ref.Signature)));
                            Properties.Add(new KeyValuePair<string, object>("cn", Ref.Collection));
                            Properties.Add(new KeyValuePair<string, object>("cr", Ref.Creator));
                            Properties.Add(new KeyValuePair<string, object>("ct", Ref.Created));
                            Properties.Add(new KeyValuePair<string, object>("b", Ref.Bytes));
 
                            if (!(Ref.Link is null))
                                Properties.Add(new KeyValuePair<string, object>("l", Convert.ToBase64String(Ref.Link)));
 
                            if (Ref.Updated != DateTime.MinValue)
                                Properties.Add(new KeyValuePair<string, object>("u", Ref.Updated));
 
                            if (Ref.Expires != DateTime.MaxValue)
                                Properties.Add(new KeyValuePair<string, object>("x", Ref.Expires));
 
                            if (Ref.Status != BlockStatus.Valid)
                                Properties.Add(new KeyValuePair<string, object>("t", Ref.Status.ToString()));
 
                            sb.Clear();
 
                            sb.Append("httpx://");
                            sb.Append(this.client.BareJID);
                            sb.Append("/NL/B/");
                            sb.Append(Base64Url.Encode(Ref.Digest));
 
                            Properties.Add(new KeyValuePair<string, object>("r", sb.ToString()));
 
                            if (First)
                            {
                                First = false;
                                sb.Append(JSON.Encode(Properties.ToArray(), false));
                            }
                            else
                                sb.Append("," + JSON.Encode(Properties.ToArray(), false));
 
                            await Response.Write(sb.ToString());
                        }
 
                        await Response.Write(']');
                        await Response.SendResponse();
                        break;
 
                    default:
                        await Response.SendResponse(new NotAcceptableException("Desired format not acceptable. Use the Accept header field to select either text/xml or application/json."));
                        return;
                }
 
                await Response.SendResponse();
            }
            catch (Exception ex)
            {
                await Response.SendResponse(ex);
            }
        }
 
    }
}