438 lines
22 KiB
C#
438 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using J2N.Collections.Generic.Extensions;
|
|
using Jellyfin.Data.Enums;
|
|
using Jellyfin.Database.Implementations.Entities;
|
|
using Jellyfin.Extensions;
|
|
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.Controller.Playlists;
|
|
using MediaBrowser.Model.Dto;
|
|
using MediaBrowser.Model.Entities;
|
|
using MediaBrowser.Model.Playlists;
|
|
using MediaBrowser.Model.Tasks;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace Jellyfin.Plugin.TubeArchivistMetadata.Tasks
|
|
{
|
|
/// <summary>
|
|
/// Task to sync TubeArchivist playlists to Jellyfin.
|
|
/// </summary>
|
|
public class JFToTubeArchivistPlaylistsSyncTask : IScheduledTask
|
|
{
|
|
private readonly ILogger<Plugin> _logger;
|
|
private readonly ILibraryManager _libraryManager;
|
|
private readonly IUserManager _userManager;
|
|
private readonly IPlaylistManager _playlistManager;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JFToTubeArchivistPlaylistsSyncTask"/> class.
|
|
/// </summary>
|
|
/// <param name="logger">Logger.</param>
|
|
/// <param name="libraryManager">Library manager.</param>
|
|
/// <param name="userManager">User manager.</param>
|
|
/// <param name="playlistManager">Playlists manager.</param>
|
|
public JFToTubeArchivistPlaylistsSyncTask(ILogger<Plugin> logger, ILibraryManager libraryManager, IUserManager userManager, IPlaylistManager playlistManager)
|
|
{
|
|
_logger = logger;
|
|
_libraryManager = libraryManager;
|
|
_userManager = userManager;
|
|
_playlistManager = playlistManager;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public string Name => "JFToTubeArchivistPlaylistsSyncTask";
|
|
|
|
/// <inheritdoc/>
|
|
public string Description => "This tasks syncs Jellyfin playlists to TubeArchivist";
|
|
|
|
/// <inheritdoc/>
|
|
public string Category => "TubeArchivistMetadata";
|
|
|
|
/// <inheritdoc/>
|
|
public string Key => "JFToTubeArchivistPlaylistsSyncTask";
|
|
|
|
private Dictionary<Guid, List<BaseItem>> GetAllVideos(IEnumerable<MediaBrowser.Controller.Playlists.Playlist> playlists, User user)
|
|
{
|
|
var items = new Dictionary<Guid, List<BaseItem>>();
|
|
foreach (var playlist in playlists)
|
|
{
|
|
items[playlist.Id] = new List<BaseItem>(playlist.GetChildren(user, true, new InternalItemsQuery()));
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
private int CountTotalVideos(Dictionary<Guid, List<BaseItem>> playlistsItems)
|
|
{
|
|
var totalVideosCount = 0;
|
|
foreach (var playlistId in playlistsItems.Keys)
|
|
{
|
|
totalVideosCount += playlistsItems[playlistId].Count;
|
|
}
|
|
|
|
return totalVideosCount;
|
|
}
|
|
|
|
private string GetPlaylistUpdatedName(string playlistName, string newId)
|
|
{
|
|
var index = playlistName.LastIndexOf(" (", StringComparison.CurrentCulture);
|
|
if (index < 0)
|
|
{
|
|
return $"{playlistName} ({newId})";
|
|
}
|
|
else
|
|
{
|
|
var authorAndName = playlistName.Substring(0, index);
|
|
return $"{authorAndName} ({newId})";
|
|
}
|
|
}
|
|
|
|
private void MoveElementToPosition(Collection<PlaylistEntry> playlistEntries, int oldPosition, int newPosition)
|
|
{
|
|
var oldItem = playlistEntries[oldPosition];
|
|
playlistEntries.RemoveAt(oldPosition);
|
|
playlistEntries.Insert(newPosition, oldItem);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
|
|
{
|
|
progress.Report(0);
|
|
if (Plugin.Instance!.Configuration.JFTAPlaylistsSync)
|
|
{
|
|
var start = DateTime.Now;
|
|
_logger.LogInformation("Starting Jellyfin->TubeArchivist playlists synchronization.");
|
|
var taApi = TubeArchivistApi.GetInstance();
|
|
var taPlaylists = await taApi.GetPlaylists().ConfigureAwait(true);
|
|
|
|
var jfUsername = Plugin.Instance!.Configuration.JFUsernameFrom;
|
|
|
|
var user = _userManager.GetUserByName(jfUsername);
|
|
if (user == null)
|
|
{
|
|
_logger.LogInformation("{Message}", $"Jellyfin user with username {jfUsername} not found");
|
|
return;
|
|
}
|
|
|
|
var userPlaylists = _playlistManager.GetPlaylists(user.Id).ToList();
|
|
var jfItemsToAnalyze = GetAllVideos(userPlaylists, user);
|
|
var totalVideosCount = CountTotalVideos(jfItemsToAnalyze);
|
|
var processedVideosCount = 0;
|
|
|
|
_logger.LogInformation("Found a total of {PlaylistsCount} playlists to analyze with a total of {VideosCount} videos", userPlaylists.Count, totalVideosCount);
|
|
if (taPlaylists != null && Plugin.Instance!.Configuration.JFTAPlaylistsDelete)
|
|
{
|
|
var taPlaylistsToDelete = taPlaylists.Where(tp => !userPlaylists.Select(up => Utils.GetTAPlaylistIdFromName(up.Name)).Contains(tp.Id));
|
|
foreach (var taPlaylistToDelete in taPlaylistsToDelete)
|
|
{
|
|
_logger.LogInformation("Deleting TubeArchivist playlist {PlaylistName} ({PlaylistId})", taPlaylistToDelete.Name, taPlaylistToDelete.Id);
|
|
await taApi.DeletePlaylist(taPlaylistToDelete.Id).ConfigureAwait(true);
|
|
}
|
|
}
|
|
|
|
foreach (var jfPlaylist in userPlaylists)
|
|
{
|
|
_logger.LogInformation("Analyzing playlist {PlaylistName}...", jfPlaylist.Name);
|
|
var taPlaylistId = Utils.GetTAPlaylistIdFromName(jfPlaylist.Name);
|
|
if (taPlaylistId == null)
|
|
{
|
|
_logger.LogDebug("The playlist {PlaylistName} was not a TA playlist: could not find TA playlist id at the end", jfPlaylist.Name);
|
|
continue;
|
|
}
|
|
|
|
// Try to find a TA playlist with matching id
|
|
// N.B.: only videos with TubeArchivist provider can be synced to TA, if there is a non matching video log a warn
|
|
var taPlaylist = taPlaylists?.Where(tp => tp.Id == taPlaylistId).FirstOrDefault();
|
|
|
|
if (taPlaylist != null)
|
|
{
|
|
// If it exists and is custom add new videos and update videos order
|
|
if (taPlaylist.Type == PlaylistType.Custom)
|
|
{
|
|
var jfItems = jfItemsToAnalyze[jfPlaylist.Id];
|
|
_logger.LogInformation("Found {PlaylistVideosCount} videos in playlist {PlaylistName}", jfItems.Count, jfPlaylist.Name);
|
|
|
|
var itemsToProcess = new List<PlaylistItemAction>();
|
|
|
|
// Add videos to move/add to the TA playlist
|
|
for (var i = 0; i < jfItems.Count; i++)
|
|
{
|
|
if (!jfItems[i].ProviderIds.ContainsKey(Constants.ProviderName))
|
|
{
|
|
_logger.LogError("Could not sync {JFItem} video from playlist {JFPlaylist} because it doesn't belong to TubeArchivist", jfItems[i].Name, jfPlaylist.Name);
|
|
continue;
|
|
}
|
|
|
|
var position = taPlaylist.Entries.FindIndex(e => e.YoutubeId == jfItems[i].ProviderIds[Constants.ProviderName]);
|
|
PlaylistItemAction action;
|
|
if (position < 0)
|
|
{
|
|
_logger.LogDebug("Video {VideoName} from playlist {PlaylistName} not found in TA playlist", jfItems[i].Name, jfPlaylist.Name);
|
|
var positionsToMove = i - position;
|
|
action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], CustomPlaylistAction.Create, positionsToMove, jfItems[i].Name);
|
|
taPlaylist.Entries.Insert(i, new PlaylistEntry(jfItems[i].ProviderIds[Constants.ProviderName], jfItems[i].Name, jfItems[i].Studios[0], i, true));
|
|
}
|
|
else
|
|
{
|
|
_logger.LogDebug("Found video {VideoName} at position {JFPosition} in playlist {PlaylistName} at position {TAPosition} in TA playlist", jfItems[i].Name, i, jfPlaylist.Name, position);
|
|
if (i == 0)
|
|
{
|
|
action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], CustomPlaylistAction.Top, jfItems[i].Name);
|
|
}
|
|
else if (i == jfItems.Count)
|
|
{
|
|
action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], CustomPlaylistAction.Bottom, jfItems[i].Name);
|
|
}
|
|
else
|
|
{
|
|
var positionsToMove = i - position;
|
|
action = new PlaylistItemAction(i, jfItems[i].ProviderIds[Constants.ProviderName], positionsToMove > 0 ? CustomPlaylistAction.Up : CustomPlaylistAction.Down, Math.Abs(positionsToMove), jfItems[i].Name);
|
|
}
|
|
|
|
var temp = taPlaylist.Entries[position];
|
|
taPlaylist.Entries.RemoveAt(position);
|
|
taPlaylist.Entries.Insert(i, temp);
|
|
}
|
|
|
|
itemsToProcess.Add(action);
|
|
}
|
|
|
|
// Add videos to delete from the TA playlist
|
|
var itemsToDelete = taPlaylist.Entries
|
|
.Where(e => !itemsToProcess
|
|
.Select(i => i.YoutubeId)
|
|
.Contains(e.YoutubeId))
|
|
.ToList();
|
|
foreach (var item in itemsToDelete)
|
|
{
|
|
_logger.LogDebug("Video {VideoName} not found in JF playlist, marking for deletion", item.Title);
|
|
var ret = taPlaylist.Entries.Remove(item);
|
|
}
|
|
|
|
itemsToProcess.AddRange(itemsToDelete.Select(e => new PlaylistItemAction(e.YoutubeId, e.Title)));
|
|
|
|
foreach (var item in itemsToProcess)
|
|
{
|
|
_logger.LogDebug("Analyzing video {VideoName} from playlist {PlaylistName} at position {Position}", item.Name, jfPlaylist.Name, item.Index);
|
|
switch (item.Action)
|
|
{
|
|
case CustomPlaylistAction.Create:
|
|
var success = await AddVideoToTAPlaylist(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
|
|
if (!success)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
|
|
case CustomPlaylistAction.Top:
|
|
case CustomPlaylistAction.Bottom:
|
|
_logger.LogDebug("Moving the video {VideoName} to the {Side} of the playlist {PlaylistName}", item.Name, item.Action, jfPlaylist.Name);
|
|
await MoveOrDeleteVideo(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
|
|
break;
|
|
|
|
case CustomPlaylistAction.Remove:
|
|
_logger.LogDebug("Removing the video {VideoName} in playlist {PlaylistName}", item.Name, jfPlaylist.Name);
|
|
await MoveOrDeleteVideo(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
|
|
break;
|
|
|
|
default:
|
|
_logger.LogDebug("Moving the video {VideoName} {Direction} in playlist {PlaylistName}", item.Name, item.Action, jfPlaylist.Name);
|
|
await MoveOrDeleteVideo(taApi, jfPlaylist, taPlaylistId, item).ConfigureAwait(true);
|
|
break;
|
|
}
|
|
|
|
processedVideosCount++;
|
|
progress.Report(processedVideosCount * 100 / totalVideosCount);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.LogWarning("Could not sync modifications on a YouTube downloaded TA playlist: {TAPlaylist}", $"{taPlaylist.Name} - {taPlaylist.Channel} ({taPlaylist.Id})");
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If it doesn't, create a new custom playlist and add videos
|
|
_logger.LogInformation("Playlist {PlaylistName} was not found on TubeArchivist. Creating a new playlist...", jfPlaylist.Name);
|
|
|
|
var playlistName = Utils.GetTAPlaylistNameFromName(jfPlaylist.Name);
|
|
if (string.IsNullOrEmpty(playlistName))
|
|
{
|
|
playlistName = jfPlaylist.Name;
|
|
}
|
|
|
|
_logger.LogDebug("Creating a new TubeArchivist playlist with name: {PlaylistName}", playlistName);
|
|
|
|
var creationRequest = new CustomPlaylistCreation(playlistName);
|
|
var createdTAPlaylist = await taApi.CreateCustomPlaylist(creationRequest).ConfigureAwait(true);
|
|
if (createdTAPlaylist == null)
|
|
{
|
|
_logger.LogError("Failed to create the playlist {JFPlaylist}", playlistName);
|
|
continue;
|
|
}
|
|
|
|
// Update the JF playlist name with the new TA playlist id
|
|
var newPlaylistName = GetPlaylistUpdatedName(jfPlaylist.Name, createdTAPlaylist.Id);
|
|
var updateRequest = new PlaylistUpdateRequest
|
|
{
|
|
Id = jfPlaylist.Id,
|
|
Name = newPlaylistName,
|
|
UserId = user.Id
|
|
};
|
|
await _playlistManager.UpdatePlaylist(updateRequest).ConfigureAwait(true);
|
|
_logger.LogDebug("Updated the playlist name from {NewPlaylistName} to {NewPlaylistName}", playlistName, newPlaylistName);
|
|
|
|
foreach (var jfItem in jfPlaylist.GetItemList(new InternalItemsQuery()))
|
|
{
|
|
_logger.LogDebug("Adding the video {VideoName} to the playlist {PlaylistName}", jfItem.Name, jfPlaylist.Name);
|
|
var action = new CustomPlaylistEntryAction(CustomPlaylistAction.Create, jfItem.ProviderIds[Constants.ProviderName]);
|
|
var response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
|
|
if (response != System.Net.HttpStatusCode.OK)
|
|
{
|
|
_logger.LogError("Failed to add the video {JFItem} to playlist {JFPlaylist}", $"{jfItem.Name} ({jfItem.ProviderIds[Constants.ProviderName]})", jfPlaylist.Name);
|
|
continue;
|
|
}
|
|
|
|
processedVideosCount++;
|
|
progress.Report(processedVideosCount * 100 / totalVideosCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
_logger.LogInformation("Time elapsed: {Time}", DateTime.Now - start);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogInformation("Jellyfin->TubeArchivist playlists synchronization is currently disabled.");
|
|
}
|
|
|
|
progress.Report(100);
|
|
}
|
|
|
|
private async Task MoveOrDeleteVideo(TubeArchivistApi taApi, MediaBrowser.Controller.Playlists.Playlist jfPlaylist, string taPlaylistId, PlaylistItemAction item)
|
|
{
|
|
var response = HttpStatusCode.OK;
|
|
for (var i = 0; i < item.PositionsToMove; i++)
|
|
{
|
|
var action = new CustomPlaylistEntryAction(item.Action, item.YoutubeId);
|
|
response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
|
|
if (response != System.Net.HttpStatusCode.OK)
|
|
{
|
|
_logger.LogError("Failed to execute the operation {Operation} for the video {JFItem} in playlist {PlaylistName}", item.Action, $"{item.Name} ({item.YoutubeId})", jfPlaylist.Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task<bool> AddVideoToTAPlaylist(TubeArchivistApi taApi, MediaBrowser.Controller.Playlists.Playlist jfPlaylist, string taPlaylistId, PlaylistItemAction item)
|
|
{
|
|
// TA playlist doesn't contain the JF video
|
|
_logger.LogDebug("Adding the video {VideoName} to the playlist {PlaylistName}", item.Name, jfPlaylist.Name);
|
|
var action = new CustomPlaylistEntryAction(CustomPlaylistAction.Create, item.YoutubeId);
|
|
var response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
|
|
if (response != System.Net.HttpStatusCode.OK)
|
|
{
|
|
_logger.LogError("Failed to add the video {JFItem} to playlist {JFPlaylist}", $"{item.Name} ({item.YoutubeId})", jfPlaylist.Name);
|
|
return false;
|
|
}
|
|
|
|
// Since now we have the video added at the bottom of the TA playlist (previouse entries count + 1),
|
|
// we need to move the video to the correct position
|
|
var positionsToMove = item.PositionsToMove;
|
|
action = new CustomPlaylistEntryAction(CustomPlaylistAction.Up, item.YoutubeId);
|
|
if (item.PositionsToMove < 0)
|
|
{
|
|
positionsToMove = (int)Math.Abs((decimal)positionsToMove!);
|
|
action = new CustomPlaylistEntryAction(CustomPlaylistAction.Up, item.YoutubeId);
|
|
}
|
|
|
|
_logger.LogDebug("Moving the video {VideoName} of the playlist {PlaylistName} {Positions} up", item.Name, jfPlaylist.Name, positionsToMove);
|
|
for (var i = 0; i < positionsToMove; i++)
|
|
{
|
|
response = await taApi.CustomPlaylistEntryAction(taPlaylistId, action).ConfigureAwait(true);
|
|
if (response != System.Net.HttpStatusCode.OK)
|
|
{
|
|
_logger.LogError("Failed to move {Direction} the video {JFItem} in playlist {JFPlaylist}", item.Action, $"{item.Name} ({item.YoutubeId})", jfPlaylist.Name);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
|
|
{
|
|
return
|
|
[
|
|
new TaskTriggerInfo
|
|
{
|
|
Type = TaskTriggerInfoType.IntervalTrigger,
|
|
IntervalTicks = TimeSpan.FromSeconds(Plugin.Instance!.Configuration.TAJFProgressTaskInterval).Ticks
|
|
},
|
|
];
|
|
}
|
|
|
|
private sealed class PlaylistItemAction
|
|
{
|
|
public PlaylistItemAction(
|
|
int index,
|
|
string youtubeId,
|
|
CustomPlaylistAction action,
|
|
int positionsToMove,
|
|
string name)
|
|
{
|
|
Index = index;
|
|
YoutubeId = youtubeId;
|
|
Action = action;
|
|
PositionsToMove = positionsToMove;
|
|
Name = name;
|
|
}
|
|
|
|
public PlaylistItemAction(
|
|
int index,
|
|
string youtubeId,
|
|
CustomPlaylistAction action,
|
|
string name)
|
|
{
|
|
Index = index;
|
|
YoutubeId = youtubeId;
|
|
Action = action;
|
|
Name = name;
|
|
PositionsToMove = 1;
|
|
}
|
|
|
|
public PlaylistItemAction(
|
|
string youtubeId,
|
|
string name)
|
|
{
|
|
YoutubeId = youtubeId;
|
|
Action = CustomPlaylistAction.Remove;
|
|
Name = name;
|
|
PositionsToMove = 1;
|
|
}
|
|
|
|
public int? Index { get; set; }
|
|
|
|
public string YoutubeId { get; set; }
|
|
|
|
public string Name { get; set; }
|
|
|
|
public CustomPlaylistAction Action { get; set; }
|
|
|
|
public int? PositionsToMove { get; set; }
|
|
}
|
|
}
|
|
}
|