ReportsDataSource.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.SourceEvents;
 
namespace Waher.Reports
{
    public class ReportsDataSource : IDataSource
    {
        public const string SourceID = "Reports";
 
        private static readonly Dictionary<string, ReportNode> nodes = new Dictionary<string, ReportNode>();
        private static readonly List<ReportNode> roots = new List<ReportNode>();
        private static ReportsDataSource instance = null;
        private static DateTime lastChanged = DateTime.UtcNow;
 
        internal static ReportsDataSource Instance => instance;
 
        public ReportsDataSource()
        {
            if (instance is null)
                instance = this;
        }
 
        string IDataSource.SourceID => SourceID;
 
        public IEnumerable<IDataSource> ChildSources => null;
 
        public bool HasChildren => false;
 
        public DateTime LastChanged => lastChanged;
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ReportsDataSource), 1, "Reports");
        }
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + SourceID + ".View"));
        }
 
        public IEnumerable<INode> RootNodes
        {
            get
            {
                lock (roots)
                {
                    return roots.ToArray();
                }
            }
        }
 
        public static async Task<bool> RegisterRootNode(ReportNode ReportRoot)
        {
            if (!await RegisterReportNode(ReportRoot))
                return false;
 
            lock (roots)
            {
                roots.Add(ReportRoot);
            }
 
            return true;
        }
 
        public static async Task<bool> RegisterReportNode(ReportNode ReportNode)
        {
            lock (nodes)
            {
                if (nodes.ContainsKey(ReportNode.NodeId))
                    return false;
 
                nodes[ReportNode.NodeId] = ReportNode;
                lastChanged = DateTime.UtcNow;
            }
 
            await NewEvent(await NodeAdded.FromNode(ReportNode,
                await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty, false));
 
            if (ReportNode.HasChildren)
            {
                foreach (INode Child in await ReportNode.ChildNodes)
                {
                    if (Child is ReportNode ChildReport)
                        await RegisterReportNode(ChildReport);
                }
            }
 
            return true;
        }
 
        public event EventHandlerAsync<SourceEvent> OnEvent = null;
 
        internal static async Task NewEvent(SourceEvent Event)
        {
            await (instance?.OnEvent?.Raise(instance, Event) ?? Task.CompletedTask);
        }
 
        public Task<INode> GetNodeAsync(IThingReference NodeRef)
        {
            if (NodeRef.SourceId != SourceID || !string.IsNullOrEmpty(NodeRef.Partition))
                return Task.FromResult<INode>(null);
 
            if (nodes.TryGetValue(NodeRef.NodeId, out ReportNode Result))
                return Task.FromResult<INode>(Result);
            else
                return Task.FromResult<INode>(null);
        }
 
    }
}