CreateTextFileCommand.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Service.IoTBroker.Sources.ProgramData
{
    public class CreateTextFileCommand : ICommand
    {
        private readonly ProgramDataFolder folderNode;
        private readonly string contentType;
        private readonly string extension;
        private readonly int nameStringId;
        private readonly string nameDefault;
        private readonly string commandId;
        private readonly string sortKey;
 
        public CreateTextFileCommand(ProgramDataFolder FolderNode, string ContentType, string Extension, int NameStringId, string NameDefault, string CommandId,
            string SortKey)
        {
            this.folderNode = FolderNode;
            this.contentType = ContentType;
            this.extension = Extension;
            this.nameStringId = NameStringId;
            this.nameDefault = NameDefault;
            this.commandId = CommandId;
            this.sortKey = SortKey;
 
            this.FileLocalName = Extension;
            this.Content = Array.Empty<string>();
            this.Encoding = System.Text.Encoding.UTF8.BodyName;
        }
 
        [Page(7, "File System", 100)]
        [Header(12, "File Name:")]
        [ToolTip(13, "Local file name.")]
        [Required]
        public string FileLocalName { get; set; }
 
        [Page(7, "File System", 100)]
        [Header(30, "Text Content:")]
        [ToolTip(31, "Text content in file.")]
        [Required]
        [DynamicContentType(nameof(GetContentType))]
        public string[] Content { get; set; }
 
        [Page(7, "File System", 100)]
        [Header(32, "Text Encoding:")]
        [ToolTip(33, "Encoding used to store text in file.")]
        [Required]
        [DynamicOptions(nameof(GetEncodingOptions))]
        public string Encoding { get; set; }
 
        public OptionAttribute[] GetEncodingOptions()
        {
            List<OptionAttribute> Encodings = new List<OptionAttribute>();
 
            foreach (EncodingInfo Encoding in System.Text.Encoding.GetEncodings())
                Encodings.Add(new OptionAttribute(Encoding.Name));
 
            return Encodings.ToArray();
        }
 
        public ContentTypeAttribute GetContentType()
        {
            return new ContentTypeAttribute(this.contentType);
        }
 
        public string CommandID => this.commandId;
 
        public CommandType Type => CommandType.Parametrized;
 
        public string SortCategory => "Edit";
 
        public string SortKey => this.sortKey;
 
        public Task<string> GetNameAsync(Language Language) => Language.GetStringAsync(typeof(ProgramDataSource), this.nameStringId, this.nameDefault);
 
        public Task<string> GetConfirmationStringAsync(Language Language) => Task.FromResult(string.Empty);
 
        public Task<string> GetFailureStringAsync(Language Language) => Task.FromResult(string.Empty);
 
        public Task<string> GetSuccessStringAsync(Language Language) => Task.FromResult(string.Empty);
 
        public Task<bool> CanExecuteAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + ProgramDataSource.SourceID + "Command." + this.CommandID));
        }
 
        public async Task ExecuteCommandAsync()
        {
            Encoding Encoding = System.Text.Encoding.GetEncoding(this.Encoding)
                ?? throw new ArgumentException("Invalid encoding.", nameof(this.Encoding));
 
            string FullPath = Path.Combine(this.folderNode.FolderName, this.FileLocalName);
            if (!FullPath.StartsWith(this.folderNode.FolderName, StringComparison.CurrentCultureIgnoreCase))
                throw new Exception("Invalid local file name.");
 
            StringBuilder sb = new StringBuilder();
            bool First = true;
 
            foreach (string Row in this.Content)
            {
                if (First)
                    First = false;
                else
                    sb.AppendLine();
 
                sb.Append(Row);
            }
 
            string Text = sb.ToString();
            byte[] Bin = Encoding.GetBytes(Text);
            byte[] Bom = Encoding.GetPreamble();
            bool HasBom = EditTextCommand.HasBom(Bin, Bom);
 
            using FileStream fs = File.Create(FullPath);
 
            if (!HasBom)
                await fs.WriteAsync(Bom, 0, Bom.Length);
 
            await fs.WriteAsync(Bin, 0, Bin.Length);
            await fs.FlushAsync();
        }
 
        public Task StartQueryExecutionAsync(Query Query, Language Language) => this.ExecuteCommandAsync();
 
        public ICommand Copy()
        {
            return new CreateTextFileCommand(this.folderNode, this.contentType, this.extension, this.nameStringId, this.nameDefault,
                this.commandId, this.sortKey);
        }
    }
}