GetFromVault.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Collections;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Storage
{
    public class GetFromVault : AgentPostResource
    {
        public GetFromVault()
            : base("Storage/GetFromVault",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(StoreInVault).Namespace + ".JSON.GetFromVault.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(StoreInVault).Namespace + ".XML.GetFromVault.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            string VaultId = (string)Parameters["PVaultId"]?.AssociatedObjectValue;
            bool Masked = (bool)(Parameters["PMasked"]?.AssociatedObjectValue ?? true);
            byte[] VaultIdBin;
 
            try
            {
                VaultIdBin = Convert.FromBase64String(VaultId);
            }
            catch (Exception)
            {
                throw new BadRequestException("Invalid Vault ID.");
            }
 
            VaultItem Item = await Database.FindFirstIgnoreRest<VaultItem>(
                new FilterFieldEqualTo("VaultId", VaultIdBin))
                ?? throw new NotFoundException("Vault item not found.");
 
            if (Item.Account != User.UserName)
                throw new ForbiddenException(Request, "Access to vault item denied.");
 
            await Response.Return(EncodeVaultItem(Item, Masked));
        }
 
        internal static NamedDictionary<string,object> EncodeVaultItem(VaultItem Item, bool Masked)
        {
            ChunkedList<NamedDictionary<string, object>> Tags = new ChunkedList<NamedDictionary<string, object>>();
 
            foreach (VaultTag Tag in Item.Tags)
            {
                Tags.Add(new NamedDictionary<string, object>("Tag", string.Empty)
                {
                    { "name", Tag.Name },
                    { "value", Masked ? (Tag.MaskedValue ?? Tag.Value) : Tag.Value }
                });
            }
 
            return new NamedDictionary<string, object>("VaultItem", AgentNamespace)
            {
                { "vaultId", Convert.ToBase64String(Item.VaultId) },
                { "type", Item.Type },
                { "clientId", Item.ClientId },
                { "created", Item.Created },
                { "updated", Item.Updated },
                { "Tags", Tags.ToArray() }
            };
        }
    }
}