StoreInVault.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
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 StoreInVault : AgentPostResource
    {
        public StoreInVault()
            : base("Storage/StoreInVault",
                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.StoreInVault.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(StoreInVault).Namespace + ".XML.StoreInVault.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            string Type = (string)Parameters["PType"].AssociatedObjectValue;
            string ClientId = (string)Parameters["PClientId"]?.AssociatedObjectValue;
            string VaultId = (string)Parameters["PVaultId"]?.AssociatedObjectValue;
            object[] TagNames = (object[])Parameters["PTagName"].AssociatedObjectValue;
            object[] TagValues = (object[])Parameters["PTagValue"].AssociatedObjectValue;
            object[] TagMaskedValues = (object[])Parameters["PTagMaskedValue"].AssociatedObjectValue;
            ChunkedList<VaultTag> Tags = new ChunkedList<VaultTag>();
 
            int i, c = TagNames?.Length ?? 0;
            if ((TagValues?.Length ?? 0) != c || (TagMaskedValues?.Length ?? 0) != c)
                throw new BadRequestException("Invalid Tags.");
 
            for (i = 0; i < c; i++)
            {
                if (!(TagNames[i] is string TagName) || string.IsNullOrEmpty(TagName))
                    throw new BadRequestException("Invalid Tag Name.");
 
                if (!(TagValues[i] is string TagValue))
                    throw new BadRequestException("Invalid Tag Value.");
 
                if (!(TagMaskedValues[i] is string TagMaskedValue))
                {
                    if (TagMaskedValues[i] is null)
                        TagMaskedValue = null;
                    else
                        throw new BadRequestException("Invalid Tag Masked Value.");
                }
 
                VaultTag Tag = new VaultTag(TagName, TagValue, TagMaskedValue);
                Tags.Add(Tag);
            }
 
            VaultItem Item;
 
            if (string.IsNullOrEmpty(VaultId))
            {
                Item = null;
 
                while (Item is null)
                {
                    Item = new VaultItem()
                    {
                        Account = User.UserName,
                        Type = Type,
                        ClientId = ClientId ?? string.Empty,
                        VaultId = Gateway.NextBytes(32),
                        Tags = Tags.ToArray(),
                        Created = DateTime.UtcNow
                    };
 
                    Item.Updated = Item.Created;
 
                    if (!(await Database.FindFirstIgnoreRest<VaultItem>(
                        new FilterFieldEqualTo("VaultId", Item.VaultId)) is null))
                    {
                        Item = null;
                    }
                }
 
                await Database.Insert(Item);
            }
            else
            {
                byte[] VaultIdBin;
 
                try
                {
                    VaultIdBin = Convert.FromBase64String(VaultId);
                }
                catch(Exception)
                {
                    throw new BadRequestException("Invalid Vault ID.");
                }
 
                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.");
 
                if (Item.Type != Type)
                    throw new BadRequestException("Vault item not associated with type.");
 
                if (Item.ClientId != (ClientId ?? string.Empty))
                {
                    if (string.IsNullOrEmpty(ClientId))
                        throw new BadRequestException("Vault item associated with a client.");
                    else
                        throw new BadRequestException("Vault item not not associated with client.");
                }
 
                Item.Updated = DateTime.UtcNow;
                Item.Tags = Tags.ToArray();
 
                await Database.Update(Item);
            }
 
            await Response.Return(new NamedDictionary<string, object>("Stored", AgentNamespace)
            {
                { "created", Item.Created },
                { "updated", Item.Updated },
                { "vaultId", Convert.ToBase64String(Item.VaultId) }
            });
        }
    }
}