Merge branch 'master' into master

1 files changed, 493 insertions, 494 deletions

diff --git a/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs b/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs
index 985f0a8f8..24f554981 100644
--- a/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs
@@ -16,663 +16,662 @@ using MediaBrowser.Common.Extensions;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
 
-namespace Emby.Server.Implementations.ScheduledTasks
+namespace Emby.Server.Implementations.ScheduledTasks;
+
+/// <summary>
+/// Class ScheduledTaskWorker.
+/// </summary>
+public class ScheduledTaskWorker : IScheduledTaskWorker
 {
+    private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+    private readonly IApplicationPaths _applicationPaths;
+    private readonly ILogger _logger;
+    private readonly ITaskManager _taskManager;
+    private readonly Lock _lastExecutionResultSyncLock = new();
+    private bool _readFromFile;
+    private TaskResult _lastExecutionResult;
+    private Task _currentTask;
+    private Tuple<TaskTriggerInfo, ITaskTrigger>[] _triggers;
+    private string _id;
+
     /// <summary>
-    /// Class ScheduledTaskWorker.
+    /// Initializes a new instance of the <see cref="ScheduledTaskWorker" /> class.
     /// </summary>
-    public class ScheduledTaskWorker : IScheduledTaskWorker
+    /// <param name="scheduledTask">The scheduled task.</param>
+    /// <param name="applicationPaths">The application paths.</param>
+    /// <param name="taskManager">The task manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <exception cref="ArgumentNullException">
+    /// scheduledTask
+    /// or
+    /// applicationPaths
+    /// or
+    /// taskManager
+    /// or
+    /// jsonSerializer
+    /// or
+    /// logger.
+    /// </exception>
+    public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, ILogger logger)
     {
-        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
-        private readonly IApplicationPaths _applicationPaths;
-        private readonly ILogger _logger;
-        private readonly ITaskManager _taskManager;
-        private readonly Lock _lastExecutionResultSyncLock = new();
-        private bool _readFromFile;
-        private TaskResult _lastExecutionResult;
-        private Task _currentTask;
-        private Tuple<TaskTriggerInfo, ITaskTrigger>[] _triggers;
-        private string _id;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ScheduledTaskWorker" /> class.
-        /// </summary>
-        /// <param name="scheduledTask">The scheduled task.</param>
-        /// <param name="applicationPaths">The application paths.</param>
-        /// <param name="taskManager">The task manager.</param>
-        /// <param name="logger">The logger.</param>
-        /// <exception cref="ArgumentNullException">
-        /// scheduledTask
-        /// or
-        /// applicationPaths
-        /// or
-        /// taskManager
-        /// or
-        /// jsonSerializer
-        /// or
-        /// logger.
-        /// </exception>
-        public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, ILogger logger)
-        {
-            ArgumentNullException.ThrowIfNull(scheduledTask);
-            ArgumentNullException.ThrowIfNull(applicationPaths);
-            ArgumentNullException.ThrowIfNull(taskManager);
-            ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(scheduledTask);
+        ArgumentNullException.ThrowIfNull(applicationPaths);
+        ArgumentNullException.ThrowIfNull(taskManager);
+        ArgumentNullException.ThrowIfNull(logger);
 
-            ScheduledTask = scheduledTask;
-            _applicationPaths = applicationPaths;
-            _taskManager = taskManager;
-            _logger = logger;
+        ScheduledTask = scheduledTask;
+        _applicationPaths = applicationPaths;
+        _taskManager = taskManager;
+        _logger = logger;
 
-            InitTriggerEvents();
-        }
+        InitTriggerEvents();
+    }
 
-        /// <inheritdoc />
-        public event EventHandler<GenericEventArgs<double>> TaskProgress;
+    /// <inheritdoc />
+    public event EventHandler<GenericEventArgs<double>> TaskProgress;
 
-        /// <inheritdoc />
-        public IScheduledTask ScheduledTask { get; private set; }
+    /// <inheritdoc />
+    public IScheduledTask ScheduledTask { get; private set; }
 
-        /// <inheritdoc />
-        public TaskResult LastExecutionResult
+    /// <inheritdoc />
+    public TaskResult LastExecutionResult
+    {
+        get
         {
-            get
-            {
-                var path = GetHistoryFilePath();
+            var path = GetHistoryFilePath();
 
-                lock (_lastExecutionResultSyncLock)
+            lock (_lastExecutionResultSyncLock)
+            {
+                if (_lastExecutionResult is null && !_readFromFile)
                 {
-                    if (_lastExecutionResult is null && !_readFromFile)
+                    if (File.Exists(path))
                     {
-                        if (File.Exists(path))
+                        var bytes = File.ReadAllBytes(path);
+                        if (bytes.Length > 0)
                         {
-                            var bytes = File.ReadAllBytes(path);
-                            if (bytes.Length > 0)
+                            try
                             {
-                                try
-                                {
-                                    _lastExecutionResult = JsonSerializer.Deserialize<TaskResult>(bytes, _jsonOptions);
-                                }
-                                catch (JsonException ex)
-                                {
-                                    _logger.LogError(ex, "Error deserializing {File}", path);
-                                }
+                                _lastExecutionResult = JsonSerializer.Deserialize<TaskResult>(bytes, _jsonOptions);
                             }
-                            else
+                            catch (JsonException ex)
                             {
-                                _logger.LogDebug("Scheduled Task history file {Path} is empty. Skipping deserialization.", path);
+                                _logger.LogError(ex, "Error deserializing {File}", path);
                             }
                         }
-
-                        _readFromFile = true;
+                        else
+                        {
+                            _logger.LogDebug("Scheduled Task history file {Path} is empty. Skipping deserialization.", path);
+                        }
                     }
-                }
 
-                return _lastExecutionResult;
+                    _readFromFile = true;
+                }
             }
 
-            private set
-            {
-                _lastExecutionResult = value;
+            return _lastExecutionResult;
+        }
 
-                var path = GetHistoryFilePath();
-                Directory.CreateDirectory(Path.GetDirectoryName(path));
+        private set
+        {
+            _lastExecutionResult = value;
 
-                lock (_lastExecutionResultSyncLock)
-                {
-                    using FileStream createStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
-                    using Utf8JsonWriter jsonStream = new Utf8JsonWriter(createStream);
-                    JsonSerializer.Serialize(jsonStream, value, _jsonOptions);
-                }
+            var path = GetHistoryFilePath();
+            Directory.CreateDirectory(Path.GetDirectoryName(path));
+
+            lock (_lastExecutionResultSyncLock)
+            {
+                using FileStream createStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
+                using Utf8JsonWriter jsonStream = new Utf8JsonWriter(createStream);
+                JsonSerializer.Serialize(jsonStream, value, _jsonOptions);
             }
         }
+    }
 
-        /// <inheritdoc />
-        public string Name => ScheduledTask.Name;
+    /// <inheritdoc />
+    public string Name => ScheduledTask.Name;
 
-        /// <inheritdoc />
-        public string Description => ScheduledTask.Description;
+    /// <inheritdoc />
+    public string Description => ScheduledTask.Description;
 
-        /// <inheritdoc />
-        public string Category => ScheduledTask.Category;
+    /// <inheritdoc />
+    public string Category => ScheduledTask.Category;
 
-        /// <summary>
-        /// Gets or sets the current cancellation token.
-        /// </summary>
-        /// <value>The current cancellation token source.</value>
-        private CancellationTokenSource CurrentCancellationTokenSource { get; set; }
+    /// <summary>
+    /// Gets or sets the current cancellation token.
+    /// </summary>
+    /// <value>The current cancellation token source.</value>
+    private CancellationTokenSource CurrentCancellationTokenSource { get; set; }
 
-        /// <summary>
-        /// Gets or sets the current execution start time.
-        /// </summary>
-        /// <value>The current execution start time.</value>
-        private DateTime CurrentExecutionStartTime { get; set; }
+    /// <summary>
+    /// Gets or sets the current execution start time.
+    /// </summary>
+    /// <value>The current execution start time.</value>
+    private DateTime CurrentExecutionStartTime { get; set; }
 
-        /// <inheritdoc />
-        public TaskState State
+    /// <inheritdoc />
+    public TaskState State
+    {
+        get
         {
-            get
+            if (CurrentCancellationTokenSource is not null)
             {
-                if (CurrentCancellationTokenSource is not null)
-                {
-                    return CurrentCancellationTokenSource.IsCancellationRequested
-                               ? TaskState.Cancelling
-                               : TaskState.Running;
-                }
-
-                return TaskState.Idle;
+                return CurrentCancellationTokenSource.IsCancellationRequested
+                            ? TaskState.Cancelling
+                            : TaskState.Running;
             }
+
+            return TaskState.Idle;
         }
+    }
 
-        /// <inheritdoc />
-        public double? CurrentProgress { get; private set; }
+    /// <inheritdoc />
+    public double? CurrentProgress { get; private set; }
 
-        /// <summary>
-        /// Gets or sets the triggers that define when the task will run.
-        /// </summary>
-        /// <value>The triggers.</value>
-        private Tuple<TaskTriggerInfo, ITaskTrigger>[] InternalTriggers
+    /// <summary>
+    /// Gets or sets the triggers that define when the task will run.
+    /// </summary>
+    /// <value>The triggers.</value>
+    private Tuple<TaskTriggerInfo, ITaskTrigger>[] InternalTriggers
+    {
+        get => _triggers;
+        set
         {
-            get => _triggers;
-            set
-            {
-                ArgumentNullException.ThrowIfNull(value);
+            ArgumentNullException.ThrowIfNull(value);
 
-                // Cleanup current triggers
-                if (_triggers is not null)
-                {
-                    DisposeTriggers();
-                }
+            // Cleanup current triggers
+            if (_triggers is not null)
+            {
+                DisposeTriggers();
+            }
 
-                _triggers = value.ToArray();
+            _triggers = value.ToArray();
 
-                ReloadTriggerEvents(false);
-            }
+            ReloadTriggerEvents(false);
         }
+    }
 
-        /// <inheritdoc />
-        public IReadOnlyList<TaskTriggerInfo> Triggers
+    /// <inheritdoc />
+    public IReadOnlyList<TaskTriggerInfo> Triggers
+    {
+        get
         {
-            get
-            {
-                return Array.ConvertAll(InternalTriggers, i => i.Item1);
-            }
+            return Array.ConvertAll(InternalTriggers, i => i.Item1);
+        }
 
-            set
-            {
-                ArgumentNullException.ThrowIfNull(value);
+        set
+        {
+            ArgumentNullException.ThrowIfNull(value);
 
-                // This null check is not great, but is needed to handle bad user input, or user mucking with the config file incorrectly
-                var triggerList = value.Where(i => i is not null).ToArray();
+            // This null check is not great, but is needed to handle bad user input, or user mucking with the config file incorrectly
+            var triggerList = value.Where(i => i is not null).ToArray();
 
-                SaveTriggers(triggerList);
+            SaveTriggers(triggerList);
 
-                InternalTriggers = Array.ConvertAll(triggerList, i => new Tuple<TaskTriggerInfo, ITaskTrigger>(i, GetTrigger(i)));
-            }
+            InternalTriggers = Array.ConvertAll(triggerList, i => new Tuple<TaskTriggerInfo, ITaskTrigger>(i, GetTrigger(i)));
         }
+    }
 
-        /// <inheritdoc />
-        public string Id
+    /// <inheritdoc />
+    public string Id
+    {
+        get
         {
-            get
-            {
-                return _id ??= ScheduledTask.GetType().FullName.GetMD5().ToString("N", CultureInfo.InvariantCulture);
-            }
+            return _id ??= ScheduledTask.GetType().FullName.GetMD5().ToString("N", CultureInfo.InvariantCulture);
         }
+    }
 
-        private void InitTriggerEvents()
-        {
-            _triggers = LoadTriggers();
-            ReloadTriggerEvents(true);
-        }
+    private void InitTriggerEvents()
+    {
+        _triggers = LoadTriggers();
+        ReloadTriggerEvents(true);
+    }
 
-        /// <inheritdoc />
-        public void ReloadTriggerEvents()
-        {
-            ReloadTriggerEvents(false);
-        }
+    /// <inheritdoc />
+    public void ReloadTriggerEvents()
+    {
+        ReloadTriggerEvents(false);
+    }
 
-        /// <summary>
-        /// Reloads the trigger events.
-        /// </summary>
-        /// <param name="isApplicationStartup">if set to <c>true</c> [is application startup].</param>
-        private void ReloadTriggerEvents(bool isApplicationStartup)
+    /// <summary>
+    /// Reloads the trigger events.
+    /// </summary>
+    /// <param name="isApplicationStartup">if set to <c>true</c> [is application startup].</param>
+    private void ReloadTriggerEvents(bool isApplicationStartup)
+    {
+        foreach (var triggerInfo in InternalTriggers)
         {
-            foreach (var triggerInfo in InternalTriggers)
-            {
-                var trigger = triggerInfo.Item2;
+            var trigger = triggerInfo.Item2;
 
-                trigger.Stop();
+            trigger.Stop();
 
-                trigger.Triggered -= OnTriggerTriggered;
-                trigger.Triggered += OnTriggerTriggered;
-                trigger.Start(LastExecutionResult, _logger, Name, isApplicationStartup);
-            }
+            trigger.Triggered -= OnTriggerTriggered;
+            trigger.Triggered += OnTriggerTriggered;
+            trigger.Start(LastExecutionResult, _logger, Name, isApplicationStartup);
         }
+    }
 
-        /// <summary>
-        /// Handles the Triggered event of the trigger control.
-        /// </summary>
-        /// <param name="sender">The source of the event.</param>
-        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
-        private async void OnTriggerTriggered(object sender, EventArgs e)
-        {
-            var trigger = (ITaskTrigger)sender;
+    /// <summary>
+    /// Handles the Triggered event of the trigger control.
+    /// </summary>
+    /// <param name="sender">The source of the event.</param>
+    /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
+    private async void OnTriggerTriggered(object sender, EventArgs e)
+    {
+        var trigger = (ITaskTrigger)sender;
 
-            if (ScheduledTask is IConfigurableScheduledTask configurableTask && !configurableTask.IsEnabled)
-            {
-                return;
-            }
+        if (ScheduledTask is IConfigurableScheduledTask configurableTask && !configurableTask.IsEnabled)
+        {
+            return;
+        }
 
-            _logger.LogDebug("{0} fired for task: {1}", trigger.GetType().Name, Name);
+        _logger.LogDebug("{0} fired for task: {1}", trigger.GetType().Name, Name);
 
-            trigger.Stop();
+        trigger.Stop();
 
-            _taskManager.QueueScheduledTask(ScheduledTask, trigger.TaskOptions);
+        _taskManager.QueueScheduledTask(ScheduledTask, trigger.TaskOptions);
 
-            await Task.Delay(1000).ConfigureAwait(false);
+        await Task.Delay(1000).ConfigureAwait(false);
 
-            trigger.Start(LastExecutionResult, _logger, Name, false);
-        }
+        trigger.Start(LastExecutionResult, _logger, Name, false);
+    }
 
-        /// <summary>
-        /// Executes the task.
-        /// </summary>
-        /// <param name="options">Task options.</param>
-        /// <returns>Task.</returns>
-        /// <exception cref="InvalidOperationException">Cannot execute a Task that is already running.</exception>
-        public async Task Execute(TaskOptions options)
-        {
-            var task = Task.Run(async () => await ExecuteInternal(options).ConfigureAwait(false));
+    /// <summary>
+    /// Executes the task.
+    /// </summary>
+    /// <param name="options">Task options.</param>
+    /// <returns>Task.</returns>
+    /// <exception cref="InvalidOperationException">Cannot execute a Task that is already running.</exception>
+    public async Task Execute(TaskOptions options)
+    {
+        var task = Task.Run(async () => await ExecuteInternal(options).ConfigureAwait(false));
 
-            _currentTask = task;
+        _currentTask = task;
 
-            try
-            {
-                await task.ConfigureAwait(false);
-            }
-            finally
-            {
-                _currentTask = null;
-                GC.Collect();
-            }
+        try
+        {
+            await task.ConfigureAwait(false);
         }
-
-        private async Task ExecuteInternal(TaskOptions options)
+        finally
         {
-            // Cancel the current execution, if any
-            if (CurrentCancellationTokenSource is not null)
-            {
-                throw new InvalidOperationException("Cannot execute a Task that is already running");
-            }
-
-            var progress = new Progress<double>();
+            _currentTask = null;
+            GC.Collect();
+        }
+    }
 
-            CurrentCancellationTokenSource = new CancellationTokenSource();
+    private async Task ExecuteInternal(TaskOptions options)
+    {
+        // Cancel the current execution, if any
+        if (CurrentCancellationTokenSource is not null)
+        {
+            throw new InvalidOperationException("Cannot execute a Task that is already running");
+        }
 
-            _logger.LogDebug("Executing {0}", Name);
+        var progress = new Progress<double>();
 
-            ((TaskManager)_taskManager).OnTaskExecuting(this);
+        CurrentCancellationTokenSource = new CancellationTokenSource();
 
-            progress.ProgressChanged += OnProgressChanged;
+        _logger.LogDebug("Executing {0}", Name);
 
-            TaskCompletionStatus status;
-            CurrentExecutionStartTime = DateTime.UtcNow;
+        ((TaskManager)_taskManager).OnTaskExecuting(this);
 
-            Exception failureException = null;
+        progress.ProgressChanged += OnProgressChanged;
 
-            try
-            {
-                if (options is not null && options.MaxRuntimeTicks.HasValue)
-                {
-                    CurrentCancellationTokenSource.CancelAfter(TimeSpan.FromTicks(options.MaxRuntimeTicks.Value));
-                }
+        TaskCompletionStatus status;
+        CurrentExecutionStartTime = DateTime.UtcNow;
 
-                await ScheduledTask.ExecuteAsync(progress, CurrentCancellationTokenSource.Token).ConfigureAwait(false);
+        Exception failureException = null;
 
-                status = TaskCompletionStatus.Completed;
-            }
-            catch (OperationCanceledException)
+        try
+        {
+            if (options is not null && options.MaxRuntimeTicks.HasValue)
             {
-                status = TaskCompletionStatus.Cancelled;
+                CurrentCancellationTokenSource.CancelAfter(TimeSpan.FromTicks(options.MaxRuntimeTicks.Value));
             }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error executing Scheduled Task");
 
-                failureException = ex;
-
-                status = TaskCompletionStatus.Failed;
-            }
+            await ScheduledTask.ExecuteAsync(progress, CurrentCancellationTokenSource.Token).ConfigureAwait(false);
 
-            var startTime = CurrentExecutionStartTime;
-            var endTime = DateTime.UtcNow;
+            status = TaskCompletionStatus.Completed;
+        }
+        catch (OperationCanceledException)
+        {
+            status = TaskCompletionStatus.Cancelled;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error executing Scheduled Task");
 
-            progress.ProgressChanged -= OnProgressChanged;
-            CurrentCancellationTokenSource.Dispose();
-            CurrentCancellationTokenSource = null;
-            CurrentProgress = null;
+            failureException = ex;
 
-            OnTaskCompleted(startTime, endTime, status, failureException);
+            status = TaskCompletionStatus.Failed;
         }
 
-        /// <summary>
-        /// Progress_s the progress changed.
-        /// </summary>
-        /// <param name="sender">The sender.</param>
-        /// <param name="e">The e.</param>
-        private void OnProgressChanged(object sender, double e)
-        {
-            e = Math.Min(e, 100);
+        var startTime = CurrentExecutionStartTime;
+        var endTime = DateTime.UtcNow;
 
-            CurrentProgress = e;
+        progress.ProgressChanged -= OnProgressChanged;
+        CurrentCancellationTokenSource.Dispose();
+        CurrentCancellationTokenSource = null;
+        CurrentProgress = null;
 
-            TaskProgress?.Invoke(this, new GenericEventArgs<double>(e));
-        }
+        OnTaskCompleted(startTime, endTime, status, failureException);
+    }
 
-        /// <summary>
-        /// Stops the task if it is currently executing.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">Cannot cancel a Task unless it is in the Running state.</exception>
-        public void Cancel()
-        {
-            if (State != TaskState.Running)
-            {
-                throw new InvalidOperationException("Cannot cancel a Task unless it is in the Running state.");
-            }
+    /// <summary>
+    /// Progress_s the progress changed.
+    /// </summary>
+    /// <param name="sender">The sender.</param>
+    /// <param name="e">The e.</param>
+    private void OnProgressChanged(object sender, double e)
+    {
+        e = Math.Min(e, 100);
 
-            CancelIfRunning();
-        }
+        CurrentProgress = e;
 
-        /// <summary>
-        /// Cancels if running.
-        /// </summary>
-        public void CancelIfRunning()
-        {
-            if (State == TaskState.Running)
-            {
-                _logger.LogInformation("Attempting to cancel Scheduled Task {0}", Name);
-                CurrentCancellationTokenSource.Cancel();
-            }
-        }
+        TaskProgress?.Invoke(this, new GenericEventArgs<double>(e));
+    }
 
-        /// <summary>
-        /// Gets the scheduled tasks configuration directory.
-        /// </summary>
-        /// <returns>System.String.</returns>
-        private string GetScheduledTasksConfigurationDirectory()
+    /// <summary>
+    /// Stops the task if it is currently executing.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Cannot cancel a Task unless it is in the Running state.</exception>
+    public void Cancel()
+    {
+        if (State != TaskState.Running)
         {
-            return Path.Combine(_applicationPaths.ConfigurationDirectoryPath, "ScheduledTasks");
+            throw new InvalidOperationException("Cannot cancel a Task unless it is in the Running state.");
         }
 
-        /// <summary>
-        /// Gets the scheduled tasks data directory.
-        /// </summary>
-        /// <returns>System.String.</returns>
-        private string GetScheduledTasksDataDirectory()
-        {
-            return Path.Combine(_applicationPaths.DataPath, "ScheduledTasks");
-        }
+        CancelIfRunning();
+    }
 
-        /// <summary>
-        /// Gets the history file path.
-        /// </summary>
-        /// <value>The history file path.</value>
-        private string GetHistoryFilePath()
+    /// <summary>
+    /// Cancels if running.
+    /// </summary>
+    public void CancelIfRunning()
+    {
+        if (State == TaskState.Running)
         {
-            return Path.Combine(GetScheduledTasksDataDirectory(), new Guid(Id) + ".js");
+            _logger.LogInformation("Attempting to cancel Scheduled Task {0}", Name);
+            CurrentCancellationTokenSource.Cancel();
         }
+    }
 
-        /// <summary>
-        /// Gets the configuration file path.
-        /// </summary>
-        /// <returns>System.String.</returns>
-        private string GetConfigurationFilePath()
-        {
-            return Path.Combine(GetScheduledTasksConfigurationDirectory(), new Guid(Id) + ".js");
-        }
+    /// <summary>
+    /// Gets the scheduled tasks configuration directory.
+    /// </summary>
+    /// <returns>System.String.</returns>
+    private string GetScheduledTasksConfigurationDirectory()
+    {
+        return Path.Combine(_applicationPaths.ConfigurationDirectoryPath, "ScheduledTasks");
+    }
 
-        /// <summary>
-        /// Loads the triggers.
-        /// </summary>
-        /// <returns>IEnumerable{BaseTaskTrigger}.</returns>
-        private Tuple<TaskTriggerInfo, ITaskTrigger>[] LoadTriggers()
-        {
-            // This null check is not great, but is needed to handle bad user input, or user mucking with the config file incorrectly
-            var settings = LoadTriggerSettings().Where(i => i is not null);
+    /// <summary>
+    /// Gets the scheduled tasks data directory.
+    /// </summary>
+    /// <returns>System.String.</returns>
+    private string GetScheduledTasksDataDirectory()
+    {
+        return Path.Combine(_applicationPaths.DataPath, "ScheduledTasks");
+    }
 
-            return settings.Select(i => new Tuple<TaskTriggerInfo, ITaskTrigger>(i, GetTrigger(i))).ToArray();
-        }
+    /// <summary>
+    /// Gets the history file path.
+    /// </summary>
+    /// <value>The history file path.</value>
+    private string GetHistoryFilePath()
+    {
+        return Path.Combine(GetScheduledTasksDataDirectory(), new Guid(Id) + ".js");
+    }
 
-        private TaskTriggerInfo[] LoadTriggerSettings()
-        {
-            string path = GetConfigurationFilePath();
-            TaskTriggerInfo[] list = null;
-            if (File.Exists(path))
-            {
-                var bytes = File.ReadAllBytes(path);
-                list = JsonSerializer.Deserialize<TaskTriggerInfo[]>(bytes, _jsonOptions);
-            }
+    /// <summary>
+    /// Gets the configuration file path.
+    /// </summary>
+    /// <returns>System.String.</returns>
+    private string GetConfigurationFilePath()
+    {
+        return Path.Combine(GetScheduledTasksConfigurationDirectory(), new Guid(Id) + ".js");
+    }
 
-            // Return defaults if file doesn't exist.
-            return list ?? GetDefaultTriggers();
-        }
+    /// <summary>
+    /// Loads the triggers.
+    /// </summary>
+    /// <returns>IEnumerable{BaseTaskTrigger}.</returns>
+    private Tuple<TaskTriggerInfo, ITaskTrigger>[] LoadTriggers()
+    {
+        // This null check is not great, but is needed to handle bad user input, or user mucking with the config file incorrectly
+        var settings = LoadTriggerSettings().Where(i => i is not null);
+
+        return settings.Select(i => new Tuple<TaskTriggerInfo, ITaskTrigger>(i, GetTrigger(i))).ToArray();
+    }
 
-        private TaskTriggerInfo[] GetDefaultTriggers()
+    private TaskTriggerInfo[] LoadTriggerSettings()
+    {
+        string path = GetConfigurationFilePath();
+        TaskTriggerInfo[] list = null;
+        if (File.Exists(path))
         {
-            try
-            {
-                return ScheduledTask.GetDefaultTriggers().ToArray();
-            }
-            catch
-            {
-                return
-                [
-                    new()
-                    {
-                        IntervalTicks = TimeSpan.FromDays(1).Ticks,
-                        Type = TaskTriggerInfoType.IntervalTrigger
-                    }
-                ];
-            }
+            var bytes = File.ReadAllBytes(path);
+            list = JsonSerializer.Deserialize<TaskTriggerInfo[]>(bytes, _jsonOptions);
         }
 
-        /// <summary>
-        /// Saves the triggers.
-        /// </summary>
-        /// <param name="triggers">The triggers.</param>
-        private void SaveTriggers(TaskTriggerInfo[] triggers)
-        {
-            var path = GetConfigurationFilePath();
+        // Return defaults if file doesn't exist.
+        return list ?? GetDefaultTriggers();
+    }
 
-            Directory.CreateDirectory(Path.GetDirectoryName(path));
-            using FileStream createStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
-            using Utf8JsonWriter jsonWriter = new Utf8JsonWriter(createStream);
-            JsonSerializer.Serialize(jsonWriter, triggers, _jsonOptions);
+    private TaskTriggerInfo[] GetDefaultTriggers()
+    {
+        try
+        {
+            return ScheduledTask.GetDefaultTriggers().ToArray();
         }
-
-        /// <summary>
-        /// Called when [task completed].
-        /// </summary>
-        /// <param name="startTime">The start time.</param>
-        /// <param name="endTime">The end time.</param>
-        /// <param name="status">The status.</param>
-        /// <param name="ex">The exception.</param>
-        private void OnTaskCompleted(DateTime startTime, DateTime endTime, TaskCompletionStatus status, Exception ex)
+        catch
         {
-            var elapsedTime = endTime - startTime;
+            return
+            [
+                new()
+                {
+                    IntervalTicks = TimeSpan.FromDays(1).Ticks,
+                    Type = TaskTriggerInfoType.IntervalTrigger
+                }
+            ];
+        }
+    }
 
-            _logger.LogInformation("{0} {1} after {2} minute(s) and {3} seconds", Name, status, Math.Truncate(elapsedTime.TotalMinutes), elapsedTime.Seconds);
+    /// <summary>
+    /// Saves the triggers.
+    /// </summary>
+    /// <param name="triggers">The triggers.</param>
+    private void SaveTriggers(TaskTriggerInfo[] triggers)
+    {
+        var path = GetConfigurationFilePath();
 
-            var result = new TaskResult
-            {
-                StartTimeUtc = startTime,
-                EndTimeUtc = endTime,
-                Status = status,
-                Name = Name,
-                Id = Id
-            };
+        Directory.CreateDirectory(Path.GetDirectoryName(path));
+        using FileStream createStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
+        using Utf8JsonWriter jsonWriter = new Utf8JsonWriter(createStream);
+        JsonSerializer.Serialize(jsonWriter, triggers, _jsonOptions);
+    }
 
-            result.Key = ScheduledTask.Key;
+    /// <summary>
+    /// Called when [task completed].
+    /// </summary>
+    /// <param name="startTime">The start time.</param>
+    /// <param name="endTime">The end time.</param>
+    /// <param name="status">The status.</param>
+    /// <param name="ex">The exception.</param>
+    private void OnTaskCompleted(DateTime startTime, DateTime endTime, TaskCompletionStatus status, Exception ex)
+    {
+        var elapsedTime = endTime - startTime;
 
-            if (ex is not null)
-            {
-                result.ErrorMessage = ex.Message;
-                result.LongErrorMessage = ex.StackTrace;
-            }
+        _logger.LogInformation("{0} {1} after {2} minute(s) and {3} seconds", Name, status, Math.Truncate(elapsedTime.TotalMinutes), elapsedTime.Seconds);
 
-            LastExecutionResult = result;
+        var result = new TaskResult
+        {
+            StartTimeUtc = startTime,
+            EndTimeUtc = endTime,
+            Status = status,
+            Name = Name,
+            Id = Id
+        };
 
-            ((TaskManager)_taskManager).OnTaskCompleted(this, result);
-        }
+        result.Key = ScheduledTask.Key;
 
-        /// <inheritdoc />
-        public void Dispose()
+        if (ex is not null)
         {
-            Dispose(true);
-            GC.SuppressFinalize(this);
+            result.ErrorMessage = ex.Message;
+            result.LongErrorMessage = ex.StackTrace;
         }
 
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool dispose)
+        LastExecutionResult = result;
+
+        ((TaskManager)_taskManager).OnTaskCompleted(this, result);
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Releases unmanaged and - optionally - managed resources.
+    /// </summary>
+    /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    protected virtual void Dispose(bool dispose)
+    {
+        if (dispose)
         {
-            if (dispose)
-            {
-                DisposeTriggers();
+            DisposeTriggers();
 
-                var wasRunning = State == TaskState.Running;
-                var startTime = CurrentExecutionStartTime;
+            var wasRunning = State == TaskState.Running;
+            var startTime = CurrentExecutionStartTime;
 
-                var token = CurrentCancellationTokenSource;
-                if (token is not null)
+            var token = CurrentCancellationTokenSource;
+            if (token is not null)
+            {
+                try
                 {
-                    try
-                    {
-                        _logger.LogInformation("{Name}: Cancelling", Name);
-                        token.Cancel();
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error calling CancellationToken.Cancel();");
-                    }
+                    _logger.LogInformation("{Name}: Cancelling", Name);
+                    token.Cancel();
                 }
-
-                var task = _currentTask;
-                if (task is not null)
+                catch (Exception ex)
                 {
-                    try
-                    {
-                        _logger.LogInformation("{Name}: Waiting on Task", Name);
-                        var exited = task.Wait(2000);
-
-                        if (exited)
-                        {
-                            _logger.LogInformation("{Name}: Task exited", Name);
-                        }
-                        else
-                        {
-                            _logger.LogInformation("{Name}: Timed out waiting for task to stop", Name);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.LogError(ex, "Error calling Task.WaitAll();");
-                    }
+                    _logger.LogError(ex, "Error calling CancellationToken.Cancel();");
                 }
+            }
 
-                if (token is not null)
+            var task = _currentTask;
+            if (task is not null)
+            {
+                try
                 {
-                    try
+                    _logger.LogInformation("{Name}: Waiting on Task", Name);
+                    var exited = task.Wait(2000);
+
+                    if (exited)
                     {
-                        _logger.LogDebug("{Name}: Disposing CancellationToken", Name);
-                        token.Dispose();
+                        _logger.LogInformation("{Name}: Task exited", Name);
                     }
-                    catch (Exception ex)
+                    else
                     {
-                        _logger.LogError(ex, "Error calling CancellationToken.Dispose();");
+                        _logger.LogInformation("{Name}: Timed out waiting for task to stop", Name);
                     }
                 }
-
-                if (wasRunning)
+                catch (Exception ex)
                 {
-                    OnTaskCompleted(startTime, DateTime.UtcNow, TaskCompletionStatus.Aborted, null);
+                    _logger.LogError(ex, "Error calling Task.WaitAll();");
                 }
             }
-        }
-
-        /// <summary>
-        /// Converts a TaskTriggerInfo into a concrete BaseTaskTrigger.
-        /// </summary>
-        /// <param name="info">The info.</param>
-        /// <returns>BaseTaskTrigger.</returns>
-        /// <exception cref="ArgumentException">Invalid trigger type:  + info.Type.</exception>
-        private ITaskTrigger GetTrigger(TaskTriggerInfo info)
-        {
-            var options = new TaskOptions
-            {
-                MaxRuntimeTicks = info.MaxRuntimeTicks
-            };
 
-            if (info.Type == TaskTriggerInfoType.DailyTrigger)
+            if (token is not null)
             {
-                if (!info.TimeOfDayTicks.HasValue)
+                try
                 {
-                    throw new ArgumentException("Info did not contain a TimeOfDayTicks.", nameof(info));
+                    _logger.LogDebug("{Name}: Disposing CancellationToken", Name);
+                    token.Dispose();
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error calling CancellationToken.Dispose();");
                 }
-
-                return new DailyTrigger(TimeSpan.FromTicks(info.TimeOfDayTicks.Value), options);
             }
 
-            if (info.Type == TaskTriggerInfoType.WeeklyTrigger)
+            if (wasRunning)
             {
-                if (!info.TimeOfDayTicks.HasValue)
-                {
-                    throw new ArgumentException("Info did not contain a TimeOfDayTicks.", nameof(info));
-                }
+                OnTaskCompleted(startTime, DateTime.UtcNow, TaskCompletionStatus.Aborted, null);
+            }
+        }
+    }
 
-                if (!info.DayOfWeek.HasValue)
-                {
-                    throw new ArgumentException("Info did not contain a DayOfWeek.", nameof(info));
-                }
+    /// <summary>
+    /// Converts a TaskTriggerInfo into a concrete BaseTaskTrigger.
+    /// </summary>
+    /// <param name="info">The info.</param>
+    /// <returns>BaseTaskTrigger.</returns>
+    /// <exception cref="ArgumentException">Invalid trigger type:  + info.Type.</exception>
+    private ITaskTrigger GetTrigger(TaskTriggerInfo info)
+    {
+        var options = new TaskOptions
+        {
+            MaxRuntimeTicks = info.MaxRuntimeTicks
+        };
 
-                return new WeeklyTrigger(TimeSpan.FromTicks(info.TimeOfDayTicks.Value), info.DayOfWeek.Value, options);
+        if (info.Type == TaskTriggerInfoType.DailyTrigger)
+        {
+            if (!info.TimeOfDayTicks.HasValue)
+            {
+                throw new ArgumentException("Info did not contain a TimeOfDayTicks.", nameof(info));
             }
 
-            if (info.Type == TaskTriggerInfoType.IntervalTrigger)
+            return new DailyTrigger(TimeSpan.FromTicks(info.TimeOfDayTicks.Value), options);
+        }
+
+        if (info.Type == TaskTriggerInfoType.WeeklyTrigger)
+        {
+            if (!info.TimeOfDayTicks.HasValue)
             {
-                if (!info.IntervalTicks.HasValue)
-                {
-                    throw new ArgumentException("Info did not contain a IntervalTicks.", nameof(info));
-                }
+                throw new ArgumentException("Info did not contain a TimeOfDayTicks.", nameof(info));
+            }
 
-                return new IntervalTrigger(TimeSpan.FromTicks(info.IntervalTicks.Value), options);
+            if (!info.DayOfWeek.HasValue)
+            {
+                throw new ArgumentException("Info did not contain a DayOfWeek.", nameof(info));
             }
 
-            if (info.Type == TaskTriggerInfoType.StartupTrigger)
+            return new WeeklyTrigger(TimeSpan.FromTicks(info.TimeOfDayTicks.Value), info.DayOfWeek.Value, options);
+        }
+
+        if (info.Type == TaskTriggerInfoType.IntervalTrigger)
+        {
+            if (!info.IntervalTicks.HasValue)
             {
-                return new StartupTrigger(options);
+                throw new ArgumentException("Info did not contain a IntervalTicks.", nameof(info));
             }
 
-            throw new ArgumentException("Unrecognized trigger type: " + info.Type);
+            return new IntervalTrigger(TimeSpan.FromTicks(info.IntervalTicks.Value), options);
         }
 
-        /// <summary>
-        /// Disposes each trigger.
-        /// </summary>
-        private void DisposeTriggers()
+        if (info.Type == TaskTriggerInfoType.StartupTrigger)
         {
-            foreach (var triggerInfo in InternalTriggers)
+            return new StartupTrigger(options);
+        }
+
+        throw new ArgumentException("Unrecognized trigger type: " + info.Type);
+    }
+
+    /// <summary>
+    /// Disposes each trigger.
+    /// </summary>
+    private void DisposeTriggers()
+    {
+        foreach (var triggerInfo in InternalTriggers)
+        {
+            var trigger = triggerInfo.Item2;
+            trigger.Triggered -= OnTriggerTriggered;
+            trigger.Stop();
+            if (trigger is IDisposable disposable)
             {
-                var trigger = triggerInfo.Item2;
-                trigger.Triggered -= OnTriggerTriggered;
-                trigger.Stop();
-                if (trigger is IDisposable disposable)
-                {
-                    disposable.Dispose();
-                }
+                disposable.Dispose();
             }
         }
     }