redxef/jellyfin-smart-playlist
1
0
Fork 0
Code Issues 3 Pull requests Projects Releases 12 Packages Wiki Activity Actions

Compare commits

base: redxef:main
Branches Tags
redxef:main
redxef:manifest
redxef:collections
redxef:enable-all-item-kinds
redxef:yaml
redxef:v0.5.3.0
redxef:v0.5.2.0
redxef:v0.5.1.0
redxef:v0.5.0.0
redxef:v0.4.1.0
redxef:v0.4.0.0
redxef:v0.3.0.0
redxef:v0.2.2.0
redxef:v0.2.1.0
redxef:v0.2.0.0
redxef:v0.1.1.0
redxef:v0.1.0.0
..
compare: redxef:enable-all-item-kinds
Branches Tags
redxef:main
redxef:manifest
redxef:collections
redxef:enable-all-item-kinds
redxef:yaml
redxef:v0.5.3.0
redxef:v0.5.2.0
redxef:v0.5.1.0
redxef:v0.5.0.0
redxef:v0.4.1.0
redxef:v0.4.0.0
redxef:v0.3.0.0
redxef:v0.2.2.0
redxef:v0.2.1.0
redxef:v0.2.0.0
redxef:v0.1.1.0
redxef:v0.1.0.0

No commits in common. "main" and "enable-all-item-kinds" have entirely different histories.
main ... enable-all

31 changed files with 426 additions and 1390 deletions
Show stats Expand all files Collapse all files

132
Jellyfin.Plugin.SmartPlaylist/Api/LispPlaygroundController.cs
View file

@ -1,132 +0,0 @@
using System.Net.Mime;
using System.Text;
using System.Web;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.ComponentModel.DataAnnotations;
using MediaBrowser.Common.Api;
using MediaBrowser.Controller.Library;
using YamlDotNet.Serialization;
using Jellyfin.Plugin.SmartPlaylist.Lisp;
namespace Jellyfin.Plugin.SmartPlaylist.Api {
[Serializable]
public class ProgramInputDto {
public string InputLinks { get; set; }
public string Program { get; set; }
}
[Serializable]
public class ProgramOutputDto {
public string Output { get; set; }
public string FinalExpression { get; set; }
public string Traceback { get; set; }
}
[ApiController]
[Authorize(Policy = Policies.RequiresElevation)]
[Route("LispPlayground")]
[Produces(MediaTypeNames.Application.Json)]
public class LispPlaygroundController : ControllerBase {
private readonly ILogger _logger;
private readonly ILibraryManager _libraryManager;
public LispPlaygroundController(
ILogger<LispPlaygroundController> logger,
ILibraryManager libraryManager
) {
_logger = logger;
_libraryManager = libraryManager;
}
private Executor SetupExecutor(StringBuilder sb, IList<string> inputs) {
var env = new DefaultEnvironment();
var executor = new Executor(env);
env["*items*"] = Lisp.Cons.FromList(inputs.Select(x => _libraryManager.GetItemById(x)).Select(x => Lisp.Object.FromBase(x)).ToList());
executor.builtins["logd"] = (x) => {
_logger.LogDebug(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["logi"] = (x) => {
_logger.LogInformation(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["logw"] = (x) => {
_logger.LogWarning(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["loge"] = (x) => {
_logger.LogError(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["print"] = (x) => {
sb.Append(string.Join(" ", x.Select((i) => {
if (i is Lisp.String i_s) {
return i_s.Value();
}
return i.ToString();
})));
return Lisp.Boolean.TRUE;
};
executor.builtins["println"] = (x) => {
sb.Append(string.Join(" ", x.Select((i) => {
if (i is Lisp.String i_s) {
return i_s.Value();
}
return i.ToString();
})));
sb.Append("\n");
return Lisp.Boolean.TRUE;
};
if (Plugin.Instance is not null) {
executor.eval(Plugin.Instance.Configuration.InitialProgram);
} else {
throw new ApplicationException("Plugin Instance is not yet initialized");
}
return executor;
}
private List<string> extractItemIds(string s) {
List<string> r = new List<string>();
foreach (string line in s.Split("\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)) {
var uri = new Uri(line);
uri = new Uri("http://some-domain.tld" + uri.Fragment.Substring(1));
var id = HttpUtility.ParseQueryString(uri.Query).Get("id");
if (id == null) {
continue;
}
r.Add(id);
}
return r;
}
[HttpPost]
[ProducesResponseType(StatusCodes.Status200OK)]
public async Task<ActionResult<ProgramOutputDto>> SetPlaylist() {
try {
string input;
using (StreamReader reader = new StreamReader(Request.Body)) {
input = await reader.ReadToEndAsync();
}
var dto = new DeserializerBuilder().Build().Deserialize<ProgramInputDto>(input);
StringBuilder output = new StringBuilder();
var e = SetupExecutor(output, extractItemIds(dto.InputLinks));
var r = e.eval(dto.Program).ToString();
return Ok(new ProgramOutputDto() {
FinalExpression = r,
Output = output.ToString(),
});
} catch (Exception ex) {
return Ok(new ProgramOutputDto() {
Traceback = ex.ToString(),
});
}
}
}
}

70
Jellyfin.Plugin.SmartPlaylist/Api/SmartCollectionController.cs
View file

@ -1,70 +0,0 @@
using System.Net.Mime;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.IO;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Providers;
using System.ComponentModel.DataAnnotations;
using MediaBrowser.Controller.Collections;
using MediaBrowser.Common.Api;
namespace Jellyfin.Plugin.SmartPlaylist.Api {
[ApiController]
[Authorize(Policy = Policies.RequiresElevation)]
[Route("SmartCollection")]
[Produces(MediaTypeNames.Application.Json)]
public class SmartCollectionController : ControllerBase {
private readonly ILogger _logger;
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IProviderManager _providerManager;
private readonly IFileSystem _fileSystem;
private readonly ICollectionManager _collectionManager;
private readonly IStore _store;
public SmartCollectionController(
ILogger<SmartCollectionController> logger,
ILibraryManager libraryManager,
IUserManager userManager,
IProviderManager providerManager,
IFileSystem fileSystem,
ICollectionManager collectionManager,
IServerApplicationPaths serverApplicationPaths
) {
_logger = logger;
_libraryManager = libraryManager;
_userManager = userManager;
_providerManager = providerManager;
_fileSystem = fileSystem;
_collectionManager = collectionManager;
_store = new Store(new SmartFileSystem(serverApplicationPaths));
}
[HttpGet]
[ProducesResponseType(StatusCodes.Status200OK)]
public async Task<ActionResult<IReadOnlyList<SmartCollectionDto>>> GetCollections() {
return Ok(await _store.GetAllSmartCollectionsAsync());
}
[HttpPost]
[ProducesResponseType(StatusCodes.Status201Created)]
public async Task<ActionResult> SetCollection([FromBody, Required] SmartCollectionDto smartCollection) {
await _store.SaveSmartCollectionAsync(smartCollection);
return Created();
}
[HttpDelete]
[Route("{smartCollectionId}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
public async Task<ActionResult> DeleteCollection([FromRoute, Required] SmartCollectionId smartCollectionId) {
_store.DeleteSmartCollectionById(smartCollectionId);
return NoContent();
}
}
}

69
Jellyfin.Plugin.SmartPlaylist/Api/SmartPlaylistController.cs
View file

@ -1,69 +0,0 @@
using System.Net.Mime;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.IO;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Playlists;
using MediaBrowser.Controller.Providers;
using System.ComponentModel.DataAnnotations;
using MediaBrowser.Common.Api;
namespace Jellyfin.Plugin.SmartPlaylist.Api {
[ApiController]
[Authorize(Policy = Policies.RequiresElevation)]
[Route("SmartPlaylist")]
[Produces(MediaTypeNames.Application.Json)]
public class SmartPlaylistController : ControllerBase {
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 SmartPlaylistController(
ILogger<SmartPlaylistController> 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 SmartFileSystem(serverApplicationPaths));
}
[HttpGet]
[ProducesResponseType(StatusCodes.Status200OK)]
public async Task<ActionResult<IReadOnlyList<SmartPlaylistDto>>> GetPlaylists() {
return Ok(await _store.GetAllSmartPlaylistsAsync());
}
[HttpPost]
[ProducesResponseType(StatusCodes.Status201Created)]
public async Task<ActionResult> SetPlaylist([FromBody, Required] SmartPlaylistDto smartPlaylist) {
await _store.SaveSmartPlaylistAsync(smartPlaylist);
return Created();
}
[HttpDelete]
[Route("{smartPlaylistId}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
public async Task<ActionResult> DeletePlaylist([FromRoute, Required] SmartPlaylistId smartPlaylistId) {
_store.DeleteSmartPlaylistById(smartPlaylistId);
return NoContent();
}
}
}

32
Jellyfin.Plugin.SmartPlaylist/Configuration/configPage.html
View file

@ -1,32 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>SmartPlaylist</title>
</head>
<body>
<div id="SmartPlaylistConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox" data-controller="__plugin/configPage.js">
<div data-role="content">
<div class="content-primary">
<form id="SmartPlaylistConfigForm">
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="InitialProgram">Initial Program</label>
<div class="fieldDescription">A program which can set up the environment</div>
<textarea id="InitialProgram" class="emby-input smartplaylist-monospace" name="InitialProgram" rows="16" cols="120"></textarea>
</div>
<div>
<button is="emby-button" type="submit" class="raised button-submit block emby-button">
<span>Save</span>
</button>
</div>
</form>
</div>
</div>
<style>
.smartplaylist-monospace {
font-family: monospace;
}
</style>
</div>
</body>
</html>

26
Jellyfin.Plugin.SmartPlaylist/Configuration/configPage.js
View file

@ -1,26 +0,0 @@
var SmartPlaylistConfig = {
pluginUniqueId: 'dd2326e3-4d3e-4bfc-80e6-28502c1131df'
};
document.querySelector('#SmartPlaylistConfigPage')
.addEventListener('pageshow', function() {
Dashboard.showLoadingMsg();
ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
document.querySelector('#InitialProgram').value = config.InitialProgram;
Dashboard.hideLoadingMsg();
});
});
document.querySelector('#SmartPlaylistConfigForm')
.addEventListener('submit', function(e) {
Dashboard.showLoadingMsg();
ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
config.InitialProgram = document.querySelector('#InitialProgram').value;
ApiClient.updatePluginConfiguration(SmartPlaylistConfig.pluginUniqueId, config).then(function (result) {
Dashboard.hideLoadingMsg();
});
});
e.preventDefault();
return false;
});

20
Jellyfin.Plugin.SmartPlaylist/Lisp/Compiler/Parser.cs
View file

@ -3,7 +3,7 @@ using Jellyfin.Plugin.SmartPlaylist.Lisp;
namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
public class Parser {
internal StringTokenStream _sts;
private StringTokenStream _sts;
public Parser(StringTokenStream tokens) {
_sts = tokens;
}
@ -29,18 +29,13 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
Debug.Assert(start.value == end.value);
Debug.Assert("\"".Contains(start.value));
string r = "";
bool exit_ok = false;
while (_sts.Available() > 0) {
Token<string> t = _sts.Get();
if (t.value == end.value) {
exit_ok = true;
break;
}
r += t.value;
}
if (!exit_ok) {
throw new ApplicationException($"Failed to parse string, are you missing the closing quotes? String is: {r}");
}
_sts.Commit();
return new String(r);
}
@ -74,16 +69,11 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
if (";".Contains(start.value)) {
return parse_comment(start, end);
}
if (end == null) {
throw new ApplicationException($"Don't know how to parse grouping starting with token '{start.value}'");
}
Debug.Assert(end != null);
IList<Expression> expressions = new List<Expression>();
bool exit_ok = false;
while (_sts.Available() > 0) {
Token<string> t = _sts.Get();
if (t.value == end.value) {
exit_ok = true;
_sts.Commit();
break;
}
@ -97,11 +87,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler {
_sts.Rewind(1);
expressions.Add(parse());
}
var r = Cons.FromList(expressions);
if (!exit_ok) {
throw new ApplicationException($"Failed to parse grouping, are you missing some closing braces? Parsed expressions: {r}");
}
return r;
return Cons.FromList(expressions);
}
Expression parse_atom(AtomToken at) {

89
Jellyfin.Plugin.SmartPlaylist/Lisp/Interpreter.cs
View file

@ -47,40 +47,6 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
this["any"] = e.eval("(lambda (fc l) (apply or (map fc l)))");
this["all"] = e.eval("(lambda (fc l) (apply and (map fc l)))");
this["append"] = e.eval("(lambda (l i) (if (null l) i (cons (car l) (append (cdr l) i))))");
this["reverse"] = e.eval(
"""
(lambda
(lst)
(let
(rev-helper
(lambda
(l acc)
(if
(null l)
acc
(rev-helper (cdr l) (cons (car l) acc)))))
(rev-helper lst '())))
"""
);
this["split"] = e.eval(
"""
(lambda
(lst n)
(if
(or (= n 0) (null lst))
(cons '() lst)
(let
(s (split (cdr lst) (- n 1)))
(cons (cons (car lst) (car s)) (cdr s)))))
"""
);
this["length"] = e.eval(
"""
(lambda
(lst n)
(if (null lst) n (length (cdr lst) (+ n 1))))
"""
);
this["qsort"] = e.eval(
"""
(lambda
@ -90,50 +56,25 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
(lambda
(list0)
(car list0)))
;(split
; (lambda
; (list0 pivot fc h0 h1)
; (cond
; ((null list0) (list list0 pivot fc h0 h1))
; ((fc (car list0) pivot) (split (cdr list0) pivot fc h0 (cons (car list0) h1)))
; (t (split (cdr list0) pivot fc (cons (car list0) h0) h1)))))
(split
(lambda
(list0 pivot fc h0 h1 heq)
(list0 pivot fc h0 h1)
(cond
((null list0) (list list0 pivot fc h0 h1 heq))
((and
(fc (car list0) pivot)
(fc pivot (car list0))) (split (cdr list0) pivot fc h0 h1 (cons (car list0) heq)))
((fc (car list0) pivot) (split (cdr list0) pivot fc h0 (cons (car list0) h1) heq))
((fc pivot (car list0)) (split (cdr list0) pivot fc (cons (car list0) h0) h1 heq))
((= (car list0) pivot) (split (cdr list0) pivot fc h0 h1 (cons (car list0) heq)))
(t (split (cdr list0) pivot fc h0 h1 heq)))))
;(sort
; (lambda
; (fc list0)
; (cond
; ((null list0) nil)
; ((null (cdr list0)) list0)
; (t
; (let*
; (halves (split list0 (getpivot list0) fc nil nil))
; (h0 (car (cdr (cdr (cdr halves)))))
; (h1 (car (cdr (cdr (cdr (cdr halves))))))
; (append (sort fc h0) (sort fc h1)))))))
((null list0) (list list0 pivot fc h0 h1))
((fc (car list0) pivot) (split (cdr list0) pivot fc h0 (cons (car list0) h1)))
(t (split (cdr list0) pivot fc (cons (car list0) h0) h1)))))
(sort
(lambda
(fc list0)
(begin t (cond
(cond
((null list0) nil)
((null (cdr list0)) list0)
(t
(let*
(halves (split list0 (getpivot list0) fc nil nil nil))
(halves (split list0 (getpivot list0) fc nil nil))
(h0 (car (cdr (cdr (cdr halves)))))
(h1 (car (cdr (cdr (cdr (cdr halves))))))
(heq (car (cdr (cdr (cdr (cdr (cdr halves)))))))
(append (append (sort fc h0) heq) (sort fc h1))))))))
(append (sort fc h0) (sort fc h1)))))))
(sort fc list00)))
"""
);
@ -338,7 +279,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
IList<Expression> r = new List<Expression>();
MethodInfo? mi = o.Value().GetType().GetMethod(s.Value(), l_types);
if (mi == null) {
throw new ApplicationException($"{o.Value()} ({o.Value().GetType()}) has no method {s.Value()}");
throw new ApplicationException($"{o.Value()} has no method {s.Value()}");
}
return Object.FromBase(mi.Invoke(o.Value(), l_));
@ -477,7 +418,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
Executor new_e = new Executor(new SubEnvironment(e.environment), e.builtins, e.builtinsLater);
foreach (var pair in args.SkipLast(1)) {
if (pair is not Cons pair_cons) {
throw new ApplicationException($"All arguments but the last have to be a list of two items, got {pair}");
throw new ApplicationException("No expression for let*");
}
Symbol refname = (Symbol) pair_cons.Item1;
Expression exp = ((Cons) pair_cons.Item2).Item1;
@ -490,7 +431,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
List<(Symbol, Expression)> vars = new List<(Symbol, Expression)>();
foreach (var pair in args.SkipLast(1)) {
if (pair is not Cons pair_cons) {
throw new ApplicationException($"All arguments but the last have to be a list of two items, got {pair}");
throw new ApplicationException("");
}
Symbol refname = (Symbol) pair_cons.Item1;
Expression exp_ = ((Cons) pair_cons.Item2).Item1;
@ -506,7 +447,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
if (args.First() is Cons proc_args_) { proc_args = proc_args_.ToList().Select(x => (Symbol) x); }
else if (args.First() == Boolean.FALSE) { proc_args = new List<Symbol>(); }
else {
throw new ApplicationException($"Expexted an argument list, but got {args.First()}");
throw new ApplicationException("");
}
return new Procedure(proc_args, args.Skip(1).First(), true);
}
@ -515,7 +456,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
if (args.First() is Cons proc_args_) { proc_args = proc_args_.ToList().Select(x => (Symbol) x); }
else if (args.First() == Boolean.FALSE) { proc_args = new List<Symbol>(); }
else {
throw new ApplicationException($"Expexted an argument list, but got {args.First()}");
throw new ApplicationException("");
}
return new Procedure(proc_args, args.Skip(1).First(), false);
}
@ -601,11 +542,7 @@ namespace Jellyfin.Plugin.SmartPlaylist.Lisp {
throw new ApplicationException($"Not handled case '{expression}'");
}
public Expression eval(Parser p) {
Expression r = eval(p.parse());
if (p._sts.Available() > 0) {
throw new ApplicationException($"Did not consume all tokens, remaining program is {string.Join(" ", p._sts.Remainder())}");
}
return r;
return eval(p.parse());
}
public Expression eval(StringTokenStream sts) {
return eval(new Parser(sts));

56
Jellyfin.Plugin.SmartPlaylist/Pages/lispPlayground.html
View file

@ -1,56 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>LispPlayground</title>
</head>
<body>
<div id="LispPlaygroundConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox" data-controller="__plugin/lispPlayground.js">
<div data-role="content">
<div class="content-primary">
<form id="LispPlaygroundConfigForm">
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="LispPlaygroundInputLinks">Input Items</label>
<div class="fieldDescription">
Items which should be given to the filter program, one link per line.
This list is provided to the program in the
<code>*items*</code> variable.<br>
Hint: Just copy the link to the media item,
it should contain a <code>id</code> in
the query part of the URL's
fragment.<br>
Example:
<code>https://jellyfin.example.com/web/#/details?id=9f63ee779963588ed2ad94d37d6abe4e&serverId=dc0683d7a413473eb8246d21eaea2f99</code><br>
<textarea id="LispPlaygroundInputLinks" class="emby-input smartplayground-monospace" name="InputLinks" rows="6" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="LispPlaygroundEditProgram">Program</label>
<div class="fieldDescription">A program which should return <code>t</code> or <code>nil</code> to include or exclude the provided <code>item</code>.</div>
<textarea id="LispPlaygroundEditProgram" class="emby-input smartplayground-monospace" name="Program" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="LispPlaygroundOutput">Output</label>
<div class="fieldDescription">The output of the program.</div>
<textarea id="LispPlaygroundOutput" class="emby-input smartplayground-monospace" name="Output" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="LispPlaygroundReturn">Final expression</label>
<div class="fieldDescription">The final expression the program has been reduced to.</div>
<textarea id="LispPlaygroundReturn" class="emby-input smartplayground-monospace" name="Output" rows="1" cols="120"></textarea>
</div>
<div>
<button is="emby-button" type="submit" class="raised button-submit block emby-button">
<span>Run</span>
</button>
</div>
</form>
</div>
</div>
<style>
.smartplayground-monospace {
font-family: monospace;
}
</style>
</div>
</body>
</html>

50
Jellyfin.Plugin.SmartPlaylist/Pages/lispPlayground.js
View file

@ -1,50 +0,0 @@
function fillForm(o) {
const output = document.querySelector('#LispPlaygroundOutput');
const return_ = document.querySelector('#LispPlaygroundReturn');
output.value = (o.hasOwnProperty("Output")) ? o.Output : o.Traceback;
return_.value = (o.hasOwnProperty("FinalExpression")) ? o.FinalExpression : '';
}
ApiClient.runLispProgram = function (inputLinks, program) {
const url = ApiClient.getUrl('LispPlayground');
return this.ajax({
type: 'POST',
url: url,
dataType: 'json',
contentType: 'application/json; charset=UTF-8',
data: JSON.stringify({
InputLinks: inputLinks,
Program: program,
}),
});
}
function initial_load() {
Dashboard.showLoadingMsg();
Dashboard.hideLoadingMsg();
}
export default function (view, params) {
view.addEventListener('viewshow', function() {
initial_load(null);
});
view.addEventListener('viewhide', function (_e) {});
view.addEventListener('viewdestroy', function (_e) {});
document.querySelector('#LispPlaygroundConfigPage')
.addEventListener('pageshow', function() {
initial_load();
});
document.querySelector('#LispPlaygroundConfigForm')
.addEventListener('submit', function (e) {
e.preventDefault();
Dashboard.showLoadingMsg();
const editInputLinks = document.querySelector('#LispPlaygroundInputLinks');
const editProgram = document.querySelector('#LispPlaygroundEditProgram');
ApiClient.runLispProgram(editInputLinks.value, editProgram.value).then(function (r) {
fillForm(r);
Dashboard.hideLoadingMsg();
});
});
}

54
Jellyfin.Plugin.SmartPlaylist/Pages/smartCollections.html
View file

@ -1,54 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>SmartCollection</title>
</head>
<body>
<div id="SmartCollectionConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox" data-controller="__plugin/smartCollections.js">
<div data-role="content">
<div class="content-primary">
<form id="SmartCollectionConfigForm">
<div>
<label class="inputLabel inputLabelUnfocused" for="SmartcollectionSelection">Choose a collection to edit</label>
<select id="SmartcollectionSelection" class="emby-select">
</select>
</div>
<div>
<label class="inputLabel inputLabelUnfocused" for="SmartcollectionEditName">Name</label>
<input id="SmartcollectionEditName" type="text" class="emby-input"/>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartcollectionEditProgram">Program</label>
<div class="fieldDescription">A program which should return <code>t</code> or <code>nil</code> to include or exclude the provided <code>item</code>.</div>
<textarea id="SmartcollectionEditProgram" class="emby-input smartcollection-monospace" name="Program" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartcollectionEditSortProgram">Sort Program</label>
<div class="fieldDescription">A program which should return a list of items to include in the collection, sorted however you like.</div>
<textarea id="SmartcollectionEditSortProgram" class="emby-input smartcollection-monospace" name="SortProgram" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartcollectionEditEnabled">Enabled</label>
<div class="fieldDescription">Is the collection enabled.</div>
<input id="SmartcollectionEditEnabled" type="checkbox" class="emby-input"/>
</div>
<div>
<button is="emby-button" type="submit" class="raised button-submit block emby-button">
<span>Save</span>
</button>
<button is="emby-button" type="reset" class="raised button-reset block emby-button">
<span>Delete</span>
</button>
</div>
</form>
</div>
</div>
<style>
.smartcollection-monospace {
font-family: monospace;
}
</style>
</div>
</body>
</html>

134
Jellyfin.Plugin.SmartPlaylist/Pages/smartCollections.js
View file

@ -1,134 +0,0 @@
var COLLECTIONS = [
{
Id: 'My New Smartcollection',
Name: 'My New Smartcollection',
Program: 'nil',
SortProgram: '(begin *items*)',
CollectionId: '00000000000000000000000000000000',
Enabled: true,
}
];
function fillForm(collection) {
const editName = document.querySelector('#SmartcollectionEditName');
const editProgram = document.querySelector('#SmartcollectionEditProgram');
const editSortProgram = document.querySelector('#SmartcollectionEditSortProgram');
const editEnabled = document.querySelector('#SmartcollectionEditEnabled');
editName.value = collection.Name;
editProgram.value = collection.Program;
editSortProgram.value = collection.SortProgram;
editEnabled.checked = collection.Enabled;
}
function fillCollectionSelect(collections) {
const selection = document.querySelector('#SmartcollectionSelection');
selection.innerHTML = '';
var o = document.createElement('option');
o.value = null;
o.innerHTML = 'Create new collection ...';
selection.appendChild(o);
for (const i of collections.slice(1)) {
var o = document.createElement('option');
o.value = i.Id;
o.innerHTML = i.Name;
selection.appendChild(o);
}
}
function jsonFromForm(collectionId) {
const editName = document.querySelector('#SmartcollectionEditName');
const editProgram = document.querySelector('#SmartcollectionEditProgram');
const editSortProgram = document.querySelector('#SmartcollectionEditSortProgram');
const editEnabled = document.querySelector('#SmartcollectionEditEnabled');
if (collectionId === null) {
collectionId = '00000000000000000000000000000000'
}
return {
Id: editName.value,
Name: editName.value,
Program: editProgram.value,
SortProgram: editSortProgram.value,
CollectionId: collectionId,
Enabled: editEnabled.checked,
};
}
ApiClient.getSmartCollections = function () {
const url = ApiClient.getUrl('SmartCollection');
return this.ajax({
type: 'GET',
url: url,
dataType: 'json',
});
}
ApiClient.setSmartCollection = function (c) {
const url = ApiClient.getUrl('SmartCollection');
return this.ajax({
type: 'POST',
url: url,
dataType: 'json',
contentType: 'application/json; charset=UTF-8',
data: JSON.stringify(c),
});
}
ApiClient.deleteSmartCollection = function (id) {
const url = ApiClient.getUrl(`SmartCollection/${id}`)
return this.ajax({
type: 'DELETE',
url: url,
});
}
function initial_load(selectedId) {
Dashboard.showLoadingMsg();
ApiClient.getSmartCollections().then(function (collections) {
COLLECTIONS = [COLLECTIONS[0]].concat(collections);
const selection = document.querySelector('#SmartcollectionSelection');
fillCollectionSelect(COLLECTIONS);
if (selectedId === null) {
selection.selectedIndex = 0;
} else {
selection.selectedIndex = COLLECTIONS.map(x => x.Id).indexOf(selectedId);
}
fillForm(COLLECTIONS[selection.selectedIndex]);
Dashboard.hideLoadingMsg();
});
}
export default function (view, params) {
view.addEventListener('viewshow', function() {
initial_load(null);
});
view.addEventListener('viewhide', function (_e) {});
view.addEventListener('viewdestroy', function (_e) {});
document.querySelector('#SmartcollectionSelection')
.addEventListener('change', function() {
const selection = document.querySelector('#SmartcollectionSelection');
fillForm(COLLECTIONS[selection.selectedIndex]);
});
document.querySelector('#SmartCollectionConfigForm')
.addEventListener('submit', function (e) {
Dashboard.showLoadingMsg();
const selection = document.querySelector('#SmartcollectionSelection');
const selectedId = COLLECTIONS[selection.selectedIndex].Id;
ApiClient.setSmartCollection(jsonFromForm(COLLECTIONS[selection.selectedIndex].CollectionId)).then(function () {
initial_load(selectedId);
});
e.preventDefault();
});
document.querySelector('#SmartCollectionConfigForm')
.addEventListener('reset', function (e) {
Dashboard.showLoadingMsg();
const selection = document.querySelector('#SmartcollectionSelection');
const selectedId = COLLECTIONS[selection.selectedIndex].Id;
ApiClient.deleteSmartCollection(selectedId).then(function () {
initial_load(null);
});
e.preventDefault();
});
}

60
Jellyfin.Plugin.SmartPlaylist/Pages/smartPlaylists.html
View file

@ -1,60 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>SmartPlaylist</title>
</head>
<body>
<div id="SmartPlaylistConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox" data-controller="__plugin/smartPlaylists.js">
<div data-role="content">
<div class="content-primary">
<form id="SmartPlaylistConfigForm">
<div>
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistSelection">Choose a playlist to edit</label>
<select id="SmartplaylistSelection" class="emby-select">
</select>
</div>
<div>
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditName">Name</label>
<input id="SmartplaylistEditName" type="text" class="emby-input"/>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditProgram">Program</label>
<div class="fieldDescription">A program which should return <code>t</code> or <code>nil</code> to include or exclude the provided <code>item</code>.</div>
<textarea id="SmartplaylistEditProgram" class="emby-input smartplaylist-monospace" name="Program" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditSortProgram">Sort Program</label>
<div class="fieldDescription">A program which should return a list of items to include in the playlist, sorted however you like.</div>
<textarea id="SmartplaylistEditSortProgram" class="emby-input smartplaylist-monospace" name="SortProgram" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditUsers">Users</label>
<div class="fieldDescription">Which users should get access to the playlist.</div>
<select multiple id="SmartplaylistEditUsers" class="emby-select">
</select>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditEnabled">Enabled</label>
<div class="fieldDescription">Is the playlist enabled.</div>
<input id="SmartplaylistEditEnabled" type="checkbox" class="emby-input"/>
</div>
<div>
<button is="emby-button" type="submit" class="raised button-submit block emby-button">
<span>Save</span>
</button>
<button is="emby-button" type="reset" class="raised button-reset block emby-button">
<span>Delete</span>
</button>
</div>
</form>
</div>
</div>
<style>
.smartplaylist-monospace {
font-family: monospace;
}
</style>
</div>
</body>
</html>

160
Jellyfin.Plugin.SmartPlaylist/Pages/smartPlaylists.js
View file

@ -1,160 +0,0 @@
var PLAYLISTS = [
{
Id: 'My New Smartplaylist',
Name: 'My New Smartplaylist',
Program: '(is-favourite)',
SortProgram: '(begin *items*)',
Playlists: [],
Enabled: true,
}
];
var USERS = [];
function fillForm(playlist, users) {
const editName = document.querySelector('#SmartplaylistEditName');
const editProgram = document.querySelector('#SmartplaylistEditProgram');
const editSortProgram = document.querySelector('#SmartplaylistEditSortProgram');
const editUsers = document.querySelector('#SmartplaylistEditUsers');
const editEnabled = document.querySelector('#SmartplaylistEditEnabled');
editName.value = playlist.Name;
editProgram.value = playlist.Program;
editSortProgram.value = playlist.SortProgram;
editUsers.innerHTML = '';
var added_users = []
for (const p of playlist.Playlists) {
var o = document.createElement('option');
o.value = btoa(JSON.stringify(p));
o.innerHTML = users.filter(u => u.Id == p.UserId).map(u => u.Name)[0];
o.setAttribute('selected', 'selected');
editUsers.appendChild(o);
added_users.push(p.UserId);
}
for (const u of users) {
if (added_users.includes(u.Id)) {
continue;
}
var o = document.createElement('option');
o.value = btoa(JSON.stringify({
'PlaylistId': '00000000000000000000000000000000',
'UserId': u.Id,
}));
o.innerHTML = u.Name;
editUsers.appendChild(o);
}
editEnabled.checked = playlist.Enabled;
}
function fillPlaylistSelect(playlists) {
const selection = document.querySelector('#SmartplaylistSelection');
selection.innerHTML = '';
var o = document.createElement('option');
o.value = null;
o.innerHTML = 'Create new playlist ...';
selection.appendChild(o);
for (const i of playlists.slice(1)) {
var o = document.createElement('option');
o.value = i.Id;
o.innerHTML = i.Name;
selection.appendChild(o);
}
}
function jsonFromForm() {
const editName = document.querySelector('#SmartplaylistEditName');
const editProgram = document.querySelector('#SmartplaylistEditProgram');
const editSortProgram = document.querySelector('#SmartplaylistEditSortProgram');
const editUsers = document.querySelector('#SmartplaylistEditUsers');
const editEnabled = document.querySelector('#SmartplaylistEditEnabled');
return {
Id: editName.value,
Name: editName.value,
Program: editProgram.value,
SortProgram: editSortProgram.value,
Playlists: Array.from(editUsers.options).filter((x) => x.selected).map(x => JSON.parse(atob(x.value))),
Enabled: editEnabled.checked,
};
}
ApiClient.getSmartPlaylists = function () {
const url = ApiClient.getUrl('SmartPlaylist');
return this.ajax({
type: 'GET',
url: url,
dataType: 'json',
});
}
ApiClient.setSmartPlaylist = function (p) {
const url = ApiClient.getUrl('SmartPlaylist');
return this.ajax({
type: 'POST',
url: url,
dataType: 'json',
contentType: 'application/json; charset=UTF-8',
data: JSON.stringify(p),
});
}
ApiClient.deleteSmartPlaylist = function (id) {
const url = ApiClient.getUrl(`SmartPlaylist/${id}`)
return this.ajax({
type: 'DELETE',
url: url,
});
}
function initial_load(selectedId) {
Dashboard.showLoadingMsg();
ApiClient.getSmartPlaylists().then(function (playlists) {
PLAYLISTS = [PLAYLISTS[0]].concat(playlists);
ApiClient.getUsers().then(function (users) {
USERS = users;
const selection = document.querySelector('#SmartplaylistSelection');
fillPlaylistSelect(PLAYLISTS);
if (selectedId === null) {
selection.selectedIndex = 0;
} else {
selection.selectedIndex = PLAYLISTS.map(x => x.Id).indexOf(selectedId);
}
fillForm(PLAYLISTS[selection.selectedIndex], USERS);
Dashboard.hideLoadingMsg();
});
});
}
export default function (view, params) {
view.addEventListener('viewshow', function() {
initial_load(null);
});
view.addEventListener('viewhide', function (_e) {});
view.addEventListener('viewdestroy', function (_e) {});
document.querySelector('#SmartplaylistSelection')
.addEventListener('change', function() {
const selection = document.querySelector('#SmartplaylistSelection');
fillForm(PLAYLISTS[selection.selectedIndex], USERS);
});
document.querySelector('#SmartPlaylistConfigForm')
.addEventListener('submit', function (e) {
Dashboard.showLoadingMsg();
const selection = document.querySelector('#SmartplaylistSelection');
const selectedId = PLAYLISTS[selection.selectedIndex].Id;
ApiClient.setSmartPlaylist(jsonFromForm()).then(function () {
initial_load(selectedId);
});
e.preventDefault();
});
document.querySelector('#SmartPlaylistConfigForm')
.addEventListener('reset', function (e) {
Dashboard.showLoadingMsg();
const selection = document.querySelector('#SmartplaylistSelection');
const selectedId = PLAYLISTS[selection.selectedIndex].Id;
ApiClient.deleteSmartPlaylist(selectedId).then(function () {
initial_load(null);
});
e.preventDefault();
});
}

38
Jellyfin.Plugin.SmartPlaylist/Plugin.cs
View file

@ -27,42 +27,8 @@ namespace Jellyfin.Plugin.SmartPlaylist {
return new[] {
new PluginPageInfo {
Name = this.Name,
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Configuration.configPage.html", GetType().Namespace),
},
new PluginPageInfo {
Name = "configPage.js",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Configuration.configPage.js", GetType().Namespace),
},
new PluginPageInfo {
Name = "Smart Playlists",
DisplayName = "Smart Playlists",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.smartPlaylists.html", GetType().Namespace),
EnableInMainMenu = true,
},
new PluginPageInfo {
Name = "smartPlaylists.js",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.smartPlaylists.js", GetType().Namespace),
},
new PluginPageInfo {
Name = "Smart Collections",
DisplayName = "Smart Collections",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.smartCollections.html", GetType().Namespace),
EnableInMainMenu = true,
},
new PluginPageInfo {
Name = "smartCollections.js",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.smartCollections.js", GetType().Namespace),
},
new PluginPageInfo {
Name = "Lisp Playground",
DisplayName = "Lisp Playground",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.lispPlayground.html", GetType().Namespace),
EnableInMainMenu = true,
},
new PluginPageInfo {
Name = "lispPlayground.js",
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Pages.lispPlayground.js", GetType().Namespace),
},
EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.configPage.html", GetType().Namespace)
}
};
}
}

24
Jellyfin.Plugin.SmartPlaylist/Configuration/PluginConfiguration.cs → Jellyfin.Plugin.SmartPlaylist/PluginConfiguration.cs
View file

@ -1,4 +1,5 @@
using MediaBrowser.Model.Plugins;
using MediaBrowser.Controller;
namespace Jellyfin.Plugin.SmartPlaylist {
public class PluginConfiguration : BasePluginConfiguration {
@ -42,7 +43,30 @@ namespace Jellyfin.Plugin.SmartPlaylist {
(define find-parent (lambda (typename) (invoke-generic *item* "FindParent" nil (list typename))))
(define find-artist (lambda nil (find-parent "MediaBrowser.Controller.Entities.Audio.MusicArtist, MediaBrowser.Controller"))))
""";
store = new Store(new SmartPlaylistFileSystem(Plugin.Instance.ServerApplicationPaths));
}
private Store store { get; set; }
public string InitialProgram { get; set; }
public SmartPlaylistDto[] Playlists {
get {
return store.GetAllSmartPlaylistsAsync().GetAwaiter().GetResult();
}
set {
var existing = store.GetAllSmartPlaylistsAsync().GetAwaiter().GetResult().Select(x => x.Id).ToList();
foreach (var p in value) {
existing.Remove(p.Id);
store.SaveSmartPlaylistAsync(p).GetAwaiter().GetResult();
}
foreach (var p in existing) {
store.DeleteSmartPlaylistById(p);
}
}
}
public object[][] Users {
get {
return Plugin.Instance.UserManager.Users.Select(x => new object[]{x.Id, x.Username}).ToArray();
}
set { }
}
}
}

81
Jellyfin.Plugin.SmartPlaylist/ScheduledTasks/Common.cs
View file

@ -1,81 +0,0 @@
using Microsoft.Extensions.Logging;
using Jellyfin.Data.Entities;
using Jellyfin.Data.Enums;
using MediaBrowser.Controller.Entities;
using Jellyfin.Plugin.SmartPlaylist.Lisp;
using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
public class Common {
public static readonly BaseItemKind[] AvailableFilterItems = {
BaseItemKind.Audio,
BaseItemKind.AudioBook,
BaseItemKind.Book,
BaseItemKind.BoxSet,
BaseItemKind.Channel,
// BaseItemKind.ChannelFolderItem,
// BaseItemKind.CollectionFolder,
BaseItemKind.Episode,
// BaseItemKind.Folder,
BaseItemKind.Genre,
// BaseItemKind.ManualPlaylistsFolder,
BaseItemKind.Movie,
BaseItemKind.LiveTvChannel,
BaseItemKind.LiveTvProgram,
BaseItemKind.MusicAlbum,
BaseItemKind.MusicArtist,
BaseItemKind.MusicGenre,
BaseItemKind.MusicVideo,
BaseItemKind.Person,
BaseItemKind.Photo,
BaseItemKind.PhotoAlbum,
BaseItemKind.Playlist,
// BaseItemKind.PlaylistsFolder,
BaseItemKind.Program,
BaseItemKind.Recording,
BaseItemKind.Season,
BaseItemKind.Series,
BaseItemKind.Studio,
BaseItemKind.Trailer,
BaseItemKind.TvChannel,
BaseItemKind.TvProgram,
BaseItemKind.UserView,
BaseItemKind.Video,
BaseItemKind.Year
};
public readonly ILogger _logger;
public Common(ILogger logger) {
_logger = logger;
}
public Executor SetupExecutor() {
var env = new DefaultEnvironment();
var executor = new Executor(env);
executor.builtins["logd"] = (x) => {
_logger.LogDebug(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["logi"] = (x) => {
_logger.LogInformation(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["logw"] = (x) => {
_logger.LogWarning(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
executor.builtins["loge"] = (x) => {
_logger.LogError(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp.Boolean.TRUE;
};
if (Plugin.Instance is not null) {
executor.eval(Plugin.Instance.Configuration.InitialProgram);
} else {
throw new ApplicationException("Plugin Instance is not yet initialized");
}
return executor;
}
}
}

152
Jellyfin.Plugin.SmartPlaylist/ScheduledTasks/GenerateCollection.cs
View file

@ -1,152 +0,0 @@
using MediaBrowser.Model.Tasks;
using Microsoft.Extensions.Logging;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Collections;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.IO;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using Jellyfin.Data.Entities;
using Jellyfin.Plugin.SmartPlaylist.Lisp;
using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
public class GenerateCollection: Common, IScheduledTask {
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IProviderManager _providerManager;
private readonly IFileSystem _fileSystem;
private readonly ICollectionManager _collectionManager;
private readonly IStore _store;
public GenerateCollection(
ILogger<Plugin> logger,
ILibraryManager libraryManager,
IUserManager userManager,
IProviderManager providerManager,
IFileSystem fileSystem,
ICollectionManager collectionManager,
IServerApplicationPaths serverApplicationPaths
) : base(logger) {
_libraryManager = libraryManager;
_userManager = userManager;
_providerManager = providerManager;
_fileSystem = fileSystem;
_collectionManager = collectionManager;
_store = new Store(new SmartFileSystem(serverApplicationPaths));
}
public string Category => "Library";
public string Name => "(re)generate Smart Collections";
public string Description => "Generate or regenerate all Smart Collections";
public string Key => nameof(GenerateCollection);
public IEnumerable<TaskTriggerInfo> GetDefaultTriggers() {
return new[] {
new TaskTriggerInfo {
IntervalTicks = TimeSpan.FromHours(24).Ticks,
Type = TaskTriggerInfo.TriggerInterval,
}
};
}
private async Task<CollectionId> CreateNewCollection(string name) {
_logger.LogDebug("Creating collection '{0}'", name);
return (await _collectionManager.CreateCollectionAsync(
new CollectionCreationOptions {
Name = name,
}
)).Id;
}
public IEnumerable<Guid> FilterCollectionItems(IEnumerable<BaseItem> items, User? user, string name, string program, string sortProgram) {
List<BaseItem> results = new List<BaseItem>();
Expression expression = new Parser(StringTokenStream.generate(program)).parse(); // parse here, so that we don't repeat the work for each item
Executor executor = SetupExecutor();
executor.environment.Set("*user*", Lisp.Object.FromBase(user));
foreach (var i in items) {
executor.environment.Set("*item*", Lisp.Object.FromBase(i));
try {
var r = executor.eval(expression);
_logger.LogTrace("Item {0} evaluated to {1}", i, r.ToString());
if ((r is not Lisp.Boolean r_bool) || (r_bool.Value())) {
_logger.LogDebug("Added '{0}' to Smart Collection {1}", i, name);
results.Add(i);
}
} catch (Exception e) {
_logger.LogError("Program crashed on item {0}:\n{1}", i.Id, expression.ToString());
_logger.LogError("Environment:\n{0}", executor.environment);
_logger.LogError("Traceback:\n{0}", e.ToString());
}
}
executor = SetupExecutor();
executor.environment.Set("*user*", Lisp.Object.FromBase(user));
executor.environment.Set("*items*", Lisp.Object.FromBase(results));
results = new List<BaseItem>();
var sort_result = executor.eval(sortProgram);
if (sort_result is Cons sorted_items) {
foreach (var i in sorted_items.ToList()) {
if (i is Lisp.Object iObject && iObject.Value() is BaseItem iBaseItem) {
results.Add(iBaseItem);
continue;
}
throw new ApplicationException($"Returned sorted list does contain unexpected items, got {i}");
}
} else if (sort_result == Lisp.Boolean.FALSE) {
} else {
throw new ApplicationException($"Did not return a list of items, returned {sort_result}");
}
return results.Select(x => x.Id);
}
private IEnumerable<BaseItem> GetAllMedia() {
var req = new InternalItemsQuery() {
IncludeItemTypes = AvailableFilterItems,
Recursive = true,
};
return _libraryManager.GetItemsResult(req).Items;
}
public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken) {
_logger.LogInformation("Started regenerate Smart Collections");
_logger.LogDebug("Loaded Assemblies:");
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies()) {
_logger.LogDebug("- {0}", asm);
}
var i = 0;
var smartCollections = await _store.GetAllSmartCollectionsAsync();
foreach (SmartCollectionDto dto in smartCollections) {
if (!dto.Enabled) {
progress.Report(100 * ((double)i)/smartCollections.Count());
i += 1;
continue;
}
if (dto.CollectionId == Guid.Empty) {
dto.CollectionId = await CreateNewCollection(dto.Name);
_store.DeleteSmartCollection(dto); // delete in case the file was not the canonical one.
await _store.SaveSmartCollectionAsync(dto);
}
var insertItems = FilterCollectionItems(GetAllMedia(), null, dto.Name, dto.Program, dto.SortProgram).ToArray();
await ClearCollection(dto.CollectionId);
await _collectionManager.AddToCollectionAsync(dto.CollectionId, insertItems);
i += 1;
progress.Report(100 * ((double)i)/smartCollections.Count());
}
}
private async Task ClearCollection(CollectionId collectionId) {
// fuck if I know
if (_libraryManager.GetItemById(collectionId) is not BoxSet collection) {
throw new ArgumentException("");
}
var existingItems = collection.LinkedChildren.Select(x => x.ItemId).Where(x => x != null).Select(x => x.Value);
await _collectionManager.RemoveFromCollectionAsync(collectionId, existingItems);
}
}
}

104
Jellyfin.Plugin.SmartPlaylist/ScheduledTasks/GeneratePlaylist.cs
View file

@ -7,17 +7,58 @@ using MediaBrowser.Controller.Playlists;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.IO;
using Jellyfin.Data.Entities;
using Jellyfin.Data.Enums;
using MediaBrowser.Model.Entities;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Model.Playlists;
using Jellyfin.Plugin.SmartPlaylist.Lisp;
using Jellyfin.Plugin.SmartPlaylist.Lisp.Compiler;
using Lisp_Object = Jellyfin.Plugin.SmartPlaylist.Lisp.Object;
using Lisp_Boolean = Jellyfin.Plugin.SmartPlaylist.Lisp.Boolean;
namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
public class GeneratePlaylist : Common, IScheduledTask {
public class GeneratePlaylist : IScheduledTask {
public static readonly BaseItemKind[] AvailableFilterItems = {
BaseItemKind.Audio,
BaseItemKind.AudioBook,
BaseItemKind.Book,
BaseItemKind.BoxSet,
BaseItemKind.Channel,
// BaseItemKind.ChannelFolderItem,
// BaseItemKind.CollectionFolder,
BaseItemKind.Episode,
// BaseItemKind.Folder,
BaseItemKind.Genre,
// BaseItemKind.ManualPlaylistsFolder,
BaseItemKind.Movie,
BaseItemKind.LiveTvChannel,
BaseItemKind.LiveTvProgram,
BaseItemKind.MusicAlbum,
BaseItemKind.MusicArtist,
BaseItemKind.MusicGenre,
BaseItemKind.MusicVideo,
BaseItemKind.Person,
BaseItemKind.Photo,
BaseItemKind.PhotoAlbum,
BaseItemKind.Playlist,
// BaseItemKind.PlaylistsFolder,
BaseItemKind.Program,
BaseItemKind.Recording,
BaseItemKind.Season,
BaseItemKind.Series,
BaseItemKind.Studio,
BaseItemKind.Trailer,
BaseItemKind.TvChannel,
BaseItemKind.TvProgram,
BaseItemKind.UserView,
BaseItemKind.Video,
BaseItemKind.Year
};
private readonly ILogger _logger;
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IProviderManager _providerManager;
@ -34,14 +75,15 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
IFileSystem fileSystem,
IPlaylistManager playlistManager,
IServerApplicationPaths serverApplicationPaths
) : base(logger) {
) {
_logger = logger;
_libraryManager = libraryManager;
_userManager = userManager;
_providerManager = providerManager;
_fileSystem = fileSystem;
_playlistManager = playlistManager;
_store = new Store(new SmartFileSystem(serverApplicationPaths));
_store = new Store(new SmartPlaylistFileSystem(serverApplicationPaths));
}
public string Category => "Library";
@ -70,41 +112,62 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
return playlistGuid;
}
private Executor SetupExecutor() {
var env = new DefaultEnvironment();
var executor = new Executor(env);
executor.builtins["logd"] = (x) => {
_logger.LogDebug(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp_Boolean.TRUE;
};
executor.builtins["logi"] = (x) => {
_logger.LogInformation(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp_Boolean.TRUE;
};
executor.builtins["logw"] = (x) => {
_logger.LogWarning(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp_Boolean.TRUE;
};
executor.builtins["loge"] = (x) => {
_logger.LogError(((Lisp.String)x.First()).Value(), x.Skip(1).ToArray());
return Lisp_Boolean.TRUE;
};
if (Plugin.Instance is not null) {
executor.eval(Plugin.Instance.Configuration.InitialProgram);
} else {
throw new ApplicationException("Plugin Instance is not yet initialized");
}
return executor;
}
private IEnumerable<Guid> FilterPlaylistItems(IEnumerable<BaseItem> items, User user, SmartPlaylistDto smartPlaylist) {
List<BaseItem> results = new List<BaseItem>();
Expression expression = new Parser(StringTokenStream.generate(smartPlaylist.Program)).parse(); // parse here, so that we don't repeat the work for each item
Executor executor = SetupExecutor();
executor.environment.Set("*user*", Lisp.Object.FromBase(user));
executor.environment.Set("*user*", Lisp_Object.FromBase(user));
foreach (var i in items) {
executor.environment.Set("*item*", Lisp.Object.FromBase(i));
try {
var r = executor.eval(expression);
_logger.LogTrace("Item {0} evaluated to {1}", i, r.ToString());
if ((r is not Lisp.Boolean r_bool) || (r_bool.Value())) {
_logger.LogDebug("Added '{0}' to Smart Playlist {1}", i, smartPlaylist.Name);
results.Add(i);
}
} catch (Exception e) {
_logger.LogError("Program crashed on item {0}:\n{1}", i.Id, expression.ToString());
_logger.LogError("Environment:\n{0}", executor.environment);
_logger.LogError("Traceback:\n{0}", e.ToString());
executor.environment.Set("*item*", Lisp_Object.FromBase(i));
var r = executor.eval(expression);
_logger.LogTrace("Item {0} evaluated to {1}", i, r.ToString());
if ((r is not Lisp_Boolean r_bool) || (r_bool.Value())) {
_logger.LogDebug("Added '{0}' to Smart Playlist {1}", i, smartPlaylist.Name);
results.Add(i);
}
}
executor = SetupExecutor();
executor.environment.Set("*user*", Lisp.Object.FromBase(user));
executor.environment.Set("*items*", Lisp.Object.FromBase(results));
executor.environment.Set("*user*", Lisp_Object.FromBase(user));
executor.environment.Set("*items*", Lisp_Object.FromBase(results));
results = new List<BaseItem>();
var sort_result = executor.eval(smartPlaylist.SortProgram);
if (sort_result is Cons sorted_items) {
foreach (var i in sorted_items.ToList()) {
if (i is Lisp.Object iObject && iObject.Value() is BaseItem iBaseItem) {
if (i is Lisp_Object iObject && iObject.Value() is BaseItem iBaseItem) {
results.Add(iBaseItem);
continue;
}
throw new ApplicationException($"Returned sorted list does contain unexpected items, got {i}");
}
} else if (sort_result == Lisp.Boolean.FALSE) {
} else if (sort_result == Lisp_Boolean.FALSE) {
} else {
throw new ApplicationException($"Did not return a list of items, returned {sort_result}");
}
@ -130,7 +193,6 @@ namespace Jellyfin.Plugin.SmartPlaylist.ScheduledTasks {
foreach (SmartPlaylistDto dto in all_playlists) {
if (!dto.Enabled) {
i += 1;
progress.Report(100 * ((double)i)/all_playlists.Count());
continue;
}
var changedDto = false;

11
Jellyfin.Plugin.SmartPlaylist/SmartContainerDto.cs → Jellyfin.Plugin.SmartPlaylist/SmartPlaylistDto.cs
View file

@ -108,15 +108,4 @@ namespace Jellyfin.Plugin.SmartPlaylist {
info.AddValue("Enabled", Enabled);
}
}
[Serializable]
public class SmartCollectionDto {
public SmartCollectionId Id { get; set; }
public CollectionId CollectionId { get; set; }
public string Name { get; set; }
public string Program { get; set; }
public string SortProgram { get; set; }
public string? Filename { get; set; }
public bool Enabled { get; set; }
}
}

61
Jellyfin.Plugin.SmartPlaylist/SmartPlaylistFileSystem.cs
View file

@ -3,61 +3,34 @@ using MediaBrowser.Controller;
namespace Jellyfin.Plugin.SmartPlaylist {
public interface ISmartPlaylistFileSystem {
public string PlaylistStoragePath { get; }
public string CollectionStoragePath { get; }
public string GetSmartPlaylistFilePath(string id);
public string FindSmartPlaylistFilePath(string id);
public string StoragePath { get; }
public string GetSmartPlaylistFilePath(SmartPlaylistId smartPlaylistId);
public string FindSmartPlaylistFilePath(SmartPlaylistId smartPlaylistId);
public string[] FindAllSmartPlaylistFilePaths();
public string GetSmartCollectionFilePath(string id);
public string FindSmartCollectionFilePath(string id);
public string[] FindAllSmartCollectionFilePaths();
}
public class SmartFileSystem : ISmartPlaylistFileSystem {
public SmartFileSystem(IServerApplicationPaths serverApplicationPaths) {
PlaylistStoragePath = Path.Combine(serverApplicationPaths.DataPath, "smartplaylists");
CollectionStoragePath = Path.Combine(serverApplicationPaths.DataPath, "smartcollections");
if (!Directory.Exists(PlaylistStoragePath)) { Directory.CreateDirectory(PlaylistStoragePath); }
if (!Directory.Exists(CollectionStoragePath)) { Directory.CreateDirectory(CollectionStoragePath); }
public class SmartPlaylistFileSystem : ISmartPlaylistFileSystem {
public SmartPlaylistFileSystem(IServerApplicationPaths serverApplicationPaths) {
StoragePath = Path.Combine(serverApplicationPaths.DataPath, "smartplaylists");
if (!Directory.Exists(StoragePath)) { Directory.CreateDirectory(StoragePath); }
}
public string PlaylistStoragePath { get; }
public string CollectionStoragePath { get; }
public string GetSmartPlaylistFilePath(string id) {
return Path.Combine(PlaylistStoragePath, $"{id}.yaml");
public string StoragePath { get; }
public string GetSmartPlaylistFilePath(SmartPlaylistId smartPlaylistId) {
return Path.Combine(StoragePath, $"{smartPlaylistId}.yaml");
}
public string FindSmartPlaylistFilePath(string id) {
return Directory.GetFiles(PlaylistStoragePath, $"{id}.yaml", SearchOption.AllDirectories).Concat(
Directory.GetFiles(PlaylistStoragePath, $"{id}.yml", SearchOption.AllDirectories)
public string FindSmartPlaylistFilePath(SmartPlaylistId smartPlaylistId) {
return Directory.GetFiles(StoragePath, $"{smartPlaylistId}.yaml", SearchOption.AllDirectories).Concat(
Directory.GetFiles(StoragePath, $"{smartPlaylistId}.yml", SearchOption.AllDirectories)
).Concat(
Directory.GetFiles(PlaylistStoragePath, $"{id}.json", SearchOption.AllDirectories)
Directory.GetFiles(StoragePath, $"{smartPlaylistId}.json", SearchOption.AllDirectories)
).First();
}
public string[] FindAllSmartPlaylistFilePaths() {
return Directory.GetFiles(PlaylistStoragePath, "*.yaml", SearchOption.AllDirectories).Concat(
Directory.GetFiles(PlaylistStoragePath, "*.yml", SearchOption.AllDirectories)
return Directory.GetFiles(StoragePath, "*.yaml", SearchOption.AllDirectories).Concat(
Directory.GetFiles(StoragePath, "*.yml", SearchOption.AllDirectories)
).Concat(
Directory.GetFiles(PlaylistStoragePath, "*.json", SearchOption.AllDirectories)
Directory.GetFiles(StoragePath, "*.json", SearchOption.AllDirectories)
).ToArray();
}
public string GetSmartCollectionFilePath(string id) {
return Path.Combine(CollectionStoragePath, $"{id}.yaml");
}
public string FindSmartCollectionFilePath(string id) {
return Directory.GetFiles(CollectionStoragePath, $"{id}.yaml", SearchOption.AllDirectories).Concat(
Directory.GetFiles(CollectionStoragePath, $"{id}.yml", SearchOption.AllDirectories)
).Concat(
Directory.GetFiles(CollectionStoragePath, $"{id}.json", SearchOption.AllDirectories)
).First();
}
public string[] FindAllSmartCollectionFilePaths() {
return Directory.GetFiles(CollectionStoragePath, "*.yaml", SearchOption.AllDirectories).Concat(
Directory.GetFiles(CollectionStoragePath, "*.yml", SearchOption.AllDirectories)
).Concat(
Directory.GetFiles(CollectionStoragePath, "*.json", SearchOption.AllDirectories)
).ToArray();
}
}
}

52
Jellyfin.Plugin.SmartPlaylist/Store.cs
View file

@ -7,12 +7,6 @@ namespace Jellyfin.Plugin.SmartPlaylist {
Task SaveSmartPlaylistAsync(SmartPlaylistDto smartPlaylist);
void DeleteSmartPlaylistById(SmartPlaylistId smartPlaylistId);
void DeleteSmartPlaylist(SmartPlaylistDto smartPlaylist);
Task<SmartCollectionDto> GetSmartCollectionAsync(SmartCollectionId smartCollectionId);
Task<SmartCollectionDto[]> GetAllSmartCollectionsAsync();
Task SaveSmartCollectionAsync(SmartCollectionDto smartCollection);
void DeleteSmartCollectionById(SmartCollectionId smartCollectionId);
void DeleteSmartCollection(SmartCollectionDto smartCollection);
}
public class Store : IStore {
@ -65,51 +59,5 @@ namespace Jellyfin.Plugin.SmartPlaylist {
if (File.Exists(smartPlaylist.Filename)) { File.Delete(smartPlaylist.Filename); }
DeleteSmartPlaylistById(smartPlaylist.Id);
}
private async Task<SmartCollectionDto> LoadCollectionAsync(string filename) {
var r = await File.ReadAllTextAsync(filename);
if (r.Equals("")) {
r = "{}";
}
var dto = new DeserializerBuilder().Build().Deserialize<SmartCollectionDto>(r);
if (dto == null)
{
throw new ApplicationException("");
}
if (dto.Id != Path.GetFileNameWithoutExtension(filename)) {
dto.Id = Path.GetFileNameWithoutExtension(filename);
}
if (dto.Name != Path.GetFileNameWithoutExtension(filename)) {
dto.Name = Path.GetFileNameWithoutExtension(filename);
}
if (dto.Filename != filename) {
dto.Filename = filename;
}
return dto;
}
public async Task<SmartCollectionDto> GetSmartCollectionAsync(SmartCollectionId smartCollectionId) {
string filename = _fileSystem.FindSmartCollectionFilePath(smartCollectionId);
return await LoadCollectionAsync(filename).ConfigureAwait(false);
}
public async Task<SmartCollectionDto[]> GetAllSmartCollectionsAsync() {
var t = _fileSystem.FindAllSmartCollectionFilePaths().Select(LoadCollectionAsync).ToArray();
await Task.WhenAll(t).ConfigureAwait(false);
return t.Where(x => x != null).Select(x => x.Result).ToArray();
}
public async Task SaveSmartCollectionAsync(SmartCollectionDto smartCollection) {
string filename = _fileSystem.GetSmartCollectionFilePath(smartCollection.Id);
var text = new SerializerBuilder().Build().Serialize(smartCollection);
await File.WriteAllTextAsync(filename, text);
}
public void DeleteSmartCollectionById(SmartCollectionId smartCollectionId) {
try {
string filename = _fileSystem.FindSmartCollectionFilePath(smartCollectionId);
if (File.Exists(filename)) { File.Delete(filename); }
} catch (System.InvalidOperationException) {}
}
public void DeleteSmartCollection(SmartCollectionDto smartCollection) {
if (File.Exists(smartCollection.Filename)) { File.Delete(smartCollection.Filename); }
DeleteSmartCollectionById(smartCollection.Id);
}
}
}

2
Jellyfin.Plugin.SmartPlaylist/Types.cs
View file

@ -2,6 +2,4 @@ global using System;
global using UserId = System.Guid;
global using PlaylistId = System.Guid;
global using CollectionId = System.Guid;
global using SmartPlaylistId = string;
global using SmartCollectionId = string;

3
Jellyfin.Plugin.SmartPlaylist/Util/Stream.cs
View file

@ -56,9 +56,6 @@ namespace Jellyfin.Plugin.SmartPlaylist.Util {
public IStream<T> Copy() {
return new Stream<T>(_items, _cursor, _ephemeralCursor);
}
public IList<T> Remainder() {
return _items.Skip(_cursor).ToList();
}
}
}

69
Jellyfin.Plugin.SmartPlaylist/build.yaml
View file

@ -1,7 +1,7 @@
name: Smart Playlist
guid: dd2326e3-4d3e-4bfc-80e6-28502c1131df
version: 0.5.3.0
targetAbi: 10.10.6.0
version: 0.4.0.0
targetAbi: 10.10.3.0
framework: net8.0
owner: redxef
overview: Smart playlists with Lisp filter engine.
@ -14,9 +14,66 @@ artifacts:
- jellyfin-smart-playlist.dll
- YamlDotNet.dll
changelog: |
## v0.5.3.0
- bump Jellyfin ABI version to 10.10.6
- bump yamldotnet to 16.3.0
## v0.4.0.0
- Add a basic UI to configure the playlists.
- It's now possible to print log messages to the jellyfin log by calling `logd`, `logi`, `logw` or `loge`
for the respective levels `debug`, `info`, `warning` or `error`.
- Allow calling generic methods via `(invoke-generic object methodname args list-of-types)`.
- Add quoting via single quote: `'`.
- Add special case for `(quote <form>)` to be rendered as `'<form>`.
- It is now possible to include comments in the source via a semicolon (`;`).
- Respect the `Enabled` flag and only process the playlists that are enabled.
- New methods have been added: `rand`, `shuf`.
- Add `find-artist`, `get-name` and `find-parent` default definitions.
- Update YamlDotNet to v16.2.1.
**Breaking changes**:
- Rename global environment variables to be enclosed by `*`.
**Fixes**:
- qsort doesn't loop endlessly with duplicate values in import anymore
- The initialization of the executor now contains the same default definitions for the SortProgram and the normal Program.
- The progress report now considers the SmartPlaylists and not the individual playlists per user.
- It is now possible to pass builtins as arguments. Previously to get `(qsort > (list 1 2 3))` one had to write
something like this: `(qsort (lambda (a b) (> a b)) (list 1 2 3))`.
- A program no longer has to be a list, `t` is a valid program.
- Fix list parsing in cases where a space was before the closing parenthesis.
## v0.3.0.0
- Add a second program (`SortProgram`) which is run after the filtering, this
program should return the list of items, but in the order in which they should appear in
the playlist. The default is `(begin items)` which returns the list as is.
- Extend builtin lisp definitions: add `qsort` and string comparison methods
- Extend default program definitions: add `all-genres` and `any-genres` to quickly specify a list of genres which to include (or excluding when negating)
- Update Jellyfin to v 10.10.3
**Fixes**:
- The progress report now correctly gives a percentage in the range [0, 100].
## v0.2.2.0
- Update Jellyfin to v 10.10.2
## v0.2.1.0
- Make default program configuration a textarea in the settings page
- Add convinience definitions: `is-type`, `name-contains`
- Update YamlDotNet to v 16.2.0
**Fixes**:
- The default program was malformed, a closing bracket was at the wrong position
- The `haskeys` function could only be called on Objects
## v0.2.0.0
- Switch to yaml loading, old json files are still accepted
- Rework lisp interpreter to be more conventional
- Use arbitrary strings as ids for playlists
- Add configuration page with some default definitions for
the filter expressions.
**Breaking Changes**:
- The lisp interpreter will now only detect strings in double quotes (`"`).
- The interpreter will also not allow specifying lists without quoting them.
`(1 2 3)` ... used to work but will no longer, replace by either specifying
the list as `(list 1 2 3)` or `(quote (1 2 3))`.
## v0.1.1.0
- Initial Alpha release.

201
Jellyfin.Plugin.SmartPlaylist/configPage.html Normal file
View file

@ -0,0 +1,201 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>SmartPlaylist</title>
</head>
<body>
<div id="SmartPlaylistConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
<div data-role="content">
<div class="content-primary">
<form id="SmartPlaylistConfigForm">
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="InitialProgram">Initial Program</label>
<div class="fieldDescription">A program which can set up the environment</div>
<textarea id="InitialProgram" class="emby-input smartplaylist-monospace" name="InitialProgram" rows="16" cols="120"></textarea>
</div>
<div>
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistSelection">Choose a playlist to edit</label>
<select id="SmartplaylistSelection" class="emby-select">
</select>
</div>
<div>
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditName">Name</label>
<input id="SmartplaylistEditName" type="text" class="emby-input"/>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditProgram">Program</label>
<div class="fieldDescription">A program which should return <code>t</code> or <code>nil</code> to include or exclude the provided <code>item</code>.</div>
<textarea id="SmartplaylistEditProgram" class="emby-input smartplaylist-monospace" name="Program" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditSortProgram">Sort Program</label>
<div class="fieldDescription">A program which should return a list of items to include in the playlist, sorted however you like.</div>
<textarea id="SmartplaylistEditSortProgram" class="emby-input smartplaylist-monospace" name="SortProgram" rows="16" cols="120"></textarea>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartplaylistEditUsers">Users</label>
<div class="fieldDescription">Which users should get access to the playlist.</div>
<select multiple id="SmartplaylistEditUsers" class="emby-select">
</select>
</div>
<div class="inputContainer">
<label class="inputLabel inputLabelUnfocused" for="SmartPlaylistEditEnabled">Enabled</label>
<div class="fieldDescription">Is the playlist enabled.</div>
<input id="SmartplaylistEditEnabled" type="checkbox" class="emby-input"/>
</div>
<div>
<button is="emby-button" type="submit" class="raised button-submit block emby-button">
<span>Save</span>
</button>
</div>
</form>
</div>
</div>
<style>
.smartplaylist-monospace {
font-family: monospace;
}
</style>
<script type="text/javascript">
var SmartPlaylistConfig = {
pluginUniqueId: 'dd2326e3-4d3e-4bfc-80e6-28502c1131df'
};
function changeEditBox(config, id) {
const selection = document.querySelector('#SmartplaylistSelection');
const editName = document.querySelector('#SmartplaylistEditName');
const editProgram = document.querySelector('#SmartplaylistEditProgram');
const editSortProgram = document.querySelector('#SmartplaylistEditSortProgram');
const editUsers = document.querySelector('#SmartplaylistEditUsers');
const editEnabled = document.querySelector('#SmartplaylistEditEnabled');
if (id === null) {
selection.selectedIndex = 0;
editName.value = 'My New Smartplaylist';
editProgram.value = '(is-favourite)';
editSortProgram.value = '(begin *items*)';
editUsers.innerHTML = '';
for (const u of config.Users) {
var o = document.createElement('option');
o.value = u[0];
o.innerHTML = u[1];
o.setAttribute('selected', 'selected');
editUsers.appendChild(o);
}
editEnabled.checked = true;
return;
}
function matchId(p) {
return p.Id == id;
}
const index = config.Playlists.map(function (x) { return x.Id }).indexOf(id);
selection.selectedIndex = index + 1;
const p = config.Playlists[index];
editName.value = p.Name;
editProgram.value = p.Program;
editSortProgram.value = p.SortProgram;
editUsers.innerHTML = '';
for (const u of config.Users) {
var o = document.createElement('option');
o.value = u[0];
o.innerHTML = u[1];
if (p.Playlists.map((x) => x.UserId).includes(u[0])) {
o.setAttribute('selected', 'selected');
}
editUsers.appendChild(o);
}
editEnabled.checked = p.Enabled;
}
function fillPlaylistSelect(config) {
const selection = document.querySelector('#SmartplaylistSelection');
selection.innerHTML = '';
var o = document.createElement('option');
o.value = null;
o.innerHTML = 'Create new playlist ...';
selection.appendChild(o);
for (const i of config.Playlists) {
var o = document.createElement('option');
o.value = i.Id;
o.innerHTML = i.Name;
selection.appendChild(o);
}
}
document.querySelector('#SmartPlaylistConfigPage')
.addEventListener('pageshow', function() {
Dashboard.showLoadingMsg();
ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
document.querySelector('#InitialProgram').value = config.InitialProgram;
fillPlaylistSelect(config);
changeEditBox(config, (config.Playlists.length > 0) ? config.Playlists[0].Id : null);
Dashboard.hideLoadingMsg();
});
});
document.querySelector('#SmartplaylistSelection')
.addEventListener('change', function() {
Dashboard.showLoadingMsg();
ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
const selection = document.querySelector('#SmartplaylistSelection');
changeEditBox(config, (selection.selectedIndex > 0) ? config.Playlists[selection.selectedIndex - 1].Id : null);
Dashboard.hideLoadingMsg();
});
});
document.querySelector('#SmartPlaylistConfigForm')
.addEventListener('submit', function(e) {
Dashboard.showLoadingMsg();
ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
config.InitialProgram = document.querySelector('#InitialProgram').value;
const selection = document.querySelector('#SmartplaylistSelection');
const editName = document.querySelector('#SmartplaylistEditName');
const editProgram = document.querySelector('#SmartplaylistEditProgram');
const editSortProgram = document.querySelector('#SmartplaylistEditSortProgram');
const editUsers = document.querySelector('#SmartplaylistEditUsers');
const editEnabled = document.querySelector('#SmartplaylistEditEnabled');
var index = selection.selectedIndex;
if (index === 0) {
const o = {
Id: editName.value,
Name: editName.value,
Program: editProgram.value,
SortProgram: editSortProgram.value,
Playlists: Array.from(editUsers.options).filter((x) => x.selected).map((x) => {
const m = {UserId: x.value, PlaylistId: "00000000-0000-0000-0000-000000000000"};
return m;
}),
Enabled: editEnabled.checked,
};
config.Playlists.push(o);
} else {
config.Playlists[index-1].Id = editName.value;
config.Playlists[index-1].Name = editName.value;
config.Playlists[index-1].Program = editProgram.value;
config.Playlists[index-1].SortProgram = editSortProgram.value;
config.Playlists[index-1].Playlists = Array.from(editUsers.options).filter((x) => x.selected).map((x) => {
const existing = config.Playlists[index-1].Playlists.filter((x_) => x_.UserId === x.value).map((x_) => x_.PlaylistId);
const m = {UserId: x.value, PlaylistId: ((existing.length > 0) ? existing[0] : "00000000-0000-0000-0000-000000000000")};
return m;
}),
config.Playlists[index-1].Enabled = editEnabled.checked;
}
ApiClient.updatePluginConfiguration(SmartPlaylistConfig.pluginUniqueId, config).then(function (result) {
Dashboard.processPluginConfigurationUpdateResult(result);
ApiClient.getPluginConfiguration(SmartPlaylistConfig.pluginUniqueId).then(function (config) {
document.querySelector('#InitialProgram').value = config.InitialProgram;
fillPlaylistSelect(config);
changeEditBox(config, (config.Playlists.length > 0) ? config.Playlists[0].Id : null);
Dashboard.hideLoadingMsg();
});
});
});
e.preventDefault();
return false;
});
</script>
</div>
</body>
</html>

26
Jellyfin.Plugin.SmartPlaylist/jellyfin-smart-playlist.csproj
View file

@ -5,32 +5,18 @@
<RootNamespace>Jellyfin.Plugin.SmartPlaylist</RootNamespace>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<Version>0.5.3.0</Version>
<Version>0.4.0.0</Version>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Jellyfin.Controller" Version="10.10.6" />
<PackageReference Include="Jellyfin.Model" Version="10.10.6" />
<PackageReference Include="YamlDotNet" Version="16.3.0" />
<PackageReference Include="Jellyfin.Controller" Version="10.10.3" />
<PackageReference Include="Jellyfin.Model" Version="10.10.3" />
<PackageReference Include="YamlDotNet" Version="16.2.1" />
</ItemGroup>
<ItemGroup>
<None Remove="Configuration\configPage.html"/>
<None Remove="Configuration\configPage.js"/>
<None Remove="Pages\smartPlaylists.html"/>
<None Remove="Pages\smartPlaylists.js"/>
<None Remove="Pages\smartCollections.html"/>
<None Remove="Pages\smartCollections.js"/>
<None Remove="Pages\lispPlayground.html"/>
<None Remove="Pages\lispPlayground.js"/>
<EmbeddedResource Include="Configuration\configPage.html"/>
<EmbeddedResource Include="Configuration\configPage.js"/>
<EmbeddedResource Include="Pages\smartPlaylists.html"/>
<EmbeddedResource Include="Pages\smartPlaylists.js"/>
<EmbeddedResource Include="Pages\smartCollections.html"/>
<EmbeddedResource Include="Pages\smartCollections.js"/>
<EmbeddedResource Include="Pages\lispPlayground.html"/>
<EmbeddedResource Include="Pages\lispPlayground.js"/>
<None Remove="configPage.html"/>
<EmbeddedResource Include="configPage.html"/>
</ItemGroup>
</Project>

9
README.md
View file

@ -5,7 +5,7 @@ Smart playlists with Lisp filter engine.
This readme contains instructions for the most recent changes in
the development branch (`main`). To view the file appropriate
for your version select the tag corresponding to your version.
The latest version is [v0.5.3.0](https://gitea.redxef.at/redxef/jellyfin-smart-playlist/src/tag/v0.5.3.0).
The latest version is [v0.4.0.0](https://gitea.redxef.at/redxef/jellyfin-smart-playlist/src/tag/v0.4.0.0).
![configuration page](config.png)
@ -75,17 +75,12 @@ Enable this playlist, currently ignored.
Add the [plugin repository](https://jellyfin.org/docs/general/server/plugins/#catalog)
to Jellyfin:
`https://git.redxef.at/redxef/jellyfin-smart-playlist/raw/branch/manifest/manifest.json`
`https://gitea.redxef.at/redxef/jellyfin-smart-playlist/raw/branch/manifest/manifest.json`
Go to `Dashboard>Catalog>(Gear)>(Plus)` and paste the provided link into
the field labeled `Repository URL`, give the plugin a descriptive name
too.
## Mirror
There is a mirror at
[codeberg.org/redxef/jellyfin-smart-playlist](https://codeberg.org/redxef/jellyfin-smart-playlist).
## Releasing a new version
1. Write the changelog: `git log --oneline $prev_version..`

16
Test/test.sh
View file

@ -4,16 +4,14 @@ JELLYFIN=jellyfin/jellyfin
set -eu
cd "$(dirname "$0")"
pwd
(
cd ../Jellyfin.Plugin.SmartPlaylist/
dotnet build
)
pwd
mkdir -p ./cache ./media ./config/plugins/jellyfin-smart-playlist
if [ "$#" -eq 1 ] && [ "$1" = '--skip-build' ]; then
:
else
(
cd ../Jellyfin.Plugin.SmartPlaylist/
dotnet build
)
cp ../Jellyfin.Plugin.SmartPlaylist/bin/Debug/net8.0/jellyfin-smart-playlist.dll ./config/plugins/jellyfin-smart-playlist/
fi
cp ../Jellyfin.Plugin.SmartPlaylist/bin/Debug/net8.0/jellyfin-smart-playlist.dll ./config/plugins/jellyfin-smart-playlist/
docker pull "$JELLYFIN"
docker run --rm --user "$(id -u):$(id -g)" \
-v ./cache:/cache \

4
Tests/Tests.cs
View file

@ -267,10 +267,6 @@ namespace Tests
//Assert.Equal("", e.eval("(shuf (list 0 1 2 3 4 5 6))").ToString());
Assert.Equal("(1 2 3 4 5 6 7)", e.eval("(qsort (lambda (a b) (> a b)) '(5 4 7 3 2 6 1))").ToString());
Assert.Equal("(1 2 3 4 5 6 7)", e.eval("(qsort > (list 5 4 7 3 2 6 1))").ToString());
Assert.Equal("(0 1 2 4 5 5)", e.eval("(qsort > '(2 4 1 5 5 0))").ToString());
Assert.Equal("(5 5 4 2 1 0)", e.eval("(qsort < '(2 4 1 5 5 0))").ToString());
Assert.Equal("(5 5 4 2 1 0)", e.eval("(qsort <= '(2 4 1 5 5 0))").ToString());
Assert.Equal("(0 1 2 4 5 5)", e.eval("(qsort >= '(2 4 1 5 5 0))").ToString());
}
}
}

1
ci/pipeline.yml
View file

@ -29,7 +29,6 @@ resources:
basic:
username: ((gitea.username))
password: ((gitea.token))
version_check_method: none
- name: artifact
type: http-resource
source:

10
examples.md
View file

@ -26,19 +26,19 @@
(is-genre "swing" g)))
```
- `All of Haller`: A playlist containing all items by artist `Haller`,
- `All of Seeed`: A playlist containing all items by artist `Seeed`,
useless, since you also can just navigate to the artist to play all
their songs, but a good example.
```
Id: Haller
Name: Haller
Id: Seeed
Name: Seeed
Program: |
(let
(parent
(invoke-generic *item* "FindParent" nil (list "MediaBrowser.Controller.Entities.Audio.MusicArtist, MediaBrowser.Controller")))
(cond
((null parent) nil)
(t (string= (lower (car (getitems parent "Name"))) (lower "Haller")))))
(t (string= (car (getitems parent "Name")) "Haller"))))
```
or simplified with definitions contained in the preamble:
```
@ -91,7 +91,7 @@
(lambda
(i)
;; the `(and (find-artist)` is here to prevent null violations.
(and (find-artist) (string= (lower i) (lower (get-name (find-artist))))))
(and (find-artist) (string= i (lower (get-name (find-artist))))))
*include-artists*)))
SortProgram: (begin (shuf *items*))
Filename: /config/data/smartplaylists/German.yaml