Inherit parental restrictions on shared accounts, with a chosen rating cap

A shared account previously inherited its members' library access but
none of their content restrictions, so a child could log into "alice+kid"
with their own password and get around their own rating cap.

The shared account now gets the strictest member's parental rating,
unrated-item block, blocked tags and allowed tags, recomputed at
creation, on membership change and at startup. An admin can raise the
rating cap on a slider between the strictest and the loosest member;
unrated and tag rules stay strictest-wins.

What makes raising the cap safe is the unlock rule: after a member's
password matches, both users' live policies are compared and the login
is refused if the account is looser than the member on any field. So
raising the cap above the child's rating means the child's password no
longer opens the account, while the parent's still does. The same rule
bounds the slider - past the loosest member nobody could unlock the
account - so a chosen cap is clamped back into range whenever applied.

Allowed tags need care: Jellyfin reads an empty list as "no whitelist",
so an empty intersection of members' whitelists is written as a sentinel
tag no item carries. Access schedules and channels are not inherited yet.

The shared account is never an administrator. Groups created at the
login screen always inherit and are restricted before the first session
exists. The dashboard shows each member's cap, who a chosen cap shuts
out, and the restrictions in effect, and gains a per-group edit form for
the sync options.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Jellyfin.Plugin.WatchedTogether/Controllers/WatchedTogetherController.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Net.Mime;
 using System.Threading.Tasks;
 using Jellyfin.Plugin.WatchedTogether.Compat;
+using Jellyfin.Plugin.WatchedTogether.Configuration;
 using Jellyfin.Plugin.WatchedTogether.Models;
 using Jellyfin.Plugin.WatchedTogether.Services;
 using MediaBrowser.Common.Api;
@@ -25,6 +26,7 @@ namespace Jellyfin.Plugin.WatchedTogether.Controllers;
 public class WatchedTogetherController : ControllerBase
 {
     private readonly IProvisioningService _provisioningService;
+    private readonly IRestrictionService _restrictionService;
     private readonly IUserManager _userManager;
     private readonly ILogger<WatchedTogetherController> _logger;
 
@@ -32,14 +34,17 @@ public class WatchedTogetherController : ControllerBase
     /// Initializes a new instance of the <see cref="WatchedTogetherController"/> class.
     /// </summary>
     /// <param name="provisioningService">The provisioning service.</param>
+    /// <param name="restrictionService">The content restriction service.</param>
     /// <param name="userManager">The user manager.</param>
     /// <param name="logger">The logger.</param>
     public WatchedTogetherController(
         IProvisioningService provisioningService,
+        IRestrictionService restrictionService,
         IUserManager userManager,
         ILogger<WatchedTogetherController> logger)
     {
         _provisioningService = provisioningService;
+        _restrictionService = restrictionService;
         _userManager = userManager;
         _logger = logger;
     }
@@ -58,21 +63,7 @@ public class WatchedTogetherController : ControllerBase
             return Ok(Array.Empty<GroupDto>());
         }
 
-        var groups = config.Groups.Select(g => new GroupDto
-        {
-            SharedUserId = g.SharedUserId,
-            SharedUsername = _userManager.GetUserById(g.SharedUserId)?.Username ?? "(deleted)",
-            SyncUnwatched = g.SyncUnwatched,
-            SyncPlayCount = g.SyncPlayCount,
-            IsDisabled = g.IsDisabled,
-            Members = g.MemberUserIds.Select(id => new MemberDto
-            {
-                UserId = id,
-                Username = _userManager.GetUserById(id)?.Username ?? "(deleted)"
-            }).ToList()
-        }).ToList();
-
-        return Ok(groups);
+        return Ok(config.Groups.Select(ToDto).ToList());
     }
 
     /// <summary>
@@ -114,19 +105,7 @@ public class WatchedTogetherController : ControllerBase
                 request.MemberUserIds,
                 request.Name).ConfigureAwait(false);
 
-            return Ok(new GroupDto
-            {
-                SharedUserId = group.SharedUserId,
-                SharedUsername = _userManager.GetUserById(group.SharedUserId)?.Username ?? string.Empty,
-                SyncUnwatched = group.SyncUnwatched,
-                SyncPlayCount = group.SyncPlayCount,
-                IsDisabled = group.IsDisabled,
-                Members = group.MemberUserIds.Select(id => new MemberDto
-                {
-                    UserId = id,
-                    Username = _userManager.GetUserById(id)?.Username ?? "(deleted)"
-                }).ToList()
-            });
+            return Ok(ToDto(group));
         }
         catch (ArgumentException ex)
         {
@@ -157,7 +136,9 @@ public class WatchedTogetherController : ControllerBase
                 request.MemberUserIds,
                 request.SyncUnwatched,
                 request.SyncPlayCount,
-                request.IsDisabled).ConfigureAwait(false);
+                request.IsDisabled,
+                request.InheritParentalRating,
+                request.ParentalRatingCap).ConfigureAwait(false);
 
             return NoContent();
         }
@@ -192,4 +173,51 @@ public class WatchedTogetherController : ControllerBase
             return BadRequest(ex.Message);
         }
     }
+
+    /// <summary>
+    /// Resolves a stored group against current user records, including the restrictions its
+    /// shared account actually carries right now.
+    /// </summary>
+    /// <param name="group">The stored group.</param>
+    /// <returns>The group as the dashboard shows it.</returns>
+    private GroupDto ToDto(SharedGroup group)
+    {
+        var sharedUser = _userManager.GetUserById(group.SharedUserId);
+        var range = _restrictionService.GetRatingRange(group.MemberUserIds);
+
+        return new GroupDto
+        {
+            SharedUserId = group.SharedUserId,
+            SharedUsername = sharedUser?.Username ?? "(deleted)",
+            SyncUnwatched = group.SyncUnwatched,
+            SyncPlayCount = group.SyncPlayCount,
+            IsDisabled = group.IsDisabled,
+            InheritParentalRating = group.InheritParentalRating,
+            ParentalRatingCap = group.ParentalRatingCap,
+            StrictestMemberRating = range.Strictest,
+            LoosestMemberRating = range.Loosest,
+            Restrictions = sharedUser is null ? null : ToDto(ContentRestrictions.FromUser(sharedUser)),
+            Members = group.MemberUserIds.Select(id =>
+            {
+                var member = _userManager.GetUserById(id);
+                return new MemberDto
+                {
+                    UserId = id,
+                    Username = member?.Username ?? "(deleted)",
+                    MaxParentalRating = member is null ? 0 : member.MaxParentalRatingScore
+                };
+            }).ToList()
+        };
+    }
+
+    private static RestrictionsDto ToDto(ContentRestrictions restrictions)
+        => new()
+        {
+            MaxParentalRating = restrictions.MaxParentalRatingScore,
+            MaxParentalSubRating = restrictions.MaxParentalRatingSubScore,
+            BlockUnratedItems = restrictions.BlockUnratedItems.Select(u => u.ToString()).OrderBy(u => u, StringComparer.Ordinal).ToList(),
+            BlockedTags = restrictions.BlockedTags.OrderBy(t => t, StringComparer.OrdinalIgnoreCase).ToList(),
+            AllowedTags = (restrictions.AllowedTags ?? Enumerable.Empty<string>()).OrderBy(t => t, StringComparer.OrdinalIgnoreCase).ToList(),
+            AllowsNothing = restrictions.HasAllowedTags && restrictions.AllowedTags!.Count == 0
+        };
 }