Implement JF->TA watched status synchronization

Jellyfin.Plugin.TubeArchivistMetadata/Configuration/PluginConfiguration.cs

@@ -41,6 +41,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
             TAJFSync = false;
             _jfUsernamesTo = new HashSet<string>();
             TAJFTaskInterval = 1;
+            JFTAWatchedTaskInterval = 1;
         }
 
         /// <summary>
@@ -135,6 +136,12 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Configuration
         /// </summary>
         public int TAJFTaskInterval { get; set; }
 
+        /// <summary>
+        /// Gets or sets the interval in seconds at which the Jellyfin to TubeArchivist watched statuses synchronization task should run.
+        /// It requires Jellyfin server restart to take effect.
+        /// </summary>
+        public int JFTAWatchedTaskInterval { get; set; }
+
         /// <summary>
         /// Gets the playback progress owners Jellyfin usernames to synchronize data from TubeArchivist.
         /// </summary>

Jellyfin.Plugin.TubeArchivistMetadata/Configuration/configPage.html

@@ -58,6 +58,13 @@
                         <div class="fieldDescription">This is the Jellyfin username to synchronize data from on
                             TubeArchivist</div>
                     </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="JFTAWatchedTaskInterval">Jellyfin to TubeArchivist
+                            watched statuses synchronization interval</label>
+                        <input id="JFTAWatchedTaskInterval" name="JFTAWatchedTaskInterval" type="number" is="emby-input" min="1" />
+                        <div class="fieldDescription">This is the Jellyfin to TubeArchivist watched statuses
+                            synchronization interval in seconds (Jellyfin restart required).</div>
+                    </div>
                     <div class="checkboxContainer checkboxContainer-withDescription">
                         <label class="emby-checkbox-label" for="TAJFSync">
                             <input id="TAJFSync" name="TAJFSync" type="checkbox" is="emby-checkbox" />
@@ -105,6 +112,7 @@
                         document.querySelector('#TAJFSync').checked = config.TAJFSync;
                         document.querySelector('#JFUsernameFrom').value = config.JFUsernameFrom;
                         document.querySelector('#TAJFTaskInterval').value = config.TAJFTaskInterval;
+                        document.querySelector('#JFTAWatchedTaskInterval').value = config.JFTAWatchedTaskInterval;
                         Dashboard.hideLoadingMsg();
                     });
                 });
@@ -122,6 +130,7 @@
                         config.TAJFSync = document.querySelector('#TAJFSync').checked;
                         config.JFUsernameFrom = document.querySelector('#JFUsernameFrom').value;
                         config.TAJFTaskInterval = document.querySelector('#TAJFTaskInterval').value;
+                        config.JFTAWatchedTaskInterval = document.querySelector('#JFTAWatchedTaskInterval').value;
                         ApiClient.updatePluginConfiguration(TAMetadataConfig.pluginUniqueId, config).then(function (result) {
                             Dashboard.processPluginConfigurationUpdateResult(result);
                         });

Jellyfin.Plugin.TubeArchivistMetadata/Plugin.cs

@@ -4,6 +4,7 @@ using System.Globalization;
 using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
 using Jellyfin.Plugin.TubeArchivistMetadata.Configuration;
 using Jellyfin.Plugin.TubeArchivistMetadata.Tasks;
 using Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist;
@@ -11,6 +12,7 @@ using Jellyfin.Plugin.TubeArchivistMetadata.Utilities;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Plugins;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Session;
 using MediaBrowser.Model.Plugins;
@@ -25,6 +27,8 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
     /// </summary>
     public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     {
+        private readonly IUserManager _userManager;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Plugin"/> class.
         /// </summary>
@@ -57,9 +61,11 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
             SessionManager = sessionManager;
             sessionManager.PlaybackProgress += OnPlaybackProgress;
             LibraryManager = libraryManager;
+            _userManager = userManager;
 
             var taToJellyfinProgressSyncTask = new TAToJellyfinProgressSyncTask(logger, libraryManager, userManager, userDataManager);
             var jfToTubearchivistProgressSyncTask = new JFToTubearchivistProgressSyncTask(logger, libraryManager, userManager, userDataManager);
+            var jfToTubearchivistWatchedSyncTask = new JFToTubearchivistWatchedSyncTask(logger, libraryManager, userManager, userDataManager);
             var isTAJFTaskPresent = taskManager.ScheduledTasks.Any(t => t.Name.Equals(taToJellyfinProgressSyncTask.Name, StringComparison.Ordinal));
             if (Instance!.Configuration.TAJFSync && !isTAJFTaskPresent)
             {
@@ -72,8 +78,10 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata
             if (Instance!.Configuration.JFTASync && !isJFTATaskPresent)
             {
                 logger.LogInformation("Queueing task {TaskName}.", jfToTubearchivistProgressSyncTask.Name);
-                taskManager.AddTasks([jfToTubearchivistProgressSyncTask]);
+                logger.LogInformation("Queueing task {TaskName}.", jfToTubearchivistWatchedSyncTask.Name);
+                taskManager.AddTasks([jfToTubearchivistProgressSyncTask, jfToTubearchivistWatchedSyncTask]);
                 taskManager.Execute<JFToTubearchivistProgressSyncTask>();
+                taskManager.Execute<JFToTubearchivistWatchedSyncTask>();
             }
 
             logger.LogInformation("{Message}", "Collection display name: " + Instance?.Configuration.CollectionTitle);

Jellyfin.Plugin.TubeArchivistMetadata/Tasks/JFToTubeArchivistProgressSyncTask.cs

@@ -56,7 +56,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
         /// <inheritdoc/>
         public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
         {
-            if (Plugin.Instance!.Configuration.TAJFSync)
+            if (Plugin.Instance!.Configuration.JFTASync)
             {
                 var start = DateTime.Now;
                 _logger.LogInformation("Starting Jellyfin->TubeArchivist playback progresses synchronization.");
@@ -93,6 +93,9 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
 
                         foreach (Series channel in channels)
                         {
+                            var channelYTId = Utils.GetChannelNameFromPath(channel.Path);
+                            var isChannelWatched = false;
+                            var isChannelCheckedForWatched = false;
                             var years = channel.GetChildren(user, false, new InternalItemsQuery
                             {
                                 IncludeItemTypes = new[] { BaseItemKind.Season }
@@ -116,6 +119,32 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
                                     {
                                         _logger.LogInformation("{Message}", $"POST /video/{videoYTId}/progress returned {statusCode} for video {video.Name} with progress {progress} seconds");
                                     }
+
+                                    if (!isChannelCheckedForWatched && channel.IsPlayed(user))
+                                    {
+                                        var isChannelPlayed = channel.IsPlayed(user);
+                                        statusCode = await taApi.SetWatchedStatus(channelYTId, isChannelPlayed).ConfigureAwait(true);
+                                        if (statusCode != System.Net.HttpStatusCode.OK)
+                                        {
+                                            _logger.LogInformation("{Message}", $"POST /watched returned {statusCode} for channel {channel.Name} ({channelYTId}) with wacthed status {isChannelPlayed}");
+                                        }
+                                        else
+                                        {
+                                            isChannelWatched = true;
+                                        }
+
+                                        isChannelCheckedForWatched = true;
+                                    }
+
+                                    if (!isChannelWatched)
+                                    {
+                                        var isVideoPlayed = video.IsPlayed(user);
+                                        statusCode = await taApi.SetWatchedStatus(videoYTId, isVideoPlayed).ConfigureAwait(true);
+                                        if (statusCode != System.Net.HttpStatusCode.OK)
+                                        {
+                                            _logger.LogInformation("{Message}", $"POST /watched returned {statusCode} for video {video.Name} ({videoYTId}) with wacthed status {isVideoPlayed}");
+                                        }
+                                    }
                                 }
                             }
                         }

Jellyfin.Plugin.TubeArchivistMetadata/Tasks/JFToTubeArchivistWatchedSyncTask.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist;
+using Jellyfin.Plugin.TubeArchivistMetadata.Utilities;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
+{
+    /// <summary>
+    /// Task to sync Jellyfin playback progresses to TubeArchivist.
+    /// </summary>
+    public class JFToTubearchivistWatchedSyncTask : IScheduledTask
+    {
+        private readonly ILogger<Plugin> _logger;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IUserManager _userManager;
+        private readonly IUserDataManager _userDataManager;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JFToTubearchivistWatchedSyncTask"/> class.
+        /// </summary>
+        /// <param name="logger">Logger.</param>
+        /// <param name="libraryManager">Library manager.</param>
+        /// <param name="userManager">User manager.</param>
+        /// <param name="userDataManager">User data manager.</param>
+        public JFToTubearchivistWatchedSyncTask(ILogger<Plugin> logger, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
+        {
+            _logger = logger;
+            _libraryManager = libraryManager;
+            _userManager = userManager;
+            _userDataManager = userDataManager;
+        }
+
+        /// <inheritdoc/>
+        public string Name => "JFToTubearchivistWatchedSyncTask";
+
+        /// <inheritdoc/>
+        public string Description => "This tasks syncs TubeArchivist watched statuses to Jellyfin";
+
+        /// <inheritdoc/>
+        public string Category => "TubeArchivistMetadata";
+
+        /// <inheritdoc/>
+        public string Key => "JFToTubearchivistWatchedSyncTask";
+
+        /// <inheritdoc/>
+        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            if (Plugin.Instance!.Configuration.JFTASync)
+            {
+                var start = DateTime.Now;
+                _logger.LogInformation("Starting Jellyfin->TubeArchivist watched statuses synchronization.");
+                var taApi = TubeArchivistApi.GetInstance();
+                foreach (var jfUsername in Plugin.Instance!.Configuration.GetJFUsernamesToArray())
+                {
+                    var user = _userManager.GetUserByName(jfUsername);
+                    if (user == null)
+                    {
+                        _logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
+                        continue;
+                    }
+
+                    var collectionItem = _libraryManager.GetItemList(new InternalItemsQuery
+                    {
+                        Name = Plugin.Instance?.Configuration.CollectionTitle,
+                        IncludeItemTypes = new[] { BaseItemKind.CollectionFolder }
+                    }).FirstOrDefault();
+
+                    if (collectionItem == null)
+                    {
+                        var message = $"Collection '{Plugin.Instance?.Configuration.CollectionTitle}' not found.";
+                        _logger.LogCritical("{Message}", message);
+                    }
+                    else
+                    {
+                        var collection = (CollectionFolder)collectionItem;
+                        var channels = collection.GetChildren(user, false, new InternalItemsQuery
+                        {
+                            IncludeItemTypes = new[] { BaseItemKind.Series }
+                        });
+                        _logger.LogInformation("Analyzing collection {Id} with name {Name}", collectionItem.Id, collectionItem.Name);
+                        _logger.LogInformation("Found {Message} channels", channels.Count);
+
+                        foreach (Series channel in channels)
+                        {
+                            var channelYTId = Utils.GetChannelNameFromPath(channel.Path);
+                            var isChannelWatched = false;
+                            var isChannelCheckedForWatched = false;
+                            var years = channel.GetChildren(user, false, new InternalItemsQuery
+                            {
+                                IncludeItemTypes = new[] { BaseItemKind.Season }
+                            });
+                            _logger.LogInformation("Found {Years} years in channel {ChannelName}", years.Count, channel.Name);
+
+                            foreach (Season year in years)
+                            {
+                                var videos = year.GetChildren(user, false, new InternalItemsQuery
+                                {
+                                    IncludeItemTypes = new[] { BaseItemKind.Episode }
+                                });
+                                _logger.LogInformation("Found {Videos} videos in year {YearName} of the channel {ChannelName}", videos.Count, year.Name, channel.Name);
+
+                                foreach (Episode video in videos)
+                                {
+                                    var videoYTId = Utils.GetVideoNameFromPath(video.Path);
+
+                                    if (!isChannelCheckedForWatched && channel.IsPlayed(user))
+                                    {
+                                        var isChannelPlayed = channel.IsPlayed(user);
+                                        var statusCode = await taApi.SetWatchedStatus(channelYTId, isChannelPlayed).ConfigureAwait(true);
+                                        if (statusCode != System.Net.HttpStatusCode.OK)
+                                        {
+                                            _logger.LogInformation("{Message}", $"POST /watched returned {statusCode} for channel {channel.Name} ({channelYTId}) with wacthed status {isChannelPlayed}");
+                                        }
+                                        else
+                                        {
+                                            isChannelWatched = true;
+                                        }
+
+                                        isChannelCheckedForWatched = true;
+                                    }
+
+                                    if (!isChannelWatched)
+                                    {
+                                        var isVideoPlayed = video.IsPlayed(user);
+                                        var statusCode = await taApi.SetWatchedStatus(videoYTId, isVideoPlayed).ConfigureAwait(true);
+                                        if (statusCode != System.Net.HttpStatusCode.OK)
+                                        {
+                                            _logger.LogInformation("{Message}", $"POST /watched returned {statusCode} for video {video.Name} ({videoYTId}) with wacthed status {isVideoPlayed}");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                _logger.LogInformation("Time elapsed: {Time}", DateTime.Now - start);
+            }
+            else
+            {
+                _logger.LogInformation("Jellyfin->TubeArchivist watched status is currently disabled.");
+            }
+        }
+
+        /// <inheritdoc/>
+        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+        {
+            return
+            [
+                new TaskTriggerInfo
+                {
+                    Type = TaskTriggerInfo.TriggerInterval,
+                    IntervalTicks = TimeSpan.FromSeconds(Plugin.Instance!.Configuration.JFTAWatchedTaskInterval).Ticks
+                },
+            ];
+        }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/Additional/Watched.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+
+namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
+{
+    /// <summary>
+    /// A class representing TubeArchivist API video watched status.
+    /// </summary>
+    public class Watched
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Watched"/> class.
+        /// </summary>
+        /// <param name="id">Id of the video/channel/playlist.</param>
+        /// <param name="isWatched">Watched status.</param>
+        public Watched(string id, bool isWatched)
+        {
+            Id = id;
+            IsWatched = isWatched;
+        }
+
+        /// <summary>
+        /// Gets the id of the video/channel/playlist.
+        /// </summary>
+        [JsonProperty(PropertyName = "id")]
+        public string Id { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the item has been watched or not.
+        /// </summary>
+        [JsonProperty(PropertyName = "is_watched")]
+        public bool IsWatched { get; }
+    }
+}

Jellyfin.Plugin.TubeArchivistMetadata/TubeArchivist/TubeArchivistApi.cs

@@ -153,7 +153,7 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
         /// </summary>
         /// <param name="videoId">Video id.</param>
         /// <param name="progress">Progress in seconds.</param>
-        /// <returns>Nothing if successful.</returns>
+        /// <returns>The response <see cref="HttpStatusCode"/>.</returns>
         public async Task<HttpStatusCode> SetProgress(string videoId, long progress)
         {
             var progressEndpoint = $"/api/video/{videoId}/progress/";
@@ -187,5 +187,22 @@ namespace Jellyfin.Plugin.TubeArchivistMetadata.TubeArchivist
 
             return progress;
         }
+
+        /// <summary>
+        /// Set video/channel/playlist as watched on TubeArchivist.
+        /// </summary>
+        /// <param name="itemId">Video/channel/playlist id.</param>
+        /// <param name="isWatched">Whether the item has been watched or not.</param>
+        /// <returns>The response <see cref="HttpStatusCode"/>.</returns>
+        public async Task<HttpStatusCode> SetWatchedStatus(string itemId, bool isWatched)
+        {
+            var watchedEndpoint = $"/api/watched/";
+            var url = new Uri(Utils.SanitizeUrl(Plugin.Instance!.Configuration.TubeArchivistUrl + watchedEndpoint));
+            var body = JsonConvert.SerializeObject(new Watched(itemId, isWatched));
+
+            var response = await client.PostAsync(url, new StringContent(body, Encoding.UTF8, "application/json")).ConfigureAwait(true);
+
+            return response.StatusCode;
+        }
     }
 }