jellyfin-smart-playlist/Jellyfin.Plugin.SmartPlaylist/ScheduledTasks/GeneratePlaylist.cs

using MediaBrowser.Model.Tasks;
using Microsoft.Extensions.Logging;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Playlists;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.IO;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Jellyfin.Data.Entities;
using Jellyfin.Data.Enums;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Playlists;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.Playlists;
using MediaBrowser.Model.Tasks;
using Microsoft.Extensions.Logging;

using Jellyfin.Plugin.SmartPlaylist.Lisp;
using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
using Lisp_Object = Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler.Object;
using Lisp_Boolean = Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler.Boolean;


namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
    public class GeneratePlaylist : IScheduledTask {

        public static readonly BaseItemKind[] AvailableFilterItems = {
            BaseItemKind.Audio
        };

        private readonly ILogger _logger;
        private readonly ILibraryManager _libraryManager;
        private readonly IUserManager _userManager;
        private readonly IProviderManager _providerManager;
        private readonly IFileSystem _fileSystem;
        private readonly IPlaylistManager _playlistManager;

        private readonly IStore _store;

        public GeneratePlaylist(
            ILogger<Plugin> logger,
            ILibraryManager libraryManager,
            IUserManager userManager,
            IProviderManager providerManager,
            IFileSystem fileSystem,
            IPlaylistManager playlistManager,
            IServerApplicationPaths serverApplicationPaths
        ) {
            _logger = logger;
            _libraryManager = libraryManager;
            _userManager = userManager;
            _providerManager = providerManager;
            _fileSystem = fileSystem;
            _playlistManager = playlistManager;

            _store = new Store(new SmartPlaylistFileSystem(serverApplicationPaths));
        }

        public string Category => "Library";
        public string Name => "(re)generate Smart Playlists";
        public string Description => "Generate or regenerate all Smart Playlists";
        public string Key => nameof(GeneratePlaylist);

        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers() {
            return new[] {
                new TaskTriggerInfo {
                    IntervalTicks = TimeSpan.FromHours(24).Ticks,
                    Type = TaskTriggerInfo.TriggerInterval,
                }
            };
        }

        private void GetUsers() {
            foreach (var user in _userManager.Users) {
                _logger.LogInformation("User {0}", user);
                var query = new InternalItemsQuery(user) {
                    IncludeItemTypes = AvailableFilterItems,
                    Recursive = true,
                };
                foreach (BaseItem item in _libraryManager.GetItemsResult(query).Items) {
                    _logger.LogInformation("Item {0}", item);
                }
            }
        }

        private SmartPlaylistId CreateNewPlaylist(SmartPlaylistDto dto) {
            var req = new PlaylistCreationRequest {
                Name = dto.Name,
                UserId = dto.User
            };
            var playlistGuid = Guid.Parse(_playlistManager.CreatePlaylist(req).Result.Id);
            return playlistGuid;
        }

        private IEnumerable<Guid> FilterPlaylistItems(IEnumerable<BaseItem> items, User user, SmartPlaylistDto smartPlaylist) {
            List<Guid> results = new List<Guid>();
            Expression expression = new Parser(StringTokenStream.generate(smartPlaylist.Program)).parse();
            Executor executor = new Executor();
            executor.environment["user"] = new Lisp_Object(user);
            foreach (var i in items) {
                executor.environment["item"] = new Lisp_Object(i);
                var r = executor.eval(expression);
                _logger.LogDebug("Item {0} evaluated to {1}", i, r.ToString());
                if (r is Lisp_Boolean r_bool) {
                    if (r_bool.value) {
                        _logger.LogDebug("Added "{0}" to Smart Playlist {1}", i, smartPlaylist.Name);
                        results.Add(i.Id);
                    }
                } else {
                    _logger.LogInformation("Program did not return a boolean, returned {0}", r.ToString());
                }
            }
            return results;
        }

        private IEnumerable<BaseItem> GetAllUserMedia(User user) {
            var req = new InternalItemsQuery(user) {
                IncludeItemTypes = new[] {BaseItemKind.Audio},
                Recursive = true,
            };
            return _libraryManager.GetItemsResult(req).Items;
        }

        public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken) {
            _logger.LogInformation("Started regenerate Smart Playlists");
            foreach (SmartPlaylistDto dto in await _store.GetAllSmartPlaylistsAsync()) {
                var user = _userManager.GetUserById(dto.User);
                List<Playlist> playlists = _playlistManager.GetPlaylists(user.Id).Where(x => x.Id == dto.Id).ToList();
                if ((dto.Id == null) || !playlists.Any()) {
                    _logger.LogInformation("Generating new smart playlist (dto.Id = {0}, playlists.Any() = {1})", dto.Id, playlists.Any());
                    _store.DeleteSmartPlaylist(dto);
                    dto.Id = CreateNewPlaylist(dto);
                    await _store.SaveSmartPlaylistAsync(dto);
                    playlists = _playlistManager.GetPlaylists(user.Id).Where(x => x.Id == dto.Id).ToList();
                }
                var insertItems = FilterPlaylistItems(GetAllUserMedia(user), user, dto);
                Playlist playlist = playlists.First();
                await ClearPlaylist(dto, playlist, user);
                await _playlistManager.AddItemToPlaylistAsync(playlist.Id, insertItems.ToArray(), user.Id);
            }
        }

        private async Task ClearPlaylist(SmartPlaylistDto smartPlaylist, Playlist playlist, User user) {
            // fuck if I know
            if (_libraryManager.GetItemById(playlist.Id) is not Playlist playlist_new) {
                throw new ArgumentException("");
            }
            var existingItems = playlist_new.GetManageableItems().ToList();
            await _playlistManager.RemoveItemFromPlaylistAsync(playlist.Id.ToString(), existingItems.Select(x => x.Item1.Id));
        }
    }
}