ExecuteJob.cs

using System;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Jobs.NodeTypes;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.Queries;
 
namespace Waher.Jobs.Commands
{
    public class ExecuteJob : ICommand
    {
        private readonly Job node;
 
        public ExecuteJob(Job Node)
        {
            this.node = Node;
        }
 
        public string CommandID => nameof(ExecuteJob);
 
        public CommandType Type => CommandType.Query;
 
        public string SortCategory => "Execution";
 
        public string SortKey => nameof(ExecuteJob);
 
        [Page(16, "Job", 0)]
        [Header(17, "Report Detail:")]
        [ToolTip(18, "How much detail to include in job reports.")]
        [Option(JobReportDetail.Summary, 19, "Return summary information only.")]
        [Option(JobReportDetail.Details, 20, "Return detailed information.")]
        public JobReportDetail ReportDetail { get; set; } = JobReportDetail.Details;
 
        public Task<bool> CanExecuteAsync(RequestOrigin Caller)
        {
            return this.node.CanEditAsync(Caller);
        }
 
        public ICommand Copy()
        {
            return new ExecuteJob(this.node);
        }
 
        public Task ExecuteCommandAsync()
        {
            return Task.CompletedTask;
        }
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ExecuteJob), 13, "Execute Job once...");
        }
 
        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(ExecuteJob), 15, "Unable to start the execution of the job.");
        }
 
        public Task StartQueryExecutionAsync(Query Query, Language Language)
        {
            Task.Run(async () =>
            {
                try
                {
                    try
                    {
                        await this.node.ExecuteJob(Query, Language, this.ReportDetail);
                        await this.node.RemoveErrorAsync("ExecutionError");
                    }
                    catch (Exception ex)
                    {
                        await this.node.LogErrorAsync("ExecutionError", ex.Message);
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
 
            return Task.CompletedTask;
        }
    }
}