ProgramDataFile.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Html.JavaScript;
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 ProgramDataFile : INode, IActuator
    {
        private ProgramDataFolder parent;
        private string fileName;
        private string fileLocalName;
        private DateTime? created;
        private DateTime? updated;
        private long? size;
 
        public ProgramDataFile()
            : this(string.Empty, null, null, null, null)
        {
        }
 
        public ProgramDataFile(string FileName, ProgramDataFolder Parent, DateTime? Created, DateTime? Updated, long? Size)
        {
            this.fileName = FileName;
            this.parent = Parent;
            this.created = Created;
            this.updated = Updated;
            this.size = Size;
 
            if (string.IsNullOrEmpty(this.fileName))
                this.fileLocalName = null;
            else
                this.fileLocalName = Path.GetFileName(this.fileName);
        }
 
        [Page(7, "File System", 100)]
        [Header(12, "File Name:")]
        [ToolTip(13, "Local file name.")]
        [Required]
        public string FileLocalName
        {
            get => this.fileLocalName;
            set
            {
                if (this.fileLocalName != value)
                {
                    if (this.parent is null)
                        throw new Exception("You are not allowed to change the file name.");
 
                    string FullPath = Path.Combine(this.parent.FolderName, value);
                    if (!FullPath.StartsWith(this.parent.FolderName, StringComparison.CurrentCultureIgnoreCase))
                        throw new Exception("Invalid local file name.");
 
                    if (!string.IsNullOrEmpty(this.fileName))
                    {
                        if (File.Exists(FullPath) || Directory.Exists(FullPath))
                            throw new Exception("File or folder already exists.");
 
                        File.Move(this.fileName, FullPath);
                    }
 
                    this.fileLocalName = value;
                    this.fileName = FullPath;
                }
            }
        }
 
        [Page(7, "File System", 100)]
        [Header(10, "Full Path:")]
        [ToolTip(15, "Full path to file.")]
        [ReadOnly]
        public string FileName => this.fileName;
 
        public string NodeId => this.fileName;
 
        public string SourceId => ProgramDataSource.SourceID;
 
        public string Partition => string.Empty;
 
        public string LocalId => Path.GetFileName(this.fileName);
 
        public string LogId => this.fileName;
 
        public Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ProgramDataSource), 4, "File");
        }
 
        public bool HasChildren => 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.fileName);
 
        public NodeState State => NodeState.None;
 
        public Task<IEnumerable<INode>> ChildNodes => Task.FromResult<IEnumerable<INode>>(null);
 
        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 FileUpdated()
        {
            this.created = null;
            this.updated = null;
            this.size = null;
        }
 
        public async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Parameters = new LinkedList<Parameter>();
 
            if (!this.size.HasValue)
            {
                try
                {
                    FileInfo FileInfo = new FileInfo(this.fileName);
                    this.size = FileInfo.Length;
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            if (this.created is null)
            {
                try
                {
                    this.created = File.GetCreationTimeUtc(this.fileName);
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            if (this.updated is null)
            {
                try
                {
                    this.updated = File.GetLastWriteTimeUtc(this.fileName);
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            if (this.size.HasValue)
            {
                Parameters.AddLast(new Int64Parameter("Bytes", await Language.GetStringAsync(typeof(ProgramDataSource), 14, "Bytes"),
                    this.size.Value));
            }
 
            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.fileName))
                this.parent = ParentFolder;
 
            return Task.FromResult(true);
        }
 
        public Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public Task AddAsync(INode Child)
        {
            throw new NotSupportedException();
        }
 
        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("File is protected against deletion.");
 
            if (File.Exists(this.fileName))
                File.Delete(this.fileName);
 
            return Task.CompletedTask;
        }
 
        public Task<IEnumerable<ICommand>> Commands
        {
            get
            {
                return this.IsTextFile
                    ? Task.FromResult<IEnumerable<ICommand>>(new ICommand[] { new EditTextCommand(this) })
                    : Task.FromResult<IEnumerable<ICommand>>(null);
            }
        }
 
        public bool IsTextFile
        {
            get
            {
                if (this.fileName.EndsWith(".config", StringComparison.CurrentCultureIgnoreCase))
                    return true;
 
                string FileExtension = Path.GetExtension(this.fileName);
 
                if (!InternetContent.TryGetContentType(FileExtension, out string ContentType))
                    return false;
 
                if (ContentType.StartsWith("text/", StringComparison.OrdinalIgnoreCase))
                    return true;
 
                switch (ContentType.ToLower())
                {
                    case JavaScriptCodec.DefaultContentType:
                    case XmlCodec.SchemaContentType:
                    case "application/json":
                    case "application/x-tex":
                    case "application/x-webscript":
                    case "application/x-turtle":
                    case "application/link-format":
                    case "application/sparql-query":
                        return true;
                }
 
                if (ContentType.StartsWith("application/", StringComparison.OrdinalIgnoreCase) &&
                    (ContentType.EndsWith("+xml", StringComparison.OrdinalIgnoreCase) ||
                    ContentType.EndsWith("+json", StringComparison.OrdinalIgnoreCase)))
                {
                    return true;
                }
 
                return false;
            }
        }
 
        public string ContentType
        {
            get
            {
                if (this.fileName.EndsWith(".config", StringComparison.CurrentCultureIgnoreCase))
                    return XmlCodec.DefaultContentType;
 
                string FileExtension = Path.GetExtension(this.fileName);
 
                if (InternetContent.TryGetContentType(FileExtension, out string ContentType))
                    return ContentType;
 
                return PlainTextCodec.DefaultContentType;
            }
        }
 
        public async Task<ControlParameter[]> GetControlParameters()
        {
            List<ControlParameter> Parameters = new List<ControlParameter>();
            FileAttributes Attributes = File.GetAttributes(this.FileName);
            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(18, "If file is read-only."),
                GetReadOnly, SetReadOnly));
 
            Parameters.Add(new BooleanControlParameter("Hidden", Page,
                await Namespace.GetStringAsync(19, "Hidden"),
                await Namespace.GetStringAsync(20, "If file is hidden."),
                GetHidden, SetHidden));
 
            Parameters.Add(new BooleanControlParameter("System", Page,
                await Namespace.GetStringAsync(21, "System"),
                await Namespace.GetStringAsync(22, "If file is a system file."),
                GetSystem, SetSystem));
 
            Parameters.Add(new BooleanControlParameter("Archive", Page,
                await Namespace.GetStringAsync(23, "Archive"),
                await Namespace.GetStringAsync(24, "If file 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 ProgramDataFile FileNode))
                return Task.FromResult<bool?>(null);
 
            FileAttributes Attr = File.GetAttributes(FileNode.FileName);
 
            return Task.FromResult<bool?>(Attr.HasFlag(Attribute));
        }
 
        private static Task SetAttribute(IThingReference Node, bool Value, FileAttributes Attribute)
        {
            if (!(Node is ProgramDataFile FileNode))
                throw new ArgumentException("Unexpected node type.", nameof(Node));
 
            FileAttributes Attr = File.GetAttributes(FileNode.FileName);
            FileAttributes Bak = Attr;
 
            if (Value)
                Attr |= Attribute;
            else
                Attr &= ~Attribute;
 
            if (Attr != Bak)
                File.SetAttributes(FileNode.FileName, Attr);
 
            return Task.CompletedTask;
        }
 
    }
}