SearchInVault.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 SearchInVault : AgentPostResource
    {
        public SearchInVault()
            : base("Storage/SearchInVault",
                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.SearchInVault.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(StoreInVault).Namespace + ".XML.SearchInVault.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;
            bool Masked = (bool)(Parameters["PMasked"]?.AssociatedObjectValue ?? true);
            int Offset = (int)(double)(Parameters["POffset"]?.AssociatedObjectValue ?? 0.0);
            int MaxCount = (int)(double)(Parameters["PMaxCount"]?.AssociatedObjectValue ?? 100.0);
            object[] TagNames = Parameters.ContainsKey("PTagName") ? (object[])Parameters["PTagName"].AssociatedObjectValue : Array.Empty<object>();
            object[] TagValues = Parameters.ContainsKey("PTagValue") ? (object[])Parameters["PTagValue"].AssociatedObjectValue : Array.Empty<object>();
            ChunkedList<KeyValuePair<string, string>> Tags = new ChunkedList<KeyValuePair<string, string>>();
 
            int i, c = TagNames?.Length ?? 0;
            if ((TagValues?.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.");
 
                Tags.Add(new KeyValuePair<string, string>(TagName, TagValue));
            }
 
            ChunkedList<Filter> Filters = new ChunkedList<Filter>()
            {
                new FilterFieldEqualTo("Account", User.UserName)
            };
 
            if (!(Type is null))
                Filters.Add(new FilterFieldEqualTo("Type", Type));
 
            if (!(ClientId is null))
                Filters.Add(new FilterFieldEqualTo("ClientId", ClientId));
 
            if (c > 0)
            {
                KeyValuePair<string, string>[] TagsFilter = Tags.ToArray();
 
                Filters.Add(new FilterCustom<VaultItem>((Item) =>
                {
                    foreach (KeyValuePair<string, string> P in Tags)
                    {
                        bool Found = false;
                        bool Pass = false;
 
                        foreach (VaultTag Tag in Item.Tags)
                        {
                            if (Tag.Name == P.Key)
                            {
                                Found = true;
                                if (P.Value == Tag.Value || P.Value == Tag.MaskedValue)
                                    Pass = true;
                            }
                        }
 
                        if (!Found || !Pass)
                            return false;
                    }
 
                    return true;
                }));
            }
 
            IEnumerable<VaultItem> Items;
 
            if (Filters.Count == 1)
                Items = await Database.Find<VaultItem>(Offset, MaxCount, Filters[0]);
            else
                Items = await Database.Find<VaultItem>(Offset, MaxCount, new FilterAnd(Filters.ToArray()));
 
            ChunkedList<NamedDictionary<string, object>> Result = new ChunkedList<NamedDictionary<string, object>>();
 
            foreach (VaultItem Item in Items)
                Result.Add(GetFromVault.EncodeVaultItem(Item, Masked));
 
            await Response.Return(new NamedDictionary<string, object>("VaultItems", AgentNamespace)
            {
                { "ResultSet", Result.ToArray() }
            });
        }
    }
}