PreviewIdApplicationSource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Runtime.Threading;
using Waher.Script;
using Waher.Script.Model;
using Waher.Script.Objects.VectorSpaces;
using Waher.Script.Persistence.SQL;
using Waher.Script.Persistence.SQL.Enumerators;
using Waher.Script.Persistence.SQL.Sources;
 
namespace Waher.Service.IoTBroker.Legal.Identity.Previews
{
    public class PreviewIdApplicationSource : INamedDataSource
    {
        public const string SourceID = "PreviewIdApplications";
 
        private static readonly Dictionary<string, PreviewIdApplication> applications =
            new Dictionary<string, PreviewIdApplication>();
        private static DateTime loaded = DateTime.MinValue;
 
        public PreviewIdApplicationSource()
        {
        }
 
        public string CollectionName => SourceID;
 
        public string TypeName => string.Empty;
 
        public string Name => SourceID;
 
        public Grade Supports(string Name)
        {
            return Name == SourceID ? Grade.Perfect : Grade.NotAtAll;
        }
 
        public bool IsSource(string Name)
        {
            return Name == SourceID;
        }
 
        public Task<bool> IsLabel(string Label)
        {
            switch (Label)
            {
                case "Id":
                case "Provider":
                case "State":
                case "Account":
                case "Created":
                case "Updated":
                case "From":
                case "To":
                case "Properties":
                case "ClientKeyName":
                case "ServerSignature":
                case "ClientPubKey":
                case "ClientSignature":
                case "Attachments":
                case "NrPeerReviews":
                case "Version":
                    return Task.FromResult(true);
 
                default:
                    return Task.FromResult(false);
            }
        }
 
        public Task CreateIndex(string Name, string[] Fields) => throw InvalidOperation();
 
        public Task<bool> DropIndex(string Name) => throw InvalidOperation();
 
        public Task DropCollection() => throw InvalidOperation();
 
        private static InvalidOperationException InvalidOperation()
        {
            return new InvalidOperationException("The source is read-only.");
        }
 
        public Task<int?> Delete(bool Lazy, int Offset, int Top, ScriptNode Where, Variables Variables,
            KeyValuePair<VariableReference, bool>[] Order, ScriptNode Node)
        {
            throw InvalidOperation();
        }
 
        public Task Update(bool Lazy, IEnumerable<object> Objects) => throw InvalidOperation();
 
        public Task Insert(bool Lazy, object Object) => throw InvalidOperation();
 
        public async Task<bool> Process(IProcessor<object> Processor, int Offset, int Top, bool Generic,
            ScriptNode Where, Variables Variables, KeyValuePair<VariableReference, bool>[] Order,
            ScriptNode Node)
        {
            IResultSetEnumerator e = await this.Find(Offset, Top, Generic, Where, Variables, Order, Node);
 
            if (Processor.IsAsynchronous)
            {
                while (await e.MoveNextAsync())
                {
                    if (!await Processor.ProcessAsync(e.Current))
                        return false;
                }
 
                await Processor.FlushAsync();
            }
            else
            {
                while (await e.MoveNextAsync())
                {
                    if (!Processor.Process(e.Current))
                        return false;
                }
 
                Processor.Flush();
            }
 
            return true;
        }
 
        public async Task<IResultSetEnumerator> Find(int Offset, int Top, bool Generic,
            ScriptNode Where, Variables Variables, KeyValuePair<VariableReference, bool>[] Order,
            ScriptNode Node)
        {
            PreviewIdApplication[] Applications;
 
            using (Semaphore Lock = await Semaphores.BeginWrite(SourceID))
            {
                DateTime TP = DateTime.UtcNow;
                int i, c;
 
                if (TP.Subtract(loaded).TotalDays >= 1)
                {
                    applications.Clear();
 
                    string PreviewFolder = LegalComponent.GetPreviewFolder();
                    string[] PreviewApplications = Directory.GetFiles(PreviewFolder, "*.id",
                        SearchOption.TopDirectoryOnly);
                    
                    for (i = 0, c = PreviewApplications.Length; i < c; i++)
                    {
                        string FileName = PreviewApplications[i];
                        PreviewIdApplication Application = new PreviewIdApplication(FileName,
                            File.GetCreationTimeUtc(FileName),
                            File.GetLastAccessTimeUtc(FileName));
 
                        try
                        {
                            LegalIdentity Identity = await Application.Load();
                            if (!(Identity is null))
                                applications[FileName] = Application;
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                    }
                }
 
                i = 0;
                c = applications.Count;
 
                Applications = new PreviewIdApplication[c];
 
                foreach (PreviewIdApplication Application in applications.Values)
                    Applications[i++] = Application.Clone(Variables, Node);
 
                loaded = TP;
            }
 
            ObjectVector v = new ObjectVector(Applications);
 
            return await VectorSource.Find(v, Offset, Top, Generic, Where, Variables,
                Order, Node);
        }
 
        internal static async Task PreviewFileSaved(string FileName, LegalIdentity Identity)
        {
            PreviewIdApplication Application = new PreviewIdApplication(FileName,
                File.GetCreationTimeUtc(FileName),
                File.GetLastAccessTimeUtc(FileName),
                Identity);
 
            using Semaphore Lock = await Semaphores.BeginWrite(SourceID);
            
            applications[FileName] = Application;
        }
 
        internal static async Task PreviewFileDeleted(string FileName)
        {
            using Semaphore Lock = await Semaphores.BeginWrite(SourceID);
 
            applications.Remove(FileName);
        }
    }
}