SynchronizeFolder.cs

using System.Threading.Tasks;
using Waher.Runtime.Language;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Things.Files.Commands
{
    internal class SynchronizeFolder : ICommand
    {
        private readonly FolderNode node;
 
        public SynchronizeFolder(FolderNode Node)
        {
            this.node = Node;
            this.SynchronizationOptions = Node.SynchronizationOptions;
            this.FileFilter = Node.FileFilter;
        }
 
        [Page(2, "File System", 100)]
        [Header(7, "Synchronization Mode:")]
        [ToolTip(8, "If, and how, files in the folder (or subfolders) will be synchronized.")]
        [Option(SynchronizationOptions.NoSynchronization, 9, "Do not synchronize files.")]
        [Option(SynchronizationOptions.TopLevelOnly, 10, "Synchronize top-level files only.")]
        [Option(SynchronizationOptions.IncludeSubfolders, 11, "Synchronize files in folder and subfolders.")]
        [Text(TextPosition.AfterField, 16, "You can add default script templates to be used for files found, by adding string-valued meta-data tags to the node, where the meta-data key names correspond to file extensions.")]
        public SynchronizationOptions SynchronizationOptions { get; set; }
 
        [Page(2, "File System", 100)]
        [Header(5, "File Filter:")]
        [ToolTip(6, "You can limit the files to be monitored using a file filter. If no filter is provided, all files within the scope will be monitored.")]
        public string FileFilter { get; set; }
 
        public string CommandID => nameof(SynchronizeFolder);
 
        public CommandType Type => CommandType.Query;
 
        public string SortCategory => "FileSystem";
 
        public string SortKey => "Synchronize";
 
        public Task<bool> CanExecuteAsync(RequestOrigin Caller)
        {
            return this.node.CanEditAsync(Caller);
        }
 
        public ICommand Copy()
        {
            return new SynchronizeFolder(this.node);
        }
 
        public Task ExecuteCommandAsync()
        {
            return Task.CompletedTask;
        }
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(FolderNode), 17, "Synchronize folder...");
        }
 
        public Task<string> GetSuccessStringAsync(Language Language)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<string> GetConfirmationStringAsync(Language Language)
        {
            return Task.FromResult(string.Empty);
        }
 
        public Task<string> GetFailureStringAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(FolderNode), 18, "Unable to start synchronization.");
        }
 
        public Task StartQueryExecutionAsync(Query Query, Language Language)
        {
            SynchronizationStatistics Statistics = new SynchronizationStatistics(this.node, Query);
            return this.node.SynchFolder(this.SynchronizationOptions, this.FileFilter, Statistics);
        }
    }
}