ProgramDataFolder.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.Content.Html;
using Waher.Content.Html.Css;
using Waher.Content.Html.JavaScript;
using Waher.Content.Markdown;
using Waher.Content.Text;
using Waher.Content.Xml.Text;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.ControlParameters;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.ProgramData
{
    public class ProgramDataFolder : INode, IActuator
    {
        private ProgramDataFolder parent;
        private DirectoryInfo dirInfo;
        private string folderName;
        private string folderLocalName;
        private DateTime? created;
        private DateTime? updated;
 
        public ProgramDataFolder()
            : this(string.Empty, null, null, null)
        {
        }
 
        public ProgramDataFolder(string FolderName, ProgramDataFolder Parent, DateTime? Created, DateTime? Updated)
        {
            this.folderName = FolderName;
            this.parent = Parent;
            this.created = Created;
            this.updated = Updated;
 
            if (string.IsNullOrEmpty(this.folderName))
            {
                this.dirInfo = null;
                this.folderLocalName = null;
            }
            else
            {
                this.dirInfo = new DirectoryInfo(this.folderName);
                this.folderLocalName = Path.GetFileName(this.folderName);
            }
        }
 
        [Page(7, "File System", 100)]
        [Header(8, "Folder:")]
        [ToolTip(9, "Local path to folder.")]
        [Required]
        public string FolderLocalName
        {
            get => this.folderLocalName;
            set
            {
                if (this.folderLocalName != value)
                {
                    if (this.parent is null)
                        throw new Exception("You are not allowed to change the folder name.");
 
                    string FullPath = Path.Combine(this.parent.folderName, value);
                    if (!FullPath.StartsWith(this.parent.FolderName, StringComparison.CurrentCultureIgnoreCase))
                        throw new Exception("Invalid local folder name.");
 
                    if (!string.IsNullOrEmpty(this.folderName))
                    {
                        if (Directory.Exists(FullPath) || File.Exists(FullPath))
                            throw new Exception("Folder or file already exists.");
 
                        Directory.Move(this.folderName, FullPath);
                    }
 
                    this.folderLocalName = value;
                    this.folderName = FullPath;
                    this.dirInfo = new DirectoryInfo(FullPath);
                }
            }
        }
 
        [Page(7, "File System", 100)]
        [Header(10, "Full Path:")]
        [ToolTip(11, "Full path to folder.")]
        [ReadOnly]
        public string FolderName => this.folderName;
 
        public string NodeId => this.folderName;
 
        public string SourceId => ProgramDataSource.SourceID;
 
        public string Partition => string.Empty;
 
        public string LocalId => this.folderLocalName;
 
        public string LogId => this.folderName;
 
        public Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ProgramDataSource), 2, "Folder");
        }
 
        public bool HasChildren
        {
            get
            {
                if (this.dirInfo is null || !this.dirInfo.Exists)
                    return false;
 
                DirectoryInfo[] Directories = this.dirInfo.GetDirectories();
                if (Directories.Length > 0)
                    return true;
 
                FileInfo[] Files = this.dirInfo.GetFiles();
                if (Files.Length > 0)
                    return true;
 
                return false;
            }
        }
 
        public bool ChildrenOrdered => false;
 
        public bool IsReadable => false;    // TODO
 
        public bool IsControllable => true;
 
        public bool HasCommands => true;
 
        public INode Parent => this.parent;
 
        public DateTime LastChanged => File.GetLastWriteTimeUtc(this.folderName);
 
        public NodeState State => NodeState.None;
 
        public Task<IEnumerable<INode>> ChildNodes => Task.FromResult(ProgramDataSource.GetChildNodes(this, this.folderName));
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + ProgramDataSource.SourceID + ".Node.View"));
        }
 
        public Task<bool> CanEditAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + ProgramDataSource.SourceID + ".Node.Edit"));
        }
 
        public Task<bool> CanAddAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + ProgramDataSource.SourceID + ".Node.Add"));
        }
 
        public Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            if (this.parent is null)
                return Task.FromResult(false);
            else
                return Task.FromResult(Caller.HasPrivilege("Source." + ProgramDataSource.SourceID + ".Node.Destroy"));
        }
 
        internal void FolderUpdated()
        {
            this.created = null;
            this.updated = null;
        }
 
        public async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Parameters = new LinkedList<Parameter>();
 
            if (this.created is null)
            {
                try
                {
                    this.created = Directory.GetCreationTimeUtc(this.folderName);
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            if (this.updated is null)
            {
                try
                {
                    this.updated = Directory.GetLastWriteTimeUtc(this.folderName);
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            if (this.created.HasValue)
            {
                Parameters.AddLast(new DateTimeParameter("Created", await Language.GetStringAsync(typeof(ProgramDataSource), 5, "Created"),
                    this.created.Value));
 
                if (this.updated.HasValue && this.updated.Value > this.created.Value)
                {
                    Parameters.AddLast(new DateTimeParameter("Updated", await Language.GetStringAsync(typeof(ProgramDataSource), 6, "Updated"),
                        this.updated.Value));
                }
            }
 
            return Parameters;
        }
 
        public Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Message>>(null);
        }
 
        public Task<bool> MoveUpAsync(RequestOrigin Caller) => Task.FromResult(false);
 
        public Task<bool> MoveDownAsync(RequestOrigin Caller) => Task.FromResult(false);
 
        public Task<bool> AcceptsParentAsync(INode Parent)
        {
            if (Parent is null)
                return Task.FromResult(true);
 
            if (!(Parent is ProgramDataFolder ParentFolder))
                return Task.FromResult(false);
 
            if (this.parent is null && string.IsNullOrEmpty(this.folderName))
                this.parent = ParentFolder;
 
            return Task.FromResult(true);
        }
 
        public Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(
                Child is ProgramDataFolder || 
                Child is ProgramDataFile);
        }
 
        public Task AddAsync(INode Child)
        {
            if (Child is ProgramDataFolder ChildFolder)
            {
                if (string.IsNullOrEmpty(ChildFolder.FolderName))
                    throw new Exception("Folder name is empty.");
 
                if (!ChildFolder.FolderName.StartsWith(this.folderName))
                    throw new Exception("Invalid parent folder.");
 
                if (!Directory.Exists(ChildFolder.FolderName))
                    Directory.CreateDirectory(ChildFolder.FolderName);
            }
            else if (Child is ProgramDataFile ChildFile)
            {
                if (string.IsNullOrEmpty(ChildFile.FileName))
                    throw new Exception("File name is empty.");
 
                if (!ChildFile.FileName.StartsWith(this.folderName))
                    throw new Exception("Invalid parent folder.");
 
                if (!File.Exists(ChildFile.FileName))
                {
                    FileStream fs = File.Create(ChildFile.FileName);
                    fs.Dispose();
                }
            }
            else
                throw new Exception("Unable to add child node.");
 
            return Task.CompletedTask;
        }
 
        public Task UpdateAsync() => Task.CompletedTask;
 
        public Task<bool> RemoveAsync(INode Child) => Task.FromResult(true);
 
        public Task DestroyAsync()
        {
            if (this.parent is null)
                throw new UnauthorizedAccessException("Folder is protected against deletion.");
 
            if (Directory.Exists(this.folderName))
                Directory.Delete(this.folderName, true);
 
            return Task.CompletedTask;
        }
 
        public Task<IEnumerable<ICommand>> Commands
        {
            get
            {
                return Task.FromResult<IEnumerable<ICommand>>(new ICommand[]
                {
                    new CreateFolderCommand(this, "0"),
                    new CreateTextFileCommand(this, PlainTextCodec.DefaultContentType, ".txt", 34, "Create Text File...", "CreateTextFile", "1"),
                    new CreateTextFileCommand(this, MarkdownCodec.ContentType, ".md", 40, "Create Markdown File...", "CreateMarkdownFile", "2"),
                    new CreateTextFileCommand(this, XmlCodec.DefaultContentType, ".xml", 35, "Create XML File...", "CreateXmlFile", "3"),
                    new CreateTextFileCommand(this, HtmlCodec.DefaultContentType, ".html", 36, "Create HTML File...", "CreateHtmlFile", "4"),
                    new CreateTextFileCommand(this, CssCodec.DefaultContentType, ".css", 37, "Create CSS File...", "CreateCssFile", "5"),
                    new CreateTextFileCommand(this, "text/cssx", ".cssx", 41, "Create CSSX File...", "CreateCssxFile", "6"),
                    new CreateTextFileCommand(this, JavaScriptCodec.DefaultContentType, ".js", 38, "Create JavaScript File...", "CreateJsFile", "7"),
                    new CreateTextFileCommand(this, "application/x-webscript", ".ws", 39, "Create Webscript File...", "CreateWsFile", "8")
                });
            }
        }
 
        public async Task<ControlParameter[]> GetControlParameters()
        {
            List<ControlParameter> Parameters = new List<ControlParameter>();
            DirectoryInfo Info = new DirectoryInfo(this.FolderName);
            FileAttributes Attributes = Info.Attributes;
            Language Language = await Translator.GetDefaultLanguageAsync();
            Namespace Namespace = await Language.GetNamespaceAsync(typeof(ProgramDataSource).Namespace);
            string Page = await Namespace.GetStringAsync(16, "Attributes");
 
            Parameters.Add(new BooleanControlParameter("ReadOnly", Page,
                await Namespace.GetStringAsync(17, "Read-only"),
                await Namespace.GetStringAsync(25, "If folder is read-only."),
                GetReadOnly, SetReadOnly));
 
            Parameters.Add(new BooleanControlParameter("Hidden", Page,
                await Namespace.GetStringAsync(19, "Hidden"),
                await Namespace.GetStringAsync(26, "If folder is hidden."),
                GetHidden, SetHidden));
 
            Parameters.Add(new BooleanControlParameter("System", Page,
                await Namespace.GetStringAsync(21, "System"),
                await Namespace.GetStringAsync(27, "If folder is a system file."),
                GetSystem, SetSystem));
 
            Parameters.Add(new BooleanControlParameter("Archive", Page,
                await Namespace.GetStringAsync(23, "Archive"),
                await Namespace.GetStringAsync(28, "If folder is a candidate for backup or removal."),
                GetArchive, SetArchive));
 
            return Parameters.ToArray();
        }
 
        private static Task<bool?> GetReadOnly(IThingReference Node)
        {
            return GetAttribute(Node, FileAttributes.ReadOnly);
        }
 
        private static Task SetReadOnly(IThingReference Node, bool Value)
        {
            return SetAttribute(Node, Value, FileAttributes.ReadOnly);
        }
 
        private static Task<bool?> GetHidden(IThingReference Node)
        {
            return GetAttribute(Node, FileAttributes.Hidden);
        }
 
        private static Task SetHidden(IThingReference Node, bool Value)
        {
            return SetAttribute(Node, Value, FileAttributes.Hidden);
        }
 
        private static Task<bool?> GetSystem(IThingReference Node)
        {
            return GetAttribute(Node, FileAttributes.System);
        }
 
        private static Task SetSystem(IThingReference Node, bool Value)
        {
            return SetAttribute(Node, Value, FileAttributes.System);
        }
 
        private static Task<bool?> GetArchive(IThingReference Node)
        {
            return GetAttribute(Node, FileAttributes.Archive);
        }
 
        private static Task SetArchive(IThingReference Node, bool Value)
        {
            return SetAttribute(Node, Value, FileAttributes.Archive);
        }
 
        private static Task<bool?> GetAttribute(IThingReference Node, FileAttributes Attribute)
        {
            if (!(Node is ProgramDataFolder FolderNode))
                return Task.FromResult<bool?>(null);
 
            FileAttributes Attr = FolderNode.dirInfo.Attributes;
 
            return Task.FromResult<bool?>(Attr.HasFlag(Attribute));
        }
 
        private static Task SetAttribute(IThingReference Node, bool Value, FileAttributes Attribute)
        {
            if (!(Node is ProgramDataFolder FolderNode))
                throw new ArgumentException("Unexpected node type.", nameof(Node));
 
            FileAttributes Attr = FolderNode.dirInfo.Attributes;
            FileAttributes Bak = Attr;
 
            if (Value)
                Attr |= Attribute;
            else
                Attr &= ~Attribute;
 
            if (Attr != Bak)
                FolderNode.dirInfo.Attributes = Attr;
 
            return Task.CompletedTask;
        }
 
    }
}