| | | 1 | | #nullable disable |
| | | 2 | | |
| | | 3 | | #pragma warning disable CS1591, SA1401 |
| | | 4 | | |
| | | 5 | | using System; |
| | | 6 | | using System.Collections.Generic; |
| | | 7 | | using System.Collections.Immutable; |
| | | 8 | | using System.Globalization; |
| | | 9 | | using System.IO; |
| | | 10 | | using System.Linq; |
| | | 11 | | using System.Text; |
| | | 12 | | using System.Text.Json.Serialization; |
| | | 13 | | using System.Threading; |
| | | 14 | | using System.Threading.Tasks; |
| | | 15 | | using Jellyfin.Data; |
| | | 16 | | using Jellyfin.Data.Enums; |
| | | 17 | | using Jellyfin.Database.Implementations.Entities; |
| | | 18 | | using Jellyfin.Database.Implementations.Enums; |
| | | 19 | | using Jellyfin.Extensions; |
| | | 20 | | using MediaBrowser.Common.Extensions; |
| | | 21 | | using MediaBrowser.Controller.Channels; |
| | | 22 | | using MediaBrowser.Controller.Chapters; |
| | | 23 | | using MediaBrowser.Controller.Configuration; |
| | | 24 | | using MediaBrowser.Controller.Dto; |
| | | 25 | | using MediaBrowser.Controller.Entities.TV; |
| | | 26 | | using MediaBrowser.Controller.Library; |
| | | 27 | | using MediaBrowser.Controller.MediaSegments; |
| | | 28 | | using MediaBrowser.Controller.Persistence; |
| | | 29 | | using MediaBrowser.Controller.Providers; |
| | | 30 | | using MediaBrowser.Model.Configuration; |
| | | 31 | | using MediaBrowser.Model.Dto; |
| | | 32 | | using MediaBrowser.Model.Entities; |
| | | 33 | | using MediaBrowser.Model.Globalization; |
| | | 34 | | using MediaBrowser.Model.IO; |
| | | 35 | | using MediaBrowser.Model.Library; |
| | | 36 | | using MediaBrowser.Model.LiveTv; |
| | | 37 | | using MediaBrowser.Model.MediaInfo; |
| | | 38 | | using Microsoft.Extensions.Logging; |
| | | 39 | | |
| | | 40 | | namespace MediaBrowser.Controller.Entities |
| | | 41 | | { |
| | | 42 | | /// <summary> |
| | | 43 | | /// Class BaseItem. |
| | | 44 | | /// </summary> |
| | | 45 | | public abstract class BaseItem : IHasProviderIds, IHasLookupInfo<ItemLookupInfo>, IEquatable<BaseItem> |
| | | 46 | | { |
| | | 47 | | private BaseItemKind? _baseItemKind; |
| | | 48 | | |
| | | 49 | | public const string ThemeSongFileName = "theme"; |
| | | 50 | | |
| | | 51 | | // Well below the 255 byte limit of the common Linux filesystems and the 255 character limit |
| | | 52 | | // of Windows, so the files inside the folder still fit within MAX_PATH. |
| | | 53 | | private const int MaxItemByNameFolderNameBytes = 128; |
| | | 54 | | |
| | | 55 | | /// <summary> |
| | | 56 | | /// The supported image extensions. |
| | | 57 | | /// </summary> |
| | 5 | 58 | | public static readonly string[] SupportedImageExtensions |
| | 5 | 59 | | = [".png", ".jpg", ".jpeg", ".webp", ".tbn", ".gif", ".svg"]; |
| | | 60 | | |
| | 5 | 61 | | private static readonly List<string> _supportedExtensions = new List<string>(SupportedImageExtensions) |
| | 5 | 62 | | { |
| | 5 | 63 | | ".nfo", |
| | 5 | 64 | | ".xml", |
| | 5 | 65 | | ".srt", |
| | 5 | 66 | | ".vtt", |
| | 5 | 67 | | ".sub", |
| | 5 | 68 | | ".sup", |
| | 5 | 69 | | ".idx", |
| | 5 | 70 | | ".txt", |
| | 5 | 71 | | ".edl", |
| | 5 | 72 | | ".bif", |
| | 5 | 73 | | ".smi", |
| | 5 | 74 | | ".ttml", |
| | 5 | 75 | | ".lrc", |
| | 5 | 76 | | ".elrc" |
| | 5 | 77 | | }; |
| | | 78 | | |
| | | 79 | | /// <summary> |
| | | 80 | | /// Extra types that should be counted and displayed as "Special Features" in the UI. |
| | | 81 | | /// </summary> |
| | 5 | 82 | | public static readonly IReadOnlyCollection<ExtraType> DisplayExtraTypes = new HashSet<ExtraType> |
| | 5 | 83 | | { |
| | 5 | 84 | | Model.Entities.ExtraType.Unknown, |
| | 5 | 85 | | Model.Entities.ExtraType.BehindTheScenes, |
| | 5 | 86 | | Model.Entities.ExtraType.Clip, |
| | 5 | 87 | | Model.Entities.ExtraType.DeletedScene, |
| | 5 | 88 | | Model.Entities.ExtraType.Interview, |
| | 5 | 89 | | Model.Entities.ExtraType.Sample, |
| | 5 | 90 | | Model.Entities.ExtraType.Scene, |
| | 5 | 91 | | Model.Entities.ExtraType.Featurette, |
| | 5 | 92 | | Model.Entities.ExtraType.Short |
| | 5 | 93 | | }; |
| | | 94 | | |
| | 5 | 95 | | private protected static readonly char[] VersionDelimiters = ['-', '_', '.']; |
| | | 96 | | |
| | | 97 | | private string _sortName; |
| | | 98 | | |
| | | 99 | | private string _forcedSortName; |
| | | 100 | | |
| | | 101 | | private string _name; |
| | | 102 | | |
| | | 103 | | private string _originalLanguage; |
| | | 104 | | |
| | | 105 | | private float? _lufs; |
| | | 106 | | |
| | | 107 | | private float? _normalizationGain; |
| | | 108 | | |
| | | 109 | | private float? _criticRating; |
| | | 110 | | |
| | | 111 | | private float? _communityRating; |
| | | 112 | | |
| | | 113 | | public const char SlugChar = '-'; |
| | | 114 | | |
| | | 115 | | protected BaseItem() |
| | | 116 | | { |
| | 3950 | 117 | | Tags = Array.Empty<string>(); |
| | 3950 | 118 | | Genres = Array.Empty<string>(); |
| | 3950 | 119 | | Studios = Array.Empty<string>(); |
| | 3950 | 120 | | ProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); |
| | 3950 | 121 | | LockedFields = Array.Empty<MetadataField>(); |
| | 3950 | 122 | | ImageInfos = Array.Empty<ItemImageInfo>(); |
| | 3950 | 123 | | ProductionLocations = Array.Empty<string>(); |
| | 3950 | 124 | | RemoteTrailers = Array.Empty<MediaUrl>(); |
| | 3950 | 125 | | UserData = []; |
| | 3950 | 126 | | } |
| | | 127 | | |
| | | 128 | | /// <summary> |
| | | 129 | | /// Gets or Sets the user data collection as cached from the last Db query. |
| | | 130 | | /// </summary> |
| | | 131 | | [JsonIgnore] |
| | | 132 | | public ICollection<UserData> UserData { get; set; } |
| | | 133 | | |
| | | 134 | | [JsonIgnore] |
| | | 135 | | public string PreferredMetadataCountryCode { get; set; } |
| | | 136 | | |
| | | 137 | | [JsonIgnore] |
| | | 138 | | public string PreferredMetadataLanguage { get; set; } |
| | | 139 | | |
| | | 140 | | public long? Size { get; set; } |
| | | 141 | | |
| | | 142 | | public string Container { get; set; } |
| | | 143 | | |
| | | 144 | | [JsonIgnore] |
| | | 145 | | public string Tagline { get; set; } |
| | | 146 | | |
| | | 147 | | [JsonIgnore] |
| | | 148 | | public virtual ItemImageInfo[] ImageInfos { get; set; } |
| | | 149 | | |
| | | 150 | | [JsonIgnore] |
| | | 151 | | public bool IsVirtualItem { get; set; } |
| | | 152 | | |
| | | 153 | | /// <summary> |
| | | 154 | | /// Gets or sets the album. |
| | | 155 | | /// </summary> |
| | | 156 | | /// <value>The album.</value> |
| | | 157 | | [JsonIgnore] |
| | | 158 | | public string Album { get; set; } |
| | | 159 | | |
| | | 160 | | /// <summary> |
| | | 161 | | /// Gets or sets the LUFS value. |
| | | 162 | | /// </summary> |
| | | 163 | | /// <value>The LUFS Value.</value> |
| | | 164 | | [JsonIgnore] |
| | | 165 | | public float? LUFS |
| | | 166 | | { |
| | 266 | 167 | | get => _lufs; |
| | 268 | 168 | | set => _lufs = FiniteOrNull(value); |
| | | 169 | | } |
| | | 170 | | |
| | | 171 | | /// <summary> |
| | | 172 | | /// Gets or sets the gain required for audio normalization. |
| | | 173 | | /// </summary> |
| | | 174 | | /// <value>The gain required for audio normalization.</value> |
| | | 175 | | [JsonIgnore] |
| | | 176 | | public float? NormalizationGain |
| | | 177 | | { |
| | 266 | 178 | | get => _normalizationGain; |
| | 268 | 179 | | set => _normalizationGain = FiniteOrNull(value); |
| | | 180 | | } |
| | | 181 | | |
| | | 182 | | /// <summary> |
| | | 183 | | /// Gets or sets the channel identifier. |
| | | 184 | | /// </summary> |
| | | 185 | | /// <value>The channel identifier.</value> |
| | | 186 | | [JsonIgnore] |
| | | 187 | | public Guid ChannelId { get; set; } |
| | | 188 | | |
| | | 189 | | [JsonIgnore] |
| | 0 | 190 | | public virtual bool SupportsAddingToPlaylist => false; |
| | | 191 | | |
| | | 192 | | [JsonIgnore] |
| | 49 | 193 | | public virtual bool AlwaysScanInternalMetadataPath => false; |
| | | 194 | | |
| | | 195 | | /// <summary> |
| | | 196 | | /// Gets or sets a value indicating whether this instance is in mixed folder. |
| | | 197 | | /// </summary> |
| | | 198 | | /// <value><c>true</c> if this instance is in mixed folder; otherwise, <c>false</c>.</value> |
| | | 199 | | [JsonIgnore] |
| | | 200 | | public bool IsInMixedFolder { get; set; } |
| | | 201 | | |
| | | 202 | | [JsonIgnore] |
| | 0 | 203 | | public virtual bool SupportsPlayedStatus => false; |
| | | 204 | | |
| | | 205 | | [JsonIgnore] |
| | 0 | 206 | | public virtual bool SupportsPositionTicksResume => false; |
| | | 207 | | |
| | | 208 | | [JsonIgnore] |
| | 18 | 209 | | public virtual bool SupportsRemoteImageDownloading => true; |
| | | 210 | | |
| | | 211 | | /// <summary> |
| | | 212 | | /// Gets or sets the name. |
| | | 213 | | /// </summary> |
| | | 214 | | /// <value>The name.</value> |
| | | 215 | | [JsonIgnore] |
| | | 216 | | public virtual string Name |
| | | 217 | | { |
| | 1430 | 218 | | get => _name; |
| | | 219 | | set |
| | | 220 | | { |
| | 938 | 221 | | _name = value; |
| | | 222 | | |
| | | 223 | | // lazy load this again |
| | 938 | 224 | | _sortName = null; |
| | 938 | 225 | | } |
| | | 226 | | } |
| | | 227 | | |
| | | 228 | | [JsonIgnore] |
| | 0 | 229 | | public bool IsUnaired => PremiereDate.HasValue && PremiereDate.Value.ToLocalTime().Date >= DateTime.Now.Date; |
| | | 230 | | |
| | | 231 | | [JsonIgnore] |
| | | 232 | | public int? TotalBitrate { get; set; } |
| | | 233 | | |
| | | 234 | | [JsonIgnore] |
| | | 235 | | public ExtraType? ExtraType { get; set; } |
| | | 236 | | |
| | | 237 | | [JsonIgnore] |
| | 0 | 238 | | public bool IsThemeMedia => ExtraType.HasValue && (ExtraType.Value == Model.Entities.ExtraType.ThemeSong || Extr |
| | | 239 | | |
| | | 240 | | [JsonIgnore] |
| | | 241 | | public string OriginalTitle { get; set; } |
| | | 242 | | |
| | | 243 | | [JsonIgnore] |
| | | 244 | | public string OriginalLanguage |
| | | 245 | | { |
| | 539 | 246 | | get => _originalLanguage; |
| | 443 | 247 | | set => _originalLanguage = LocalizationManager?.FindLanguageInfo(value)?.TwoLetterISOLanguageName ?? value; |
| | | 248 | | } |
| | | 249 | | |
| | | 250 | | /// <summary> |
| | | 251 | | /// Gets or sets the id. |
| | | 252 | | /// </summary> |
| | | 253 | | /// <value>The id.</value> |
| | | 254 | | [JsonIgnore] |
| | | 255 | | public Guid Id { get; set; } |
| | | 256 | | |
| | | 257 | | [JsonIgnore] |
| | | 258 | | public Guid OwnerId { get; set; } |
| | | 259 | | |
| | | 260 | | /// <summary> |
| | | 261 | | /// Gets or sets the audio. |
| | | 262 | | /// </summary> |
| | | 263 | | /// <value>The audio.</value> |
| | | 264 | | [JsonIgnore] |
| | | 265 | | public ProgramAudio? Audio { get; set; } |
| | | 266 | | |
| | | 267 | | /// <summary> |
| | | 268 | | /// Gets the id that should be used to key display prefs for this item. |
| | | 269 | | /// Default is based on the type for everything except actual generic folders. |
| | | 270 | | /// </summary> |
| | | 271 | | /// <value>The display prefs id.</value> |
| | | 272 | | [JsonIgnore] |
| | | 273 | | public virtual Guid DisplayPreferencesId |
| | | 274 | | { |
| | | 275 | | get |
| | | 276 | | { |
| | 6 | 277 | | var thisType = GetType(); |
| | 6 | 278 | | return thisType == typeof(Folder) ? Id : thisType.FullName.GetMD5(); |
| | | 279 | | } |
| | | 280 | | } |
| | | 281 | | |
| | | 282 | | /// <summary> |
| | | 283 | | /// Gets or sets the path. |
| | | 284 | | /// </summary> |
| | | 285 | | /// <value>The path.</value> |
| | | 286 | | [JsonIgnore] |
| | | 287 | | public virtual string Path { get; set; } |
| | | 288 | | |
| | | 289 | | [JsonIgnore] |
| | | 290 | | public virtual SourceType SourceType |
| | | 291 | | { |
| | | 292 | | get |
| | | 293 | | { |
| | 5345 | 294 | | if (!ChannelId.IsEmpty()) |
| | | 295 | | { |
| | 0 | 296 | | return SourceType.Channel; |
| | | 297 | | } |
| | | 298 | | |
| | 5345 | 299 | | return SourceType.Library; |
| | | 300 | | } |
| | | 301 | | } |
| | | 302 | | |
| | | 303 | | /// <summary> |
| | | 304 | | /// Gets the folder containing the item. |
| | | 305 | | /// If the item is a folder, it returns the folder itself. |
| | | 306 | | /// </summary> |
| | | 307 | | [JsonIgnore] |
| | | 308 | | public virtual string ContainingFolderPath |
| | | 309 | | { |
| | | 310 | | get |
| | | 311 | | { |
| | 721 | 312 | | if (IsFolder) |
| | | 313 | | { |
| | 611 | 314 | | return Path; |
| | | 315 | | } |
| | | 316 | | |
| | 110 | 317 | | return System.IO.Path.GetDirectoryName(Path); |
| | | 318 | | } |
| | | 319 | | } |
| | | 320 | | |
| | | 321 | | /// <summary> |
| | | 322 | | /// Gets or sets the name of the service. |
| | | 323 | | /// </summary> |
| | | 324 | | /// <value>The name of the service.</value> |
| | | 325 | | [JsonIgnore] |
| | | 326 | | public string ServiceName { get; set; } |
| | | 327 | | |
| | | 328 | | /// <summary> |
| | | 329 | | /// Gets or sets the external id. |
| | | 330 | | /// </summary> |
| | | 331 | | /// <remarks> |
| | | 332 | | /// If this content came from an external service, the id of the content on that service. |
| | | 333 | | /// </remarks> |
| | | 334 | | [JsonIgnore] |
| | | 335 | | public string ExternalId { get; set; } |
| | | 336 | | |
| | | 337 | | [JsonIgnore] |
| | | 338 | | public string ExternalSeriesId { get; set; } |
| | | 339 | | |
| | | 340 | | [JsonIgnore] |
| | 0 | 341 | | public virtual bool IsHidden => false; |
| | | 342 | | |
| | | 343 | | /// <summary> |
| | | 344 | | /// Gets the type of the location. |
| | | 345 | | /// </summary> |
| | | 346 | | /// <value>The type of the location.</value> |
| | | 347 | | [JsonIgnore] |
| | | 348 | | public virtual LocationType LocationType |
| | | 349 | | { |
| | | 350 | | get |
| | | 351 | | { |
| | 33 | 352 | | var path = Path; |
| | 33 | 353 | | if (string.IsNullOrEmpty(path)) |
| | | 354 | | { |
| | 17 | 355 | | if (SourceType == SourceType.Channel) |
| | | 356 | | { |
| | 0 | 357 | | return LocationType.Remote; |
| | | 358 | | } |
| | | 359 | | |
| | 17 | 360 | | return LocationType.Virtual; |
| | | 361 | | } |
| | | 362 | | |
| | 16 | 363 | | return FileSystem.IsPathFile(path) ? LocationType.FileSystem : LocationType.Remote; |
| | | 364 | | } |
| | | 365 | | } |
| | | 366 | | |
| | | 367 | | [JsonIgnore] |
| | | 368 | | public MediaProtocol? PathProtocol |
| | | 369 | | { |
| | | 370 | | get |
| | | 371 | | { |
| | 3858 | 372 | | var path = Path; |
| | | 373 | | |
| | 3858 | 374 | | if (string.IsNullOrEmpty(path)) |
| | | 375 | | { |
| | 131 | 376 | | return null; |
| | | 377 | | } |
| | | 378 | | |
| | 3727 | 379 | | return MediaSourceManager.GetPathProtocol(path); |
| | | 380 | | } |
| | | 381 | | } |
| | | 382 | | |
| | | 383 | | [JsonIgnore] |
| | 3815 | 384 | | public bool IsFileProtocol => PathProtocol == MediaProtocol.File; |
| | | 385 | | |
| | | 386 | | [JsonIgnore] |
| | 0 | 387 | | public bool HasPathProtocol => PathProtocol.HasValue; |
| | | 388 | | |
| | | 389 | | [JsonIgnore] |
| | | 390 | | public virtual bool SupportsLocalMetadata |
| | | 391 | | { |
| | | 392 | | get |
| | | 393 | | { |
| | 1839 | 394 | | if (SourceType == SourceType.Channel) |
| | | 395 | | { |
| | 0 | 396 | | return false; |
| | | 397 | | } |
| | | 398 | | |
| | 1839 | 399 | | return IsFileProtocol; |
| | | 400 | | } |
| | | 401 | | } |
| | | 402 | | |
| | | 403 | | [JsonIgnore] |
| | | 404 | | public virtual string FileNameWithoutExtension |
| | | 405 | | { |
| | | 406 | | get |
| | | 407 | | { |
| | 0 | 408 | | if (IsFileProtocol) |
| | | 409 | | { |
| | 0 | 410 | | return System.IO.Path.GetFileNameWithoutExtension(Path); |
| | | 411 | | } |
| | | 412 | | |
| | 0 | 413 | | return null; |
| | | 414 | | } |
| | | 415 | | } |
| | | 416 | | |
| | | 417 | | [JsonIgnore] |
| | 185 | 418 | | public virtual bool EnableAlphaNumericSorting => true; |
| | | 419 | | |
| | 190 | 420 | | public virtual bool IsHD => Height >= 720; |
| | | 421 | | |
| | | 422 | | public bool IsShortcut { get; set; } |
| | | 423 | | |
| | | 424 | | public string ShortcutPath { get; set; } |
| | | 425 | | |
| | | 426 | | public int Width { get; set; } |
| | | 427 | | |
| | | 428 | | public int Height { get; set; } |
| | | 429 | | |
| | | 430 | | /// <summary> |
| | | 431 | | /// Gets the primary image path. |
| | | 432 | | /// </summary> |
| | | 433 | | /// <remarks> |
| | | 434 | | /// This is just a helper for convenience. |
| | | 435 | | /// </remarks> |
| | | 436 | | /// <value>The primary image path.</value> |
| | | 437 | | [JsonIgnore] |
| | 0 | 438 | | public string PrimaryImagePath => this.GetImagePath(ImageType.Primary); |
| | | 439 | | |
| | | 440 | | /// <summary> |
| | | 441 | | /// Gets or sets the date created. |
| | | 442 | | /// </summary> |
| | | 443 | | /// <value>The date created.</value> |
| | | 444 | | [JsonIgnore] |
| | | 445 | | public DateTime DateCreated { get; set; } |
| | | 446 | | |
| | | 447 | | /// <summary> |
| | | 448 | | /// Gets or sets the date modified. |
| | | 449 | | /// </summary> |
| | | 450 | | /// <value>The date modified.</value> |
| | | 451 | | [JsonIgnore] |
| | | 452 | | public DateTime DateModified { get; set; } |
| | | 453 | | |
| | | 454 | | public DateTime DateLastSaved { get; set; } |
| | | 455 | | |
| | | 456 | | [JsonIgnore] |
| | | 457 | | public DateTime DateLastRefreshed { get; set; } |
| | | 458 | | |
| | | 459 | | [JsonIgnore] |
| | | 460 | | public bool IsLocked { get; set; } |
| | | 461 | | |
| | | 462 | | /// <summary> |
| | | 463 | | /// Gets or sets the locked fields. |
| | | 464 | | /// </summary> |
| | | 465 | | /// <value>The locked fields.</value> |
| | | 466 | | [JsonIgnore] |
| | | 467 | | public MetadataField[] LockedFields { get; set; } |
| | | 468 | | |
| | | 469 | | /// <summary> |
| | | 470 | | /// Gets the type of the media. |
| | | 471 | | /// </summary> |
| | | 472 | | /// <value>The type of the media.</value> |
| | | 473 | | [JsonIgnore] |
| | 187 | 474 | | public virtual MediaType MediaType => MediaType.Unknown; |
| | | 475 | | |
| | | 476 | | [JsonIgnore] |
| | | 477 | | public virtual string[] PhysicalLocations |
| | | 478 | | { |
| | | 479 | | get |
| | | 480 | | { |
| | 0 | 481 | | if (!IsFileProtocol) |
| | | 482 | | { |
| | 0 | 483 | | return Array.Empty<string>(); |
| | | 484 | | } |
| | | 485 | | |
| | 0 | 486 | | return [Path]; |
| | | 487 | | } |
| | | 488 | | } |
| | | 489 | | |
| | | 490 | | [JsonIgnore] |
| | | 491 | | public bool EnableMediaSourceDisplay |
| | | 492 | | { |
| | | 493 | | get |
| | | 494 | | { |
| | 6 | 495 | | if (SourceType == SourceType.Channel) |
| | | 496 | | { |
| | 0 | 497 | | return ChannelManager.EnableMediaSourceDisplay(this); |
| | | 498 | | } |
| | | 499 | | |
| | 6 | 500 | | return true; |
| | | 501 | | } |
| | | 502 | | } |
| | | 503 | | |
| | | 504 | | [JsonIgnore] |
| | | 505 | | public Guid ParentId { get; set; } |
| | | 506 | | |
| | | 507 | | /// <summary> |
| | | 508 | | /// Gets or sets the logger. |
| | | 509 | | /// </summary> |
| | | 510 | | public static ILogger<BaseItem> Logger { get; set; } |
| | | 511 | | |
| | | 512 | | public static ILibraryManager LibraryManager { get; set; } |
| | | 513 | | |
| | | 514 | | public static IServerConfigurationManager ConfigurationManager { get; set; } |
| | | 515 | | |
| | | 516 | | public static IProviderManager ProviderManager { get; set; } |
| | | 517 | | |
| | | 518 | | public static ILocalizationManager LocalizationManager { get; set; } |
| | | 519 | | |
| | | 520 | | public static IItemRepository ItemRepository { get; set; } |
| | | 521 | | |
| | | 522 | | public static IItemCountService ItemCountService { get; set; } |
| | | 523 | | |
| | | 524 | | public static IChapterManager ChapterManager { get; set; } |
| | | 525 | | |
| | | 526 | | public static IFileSystem FileSystem { get; set; } |
| | | 527 | | |
| | | 528 | | public static IUserDataManager UserDataManager { get; set; } |
| | | 529 | | |
| | | 530 | | public static IChannelManager ChannelManager { get; set; } |
| | | 531 | | |
| | | 532 | | public static IMediaSourceManager MediaSourceManager { get; set; } |
| | | 533 | | |
| | | 534 | | public static IMediaSegmentManager MediaSegmentManager { get; set; } |
| | | 535 | | |
| | | 536 | | /// <summary> |
| | | 537 | | /// Gets or sets the name of the forced sort. |
| | | 538 | | /// </summary> |
| | | 539 | | /// <value>The name of the forced sort.</value> |
| | | 540 | | [JsonIgnore] |
| | | 541 | | public string ForcedSortName |
| | | 542 | | { |
| | 681 | 543 | | get => _forcedSortName; |
| | | 544 | | set |
| | | 545 | | { |
| | 296 | 546 | | _forcedSortName = value; |
| | 296 | 547 | | _sortName = null; |
| | 296 | 548 | | } |
| | | 549 | | } |
| | | 550 | | |
| | | 551 | | /// <summary> |
| | | 552 | | /// Gets or sets the name of the sort. |
| | | 553 | | /// </summary> |
| | | 554 | | /// <value>The name of the sort.</value> |
| | | 555 | | [JsonIgnore] |
| | | 556 | | public string SortName |
| | | 557 | | { |
| | | 558 | | get |
| | | 559 | | { |
| | 284 | 560 | | if (_sortName is null) |
| | | 561 | | { |
| | 185 | 562 | | if (!string.IsNullOrEmpty(ForcedSortName)) |
| | | 563 | | { |
| | | 564 | | // Run the forced sort name through the same cleaning as auto-generated sort names. |
| | 1 | 565 | | _sortName = GetSortName(ForcedSortName, EnableAlphaNumericSorting, ConfigurationManager.Configur |
| | | 566 | | } |
| | | 567 | | else |
| | | 568 | | { |
| | 184 | 569 | | _sortName = CreateSortName(); |
| | | 570 | | } |
| | | 571 | | } |
| | | 572 | | |
| | 284 | 573 | | return _sortName; |
| | | 574 | | } |
| | | 575 | | |
| | 330 | 576 | | set => _sortName = value; |
| | | 577 | | } |
| | | 578 | | |
| | | 579 | | [JsonIgnore] |
| | 1051 | 580 | | public virtual Guid DisplayParentId => ParentId; |
| | | 581 | | |
| | | 582 | | [JsonIgnore] |
| | | 583 | | public BaseItem DisplayParent |
| | | 584 | | { |
| | | 585 | | get |
| | | 586 | | { |
| | 1064 | 587 | | var id = DisplayParentId; |
| | 1064 | 588 | | if (id.IsEmpty()) |
| | | 589 | | { |
| | 776 | 590 | | return null; |
| | | 591 | | } |
| | | 592 | | |
| | 288 | 593 | | return LibraryManager.GetItemById(id); |
| | | 594 | | } |
| | | 595 | | } |
| | | 596 | | |
| | | 597 | | /// <summary> |
| | | 598 | | /// Gets or sets the date that the item first debuted. For movies this could be premiere date, episodes would be |
| | | 599 | | /// </summary> |
| | | 600 | | /// <value>The premiere date.</value> |
| | | 601 | | [JsonIgnore] |
| | | 602 | | public DateTime? PremiereDate { get; set; } |
| | | 603 | | |
| | | 604 | | /// <summary> |
| | | 605 | | /// Gets or sets the end date. |
| | | 606 | | /// </summary> |
| | | 607 | | /// <value>The end date.</value> |
| | | 608 | | [JsonIgnore] |
| | | 609 | | public DateTime? EndDate { get; set; } |
| | | 610 | | |
| | | 611 | | /// <summary> |
| | | 612 | | /// Gets or sets the official rating. |
| | | 613 | | /// </summary> |
| | | 614 | | /// <value>The official rating.</value> |
| | | 615 | | [JsonIgnore] |
| | | 616 | | public string OfficialRating { get; set; } |
| | | 617 | | |
| | | 618 | | [JsonIgnore] |
| | | 619 | | public int? InheritedParentalRatingValue { get; set; } |
| | | 620 | | |
| | | 621 | | [JsonIgnore] |
| | | 622 | | public int? InheritedParentalRatingSubValue { get; set; } |
| | | 623 | | |
| | | 624 | | /// <summary> |
| | | 625 | | /// Gets or sets the critic rating. |
| | | 626 | | /// </summary> |
| | | 627 | | /// <value>The critic rating.</value> |
| | | 628 | | [JsonIgnore] |
| | | 629 | | public float? CriticRating |
| | | 630 | | { |
| | 511 | 631 | | get => _criticRating; |
| | 437 | 632 | | set => _criticRating = FiniteOrNull(value); |
| | | 633 | | } |
| | | 634 | | |
| | | 635 | | /// <summary> |
| | | 636 | | /// Gets or sets the custom rating. |
| | | 637 | | /// </summary> |
| | | 638 | | /// <value>The custom rating.</value> |
| | | 639 | | [JsonIgnore] |
| | | 640 | | public string CustomRating { get; set; } |
| | | 641 | | |
| | | 642 | | /// <summary> |
| | | 643 | | /// Gets or sets the overview. |
| | | 644 | | /// </summary> |
| | | 645 | | /// <value>The overview.</value> |
| | | 646 | | [JsonIgnore] |
| | | 647 | | public string Overview { get; set; } |
| | | 648 | | |
| | | 649 | | /// <summary> |
| | | 650 | | /// Gets or sets the studios. |
| | | 651 | | /// </summary> |
| | | 652 | | /// <value>The studios.</value> |
| | | 653 | | [JsonIgnore] |
| | | 654 | | public string[] Studios { get; set; } |
| | | 655 | | |
| | | 656 | | /// <summary> |
| | | 657 | | /// Gets or sets the genres. |
| | | 658 | | /// </summary> |
| | | 659 | | /// <value>The genres.</value> |
| | | 660 | | [JsonIgnore] |
| | | 661 | | public string[] Genres { get; set; } |
| | | 662 | | |
| | | 663 | | /// <summary> |
| | | 664 | | /// Gets or sets the tags. |
| | | 665 | | /// </summary> |
| | | 666 | | /// <value>The tags.</value> |
| | | 667 | | [JsonIgnore] |
| | | 668 | | public string[] Tags { get; set; } |
| | | 669 | | |
| | | 670 | | [JsonIgnore] |
| | | 671 | | public string[] ProductionLocations { get; set; } |
| | | 672 | | |
| | | 673 | | /// <summary> |
| | | 674 | | /// Gets or sets the home page URL. |
| | | 675 | | /// </summary> |
| | | 676 | | /// <value>The home page URL.</value> |
| | | 677 | | [JsonIgnore] |
| | | 678 | | public string HomePageUrl { get; set; } |
| | | 679 | | |
| | | 680 | | /// <summary> |
| | | 681 | | /// Gets or sets the community rating. |
| | | 682 | | /// </summary> |
| | | 683 | | /// <value>The community rating.</value> |
| | | 684 | | [JsonIgnore] |
| | | 685 | | public float? CommunityRating |
| | | 686 | | { |
| | 513 | 687 | | get => _communityRating; |
| | 457 | 688 | | set => _communityRating = FiniteOrNull(value); |
| | | 689 | | } |
| | | 690 | | |
| | | 691 | | /// <summary> |
| | | 692 | | /// Gets or sets the run time ticks. |
| | | 693 | | /// </summary> |
| | | 694 | | /// <value>The run time ticks.</value> |
| | | 695 | | [JsonIgnore] |
| | | 696 | | public long? RunTimeTicks { get; set; } |
| | | 697 | | |
| | | 698 | | /// <summary> |
| | | 699 | | /// Gets or sets the production year. |
| | | 700 | | /// </summary> |
| | | 701 | | /// <value>The production year.</value> |
| | | 702 | | [JsonIgnore] |
| | | 703 | | public int? ProductionYear { get; set; } |
| | | 704 | | |
| | | 705 | | /// <summary> |
| | | 706 | | /// Gets or sets the index number. If the item is part of a series, this is it's number in the series. |
| | | 707 | | /// This could be episode number, album track number, etc. |
| | | 708 | | /// </summary> |
| | | 709 | | /// <value>The index number.</value> |
| | | 710 | | [JsonIgnore] |
| | | 711 | | public int? IndexNumber { get; set; } |
| | | 712 | | |
| | | 713 | | /// <summary> |
| | | 714 | | /// Gets or sets the parent index number. For an episode this could be the season number, or for a song this cou |
| | | 715 | | /// </summary> |
| | | 716 | | /// <value>The parent index number.</value> |
| | | 717 | | [JsonIgnore] |
| | | 718 | | public int? ParentIndexNumber { get; set; } |
| | | 719 | | |
| | | 720 | | [JsonIgnore] |
| | 0 | 721 | | public virtual bool HasLocalAlternateVersions => false; |
| | | 722 | | |
| | | 723 | | [JsonIgnore] |
| | | 724 | | public string OfficialRatingForComparison |
| | | 725 | | { |
| | | 726 | | get |
| | | 727 | | { |
| | 532 | 728 | | var officialRating = OfficialRating; |
| | 532 | 729 | | if (!string.IsNullOrEmpty(officialRating)) |
| | | 730 | | { |
| | 11 | 731 | | return officialRating; |
| | | 732 | | } |
| | | 733 | | |
| | 521 | 734 | | var parent = DisplayParent; |
| | 521 | 735 | | if (parent is not null) |
| | | 736 | | { |
| | 141 | 737 | | return parent.OfficialRatingForComparison; |
| | | 738 | | } |
| | | 739 | | |
| | 380 | 740 | | return null; |
| | | 741 | | } |
| | | 742 | | } |
| | | 743 | | |
| | | 744 | | [JsonIgnore] |
| | | 745 | | public string CustomRatingForComparison |
| | | 746 | | { |
| | | 747 | | get |
| | | 748 | | { |
| | 397 | 749 | | return GetCustomRatingForComparision(); |
| | | 750 | | } |
| | | 751 | | } |
| | | 752 | | |
| | | 753 | | /// <summary> |
| | | 754 | | /// Gets or sets the provider ids. |
| | | 755 | | /// </summary> |
| | | 756 | | /// <value>The provider ids.</value> |
| | | 757 | | [JsonIgnore] |
| | | 758 | | public Dictionary<string, string> ProviderIds { get; set; } |
| | | 759 | | |
| | | 760 | | [JsonIgnore] |
| | 0 | 761 | | public virtual Folder LatestItemsIndexContainer => null; |
| | | 762 | | |
| | | 763 | | [JsonIgnore] |
| | | 764 | | public string PresentationUniqueKey { get; set; } |
| | | 765 | | |
| | | 766 | | [JsonIgnore] |
| | 39 | 767 | | public virtual bool EnableRememberingTrackSelections => true; |
| | | 768 | | |
| | | 769 | | [JsonIgnore] |
| | | 770 | | public virtual bool IsTopParent |
| | | 771 | | { |
| | | 772 | | get |
| | | 773 | | { |
| | 402 | 774 | | if (this is BasePluginFolder || this is Channel) |
| | | 775 | | { |
| | 75 | 776 | | return true; |
| | | 777 | | } |
| | | 778 | | |
| | 327 | 779 | | if (this is IHasCollectionType view) |
| | | 780 | | { |
| | 55 | 781 | | if (view.CollectionType == CollectionType.livetv) |
| | | 782 | | { |
| | 0 | 783 | | return true; |
| | | 784 | | } |
| | | 785 | | } |
| | | 786 | | |
| | 327 | 787 | | if (GetParent() is AggregateFolder) |
| | | 788 | | { |
| | 0 | 789 | | return true; |
| | | 790 | | } |
| | | 791 | | |
| | 327 | 792 | | return false; |
| | | 793 | | } |
| | | 794 | | } |
| | | 795 | | |
| | | 796 | | [JsonIgnore] |
| | 684 | 797 | | public virtual bool SupportsAncestors => true; |
| | | 798 | | |
| | | 799 | | [JsonIgnore] |
| | 180 | 800 | | protected virtual bool SupportsOwnedItems => !ParentId.IsEmpty() && IsFileProtocol; |
| | | 801 | | |
| | | 802 | | /// <summary> |
| | | 803 | | /// Gets a value indicating whether this item searches the folder it lives in for its own extras. |
| | | 804 | | /// </summary> |
| | | 805 | | [JsonIgnore] |
| | | 806 | | protected virtual bool SearchesContainingFolderForExtras => |
| | 76 | 807 | | IsFileProtocol |
| | 76 | 808 | | && SupportsOwnedItems |
| | 76 | 809 | | && !IsInMixedFolder |
| | 76 | 810 | | && this is not (ICollectionFolder or UserRootFolder or AggregateFolder) |
| | 76 | 811 | | && GetType() != typeof(Folder); |
| | | 812 | | |
| | | 813 | | [JsonIgnore] |
| | 75 | 814 | | public virtual bool SupportsPeople => false; |
| | | 815 | | |
| | | 816 | | [JsonIgnore] |
| | 0 | 817 | | public virtual bool SupportsThemeMedia => false; |
| | | 818 | | |
| | | 819 | | [JsonIgnore] |
| | 0 | 820 | | public virtual bool SupportsInheritedParentImages => false; |
| | | 821 | | |
| | | 822 | | /// <summary> |
| | | 823 | | /// Gets a value indicating whether this instance is folder. |
| | | 824 | | /// </summary> |
| | | 825 | | /// <value><c>true</c> if this instance is folder; otherwise, <c>false</c>.</value> |
| | | 826 | | [JsonIgnore] |
| | 165 | 827 | | public virtual bool IsFolder => false; |
| | | 828 | | |
| | | 829 | | [JsonIgnore] |
| | 0 | 830 | | public virtual bool IsDisplayedAsFolder => false; |
| | | 831 | | |
| | | 832 | | /// <summary> |
| | | 833 | | /// Gets or sets the remote trailers. |
| | | 834 | | /// </summary> |
| | | 835 | | /// <value>The remote trailers.</value> |
| | | 836 | | public IReadOnlyList<MediaUrl> RemoteTrailers { get; set; } |
| | | 837 | | |
| | | 838 | | private string GetCustomRatingForComparision(HashSet<Guid> callstack = null) |
| | | 839 | | { |
| | 538 | 840 | | callstack ??= new(); |
| | 538 | 841 | | var customRating = CustomRating; |
| | 538 | 842 | | if (!string.IsNullOrEmpty(customRating)) |
| | | 843 | | { |
| | 6 | 844 | | return customRating; |
| | | 845 | | } |
| | | 846 | | |
| | 532 | 847 | | callstack.Add(Id); |
| | | 848 | | |
| | 532 | 849 | | var parent = DisplayParent; |
| | 532 | 850 | | if (parent is not null && !callstack.Contains(parent.Id)) |
| | | 851 | | { |
| | 141 | 852 | | return parent.GetCustomRatingForComparision(callstack); |
| | | 853 | | } |
| | | 854 | | |
| | 391 | 855 | | return null; |
| | | 856 | | } |
| | | 857 | | |
| | | 858 | | public virtual double GetDefaultPrimaryImageAspectRatio() |
| | | 859 | | { |
| | 0 | 860 | | return 0; |
| | | 861 | | } |
| | | 862 | | |
| | | 863 | | public virtual string CreatePresentationUniqueKey() |
| | | 864 | | { |
| | 113 | 865 | | return Id.ToString("N", CultureInfo.InvariantCulture); |
| | | 866 | | } |
| | | 867 | | |
| | | 868 | | public virtual bool CanDelete() |
| | | 869 | | { |
| | 0 | 870 | | if (SourceType == SourceType.Channel) |
| | | 871 | | { |
| | 0 | 872 | | return ChannelManager.CanDelete(this); |
| | | 873 | | } |
| | | 874 | | |
| | 0 | 875 | | return IsFileProtocol; |
| | | 876 | | } |
| | | 877 | | |
| | | 878 | | public virtual bool IsAuthorizedToDelete(User user, List<Folder> allCollectionFolders) |
| | | 879 | | { |
| | 0 | 880 | | if (user.HasPermission(PermissionKind.EnableContentDeletion)) |
| | | 881 | | { |
| | 0 | 882 | | return true; |
| | | 883 | | } |
| | | 884 | | |
| | 0 | 885 | | var allowed = user.GetPreferenceValues<Guid>(PreferenceKind.EnableContentDeletionFromFolders); |
| | | 886 | | |
| | 0 | 887 | | if (SourceType == SourceType.Channel) |
| | | 888 | | { |
| | 0 | 889 | | return allowed.Contains(ChannelId); |
| | | 890 | | } |
| | | 891 | | |
| | 0 | 892 | | var collectionFolders = LibraryManager.GetCollectionFolders(this, allCollectionFolders); |
| | | 893 | | |
| | 0 | 894 | | foreach (var folder in collectionFolders) |
| | | 895 | | { |
| | 0 | 896 | | if (allowed.Contains(folder.Id)) |
| | | 897 | | { |
| | 0 | 898 | | return true; |
| | | 899 | | } |
| | | 900 | | } |
| | | 901 | | |
| | 0 | 902 | | return false; |
| | 0 | 903 | | } |
| | | 904 | | |
| | | 905 | | public BaseItem GetOwner() |
| | | 906 | | { |
| | 957 | 907 | | var ownerId = OwnerId; |
| | 957 | 908 | | return ownerId.IsEmpty() ? null : LibraryManager.GetItemById(ownerId); |
| | | 909 | | } |
| | | 910 | | |
| | | 911 | | public bool CanDelete(User user, List<Folder> allCollectionFolders) |
| | | 912 | | { |
| | 6 | 913 | | return CanDelete() && IsAuthorizedToDelete(user, allCollectionFolders); |
| | | 914 | | } |
| | | 915 | | |
| | | 916 | | public virtual bool CanDelete(User user) |
| | | 917 | | { |
| | 6 | 918 | | var allCollectionFolders = LibraryManager.GetUserRootFolder().Children.OfType<Folder>().ToList(); |
| | | 919 | | |
| | 6 | 920 | | return CanDelete(user, allCollectionFolders); |
| | | 921 | | } |
| | | 922 | | |
| | | 923 | | public virtual bool CanDownload() |
| | | 924 | | { |
| | 6 | 925 | | return false; |
| | | 926 | | } |
| | | 927 | | |
| | | 928 | | public virtual bool IsAuthorizedToDownload(User user) |
| | | 929 | | { |
| | 0 | 930 | | return user.HasPermission(PermissionKind.EnableContentDownloading); |
| | | 931 | | } |
| | | 932 | | |
| | | 933 | | public bool CanDownload(User user) |
| | | 934 | | { |
| | 6 | 935 | | return CanDownload() && IsAuthorizedToDownload(user); |
| | | 936 | | } |
| | | 937 | | |
| | | 938 | | /// <inheritdoc /> |
| | | 939 | | public override string ToString() |
| | | 940 | | { |
| | 69 | 941 | | return Name; |
| | | 942 | | } |
| | | 943 | | |
| | | 944 | | public virtual string GetInternalMetadataPath() |
| | | 945 | | { |
| | 93 | 946 | | var basePath = ConfigurationManager.ApplicationPaths.InternalMetadataPath; |
| | | 947 | | |
| | 93 | 948 | | return GetInternalMetadataPath(basePath); |
| | | 949 | | } |
| | | 950 | | |
| | | 951 | | protected virtual string GetInternalMetadataPath(string basePath) |
| | | 952 | | { |
| | 93 | 953 | | if (SourceType == SourceType.Channel) |
| | | 954 | | { |
| | 0 | 955 | | return System.IO.Path.Join(basePath, "channels", ChannelId.ToString("N", CultureInfo.InvariantCulture), |
| | | 956 | | } |
| | | 957 | | |
| | 93 | 958 | | ReadOnlySpan<char> idString = Id.ToString("N", CultureInfo.InvariantCulture); |
| | | 959 | | |
| | 93 | 960 | | return System.IO.Path.Join(basePath, "library", idString[..2], idString); |
| | | 961 | | } |
| | | 962 | | |
| | | 963 | | /// <summary> |
| | | 964 | | /// Creates the name of the sort. |
| | | 965 | | /// </summary> |
| | | 966 | | /// <returns>System.String.</returns> |
| | | 967 | | protected virtual string CreateSortName() |
| | | 968 | | { |
| | 184 | 969 | | return GetSortName(Name, EnableAlphaNumericSorting, ConfigurationManager.Configuration); |
| | | 970 | | } |
| | | 971 | | |
| | | 972 | | /// <summary> |
| | | 973 | | /// Turns an item-by-name entity's name into a folder name every supported filesystem accepts. |
| | | 974 | | /// </summary> |
| | | 975 | | /// <param name="name">The entity's name.</param> |
| | | 976 | | /// <returns>The folder name.</returns> |
| | | 977 | | public static string GetItemByNameFolderName(string name) |
| | | 978 | | { |
| | | 979 | | // Trim the period at the end because windows will have a hard time with that |
| | 7 | 980 | | var validName = FileSystem.GetValidFilename(name).Trim().TrimEnd('.'); |
| | | 981 | | |
| | | 982 | | // Most Linux filesystems cap a path component at 255 bytes, so a name past that cannot be |
| | | 983 | | // turned into a folder at all - and an entity with no folder can never be created, which |
| | | 984 | | // leaves the credit behind it stuck: not refreshable, not deletable, retried on every scan. |
| | | 985 | | // Only broken provider data gets this long, but it still has to resolve to something, so |
| | | 986 | | // keep a readable prefix and let a hash of the whole name tell two of them apart. |
| | 7 | 987 | | if (Encoding.UTF8.GetByteCount(validName) <= MaxItemByNameFolderNameBytes) |
| | | 988 | | { |
| | 2 | 989 | | return validName; |
| | | 990 | | } |
| | | 991 | | |
| | 5 | 992 | | var suffix = "-" + validName.GetMD5().ToString("N", CultureInfo.InvariantCulture); |
| | 5 | 993 | | var budget = MaxItemByNameFolderNameBytes - suffix.Length; |
| | 5 | 994 | | var length = Math.Min(validName.Length, budget); |
| | 5 | 995 | | while (length > 0 && Encoding.UTF8.GetByteCount(validName.AsSpan(0, length)) > budget) |
| | | 996 | | { |
| | 0 | 997 | | length--; |
| | | 998 | | } |
| | | 999 | | |
| | | 1000 | | // Never cut a surrogate pair in half, the lone half is not a valid file name character. |
| | 5 | 1001 | | if (length > 0 && char.IsHighSurrogate(validName[length - 1])) |
| | | 1002 | | { |
| | 0 | 1003 | | length--; |
| | | 1004 | | } |
| | | 1005 | | |
| | 5 | 1006 | | return string.Concat(validName.AsSpan(0, length).TrimEnd().TrimEnd('.'), suffix); |
| | | 1007 | | } |
| | | 1008 | | |
| | | 1009 | | /// <summary> |
| | | 1010 | | /// Cleans a raw name into its sortable form by applying the configured sort rules. |
| | | 1011 | | /// </summary> |
| | | 1012 | | /// <param name="name">The raw name to clean.</param> |
| | | 1013 | | /// <param name="enableAlphaNumericSorting">Whether alphanumeric sorting rules should be applied.</param> |
| | | 1014 | | /// <param name="configuration">The server configuration providing the sort rules.</param> |
| | | 1015 | | /// <returns>The cleaned, sortable name, or <c>null</c> if <paramref name="name"/> is <c>null</c>.</returns> |
| | | 1016 | | public static string GetSortName(string name, bool enableAlphaNumericSorting, ServerConfiguration configuration) |
| | | 1017 | | { |
| | 191 | 1018 | | if (name is null) |
| | | 1019 | | { |
| | 0 | 1020 | | return null; // some items may not have name filled in properly |
| | | 1021 | | } |
| | | 1022 | | |
| | 191 | 1023 | | if (!enableAlphaNumericSorting) |
| | | 1024 | | { |
| | 1 | 1025 | | return name.TrimStart(); |
| | | 1026 | | } |
| | | 1027 | | |
| | 190 | 1028 | | var sortable = name.Trim().ToLowerInvariant(); |
| | | 1029 | | |
| | 1520 | 1030 | | foreach (var search in configuration.SortRemoveWords) |
| | | 1031 | | { |
| | | 1032 | | // Remove from beginning if a space follows |
| | 570 | 1033 | | if (sortable.StartsWith(search + " ", StringComparison.Ordinal)) |
| | | 1034 | | { |
| | 6 | 1035 | | sortable = sortable.Remove(0, search.Length + 1); |
| | | 1036 | | } |
| | | 1037 | | |
| | | 1038 | | // Remove from middle if surrounded by spaces |
| | 570 | 1039 | | sortable = sortable.Replace(" " + search + " ", " ", StringComparison.Ordinal); |
| | | 1040 | | |
| | | 1041 | | // Remove from end if preceeded by a space |
| | 570 | 1042 | | if (sortable.EndsWith(" " + search, StringComparison.Ordinal)) |
| | | 1043 | | { |
| | 0 | 1044 | | sortable = sortable.Remove(sortable.Length - (search.Length + 1)); |
| | | 1045 | | } |
| | | 1046 | | } |
| | | 1047 | | |
| | 190 | 1048 | | return ModifySortChunks(ApplySortCharacterRules(sortable, configuration)); |
| | | 1049 | | } |
| | | 1050 | | |
| | | 1051 | | private static string ApplySortCharacterRules(string name, ServerConfiguration configuration) |
| | | 1052 | | { |
| | 3066 | 1053 | | foreach (var removeChar in configuration.SortRemoveCharacters) |
| | | 1054 | | { |
| | 1314 | 1055 | | name = name.Replace(removeChar, string.Empty, StringComparison.Ordinal); |
| | | 1056 | | } |
| | | 1057 | | |
| | 1752 | 1058 | | foreach (var replaceChar in configuration.SortReplaceCharacters) |
| | | 1059 | | { |
| | 657 | 1060 | | name = name.Replace(replaceChar, " ", StringComparison.Ordinal); |
| | | 1061 | | } |
| | | 1062 | | |
| | 219 | 1063 | | return name; |
| | | 1064 | | } |
| | | 1065 | | |
| | | 1066 | | /// <summary> |
| | | 1067 | | /// Normalizes a user-provided name filter value to match against <see cref="SortName"/>. |
| | | 1068 | | /// Applies the same character removal/replacement, zero-padding, diacritics removal, and transliteration |
| | | 1069 | | /// as sort name generation, but not <c>SortRemoveWords</c> since stripping articles from a prefix is unsafe. |
| | | 1070 | | /// </summary> |
| | | 1071 | | /// <param name="input">The raw filter value from the API.</param> |
| | | 1072 | | /// <returns>The normalized value suitable for comparison against SortName. Casing is preserved; callers requiri |
| | | 1073 | | public static string NormalizeSortNameFilter(string input) |
| | 29 | 1074 | | => ModifySortChunks(ApplySortCharacterRules(input, ConfigurationManager.Configuration)); |
| | | 1075 | | |
| | | 1076 | | /// <summary> |
| | | 1077 | | /// Processes a name by zero-padding numeric chunks to 10 digits for natural sort order, |
| | | 1078 | | /// removing diacritics, and transliterating non-ASCII characters. |
| | | 1079 | | /// </summary> |
| | | 1080 | | /// <param name="name">The input name to process.</param> |
| | | 1081 | | /// <returns>The processed string with padded numeric chunks.</returns> |
| | | 1082 | | public static string ModifySortChunks(ReadOnlySpan<char> name) |
| | | 1083 | | { |
| | | 1084 | | static void AppendChunk(StringBuilder builder, bool isDigitChunk, ReadOnlySpan<char> chunk) |
| | | 1085 | | { |
| | | 1086 | | if (isDigitChunk && chunk.Length < 10) |
| | | 1087 | | { |
| | | 1088 | | builder.Append('0', 10 - chunk.Length); |
| | | 1089 | | } |
| | | 1090 | | |
| | | 1091 | | builder.Append(chunk); |
| | | 1092 | | } |
| | | 1093 | | |
| | 225 | 1094 | | if (name.IsEmpty) |
| | | 1095 | | { |
| | 1 | 1096 | | return string.Empty; |
| | | 1097 | | } |
| | | 1098 | | |
| | 224 | 1099 | | var builder = new StringBuilder(name.Length); |
| | | 1100 | | |
| | 224 | 1101 | | int chunkStart = 0; |
| | 224 | 1102 | | bool isDigitChunk = char.IsDigit(name[0]); |
| | 3610 | 1103 | | for (int i = 0; i < name.Length; i++) |
| | | 1104 | | { |
| | 1581 | 1105 | | var isDigit = char.IsDigit(name[i]); |
| | 1581 | 1106 | | if (isDigit != isDigitChunk) |
| | | 1107 | | { |
| | 28 | 1108 | | AppendChunk(builder, isDigitChunk, name.Slice(chunkStart, i - chunkStart)); |
| | 28 | 1109 | | chunkStart = i; |
| | 28 | 1110 | | isDigitChunk = isDigit; |
| | | 1111 | | } |
| | | 1112 | | } |
| | | 1113 | | |
| | 224 | 1114 | | AppendChunk(builder, isDigitChunk, name.Slice(chunkStart)); |
| | | 1115 | | |
| | | 1116 | | // logger.LogDebug("ModifySortChunks Start: {0} End: {1}", name, builder.ToString()); |
| | 224 | 1117 | | var result = builder.ToString().RemoveDiacritics(); |
| | 224 | 1118 | | if (!result.All(char.IsAscii)) |
| | | 1119 | | { |
| | 0 | 1120 | | result = result.Transliterated(); |
| | | 1121 | | } |
| | | 1122 | | |
| | 224 | 1123 | | return result; |
| | | 1124 | | } |
| | | 1125 | | |
| | | 1126 | | public BaseItem GetParent() |
| | | 1127 | | { |
| | 3032 | 1128 | | var parentId = ParentId; |
| | 3032 | 1129 | | if (parentId.IsEmpty()) |
| | | 1130 | | { |
| | 2448 | 1131 | | return null; |
| | | 1132 | | } |
| | | 1133 | | |
| | 584 | 1134 | | return LibraryManager.GetItemById(parentId); |
| | | 1135 | | } |
| | | 1136 | | |
| | | 1137 | | public IEnumerable<BaseItem> GetParents() |
| | | 1138 | | { |
| | 967 | 1139 | | var parent = GetParent(); |
| | | 1140 | | |
| | 1118 | 1141 | | while (parent is not null) |
| | | 1142 | | { |
| | 152 | 1143 | | yield return parent; |
| | | 1144 | | |
| | 151 | 1145 | | parent = parent.GetParent(); |
| | | 1146 | | } |
| | 966 | 1147 | | } |
| | | 1148 | | |
| | | 1149 | | /// <summary> |
| | | 1150 | | /// Finds a parent of a given type. |
| | | 1151 | | /// </summary> |
| | | 1152 | | /// <typeparam name="T">Type of parent.</typeparam> |
| | | 1153 | | /// <returns>``0.</returns> |
| | | 1154 | | public T FindParent<T>() |
| | | 1155 | | where T : Folder |
| | | 1156 | | { |
| | 84 | 1157 | | foreach (var parent in GetParents()) |
| | | 1158 | | { |
| | 0 | 1159 | | if (parent is T item) |
| | | 1160 | | { |
| | 0 | 1161 | | return item; |
| | | 1162 | | } |
| | | 1163 | | } |
| | | 1164 | | |
| | 42 | 1165 | | return null; |
| | 0 | 1166 | | } |
| | | 1167 | | |
| | | 1168 | | /// <summary> |
| | | 1169 | | /// Gets the play access. |
| | | 1170 | | /// </summary> |
| | | 1171 | | /// <param name="user">The user.</param> |
| | | 1172 | | /// <returns>PlayAccess.</returns> |
| | | 1173 | | public PlayAccess GetPlayAccess(User user) |
| | | 1174 | | { |
| | 6 | 1175 | | if (!user.HasPermission(PermissionKind.EnableMediaPlayback)) |
| | | 1176 | | { |
| | 0 | 1177 | | return PlayAccess.None; |
| | | 1178 | | } |
| | | 1179 | | |
| | | 1180 | | // if (!user.IsParentalScheduleAllowed()) |
| | | 1181 | | // { |
| | | 1182 | | // return PlayAccess.None; |
| | | 1183 | | // } |
| | | 1184 | | |
| | 6 | 1185 | | return PlayAccess.Full; |
| | | 1186 | | } |
| | | 1187 | | |
| | | 1188 | | public virtual IReadOnlyList<MediaStream> GetMediaStreams() |
| | | 1189 | | { |
| | 0 | 1190 | | return MediaSourceManager.GetMediaStreams(new MediaStreamQuery |
| | 0 | 1191 | | { |
| | 0 | 1192 | | ItemId = Id |
| | 0 | 1193 | | }); |
| | | 1194 | | } |
| | | 1195 | | |
| | | 1196 | | protected virtual bool IsActiveRecording() |
| | | 1197 | | { |
| | 0 | 1198 | | return false; |
| | | 1199 | | } |
| | | 1200 | | |
| | | 1201 | | public virtual IReadOnlyList<MediaSourceInfo> GetMediaSources(bool enablePathSubstitution) |
| | | 1202 | | { |
| | 8 | 1203 | | if (SourceType == SourceType.Channel) |
| | | 1204 | | { |
| | 0 | 1205 | | var sources = ChannelManager.GetStaticMediaSources(this, CancellationToken.None) |
| | 0 | 1206 | | .ToList(); |
| | | 1207 | | |
| | 0 | 1208 | | if (sources.Count > 0) |
| | | 1209 | | { |
| | 0 | 1210 | | return sources; |
| | | 1211 | | } |
| | | 1212 | | } |
| | | 1213 | | |
| | 8 | 1214 | | var list = GetAllItemsForMediaSources().ToList(); |
| | 8 | 1215 | | var commonPrefix = GetCommonNamePrefix(list); |
| | 8 | 1216 | | var result = list.Select(i => GetVersionInfo(enablePathSubstitution, i.Item, i.MediaSourceType, commonPrefix |
| | | 1217 | | |
| | 8 | 1218 | | if (IsActiveRecording()) |
| | | 1219 | | { |
| | 0 | 1220 | | foreach (var mediaSource in result) |
| | | 1221 | | { |
| | 0 | 1222 | | mediaSource.Type = MediaSourceType.Placeholder; |
| | | 1223 | | } |
| | | 1224 | | } |
| | | 1225 | | |
| | | 1226 | | // The source belonging to the item being queried sorts first so it is the default the client plays. |
| | 8 | 1227 | | var selfId = Id.ToString("N", CultureInfo.InvariantCulture); |
| | | 1228 | | |
| | 8 | 1229 | | return result |
| | 8 | 1230 | | .OrderByDescending(i => string.Equals(i.Id, selfId, StringComparison.OrdinalIgnoreCase)) |
| | 8 | 1231 | | .ThenBy(i => i.VideoType == VideoType.VideoFile ? 0 : 1) |
| | 8 | 1232 | | .ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0) |
| | 8 | 1233 | | .ThenByDescending(i => i, new MediaSourceWidthComparator()) |
| | 8 | 1234 | | .ToArray(); |
| | | 1235 | | } |
| | | 1236 | | |
| | | 1237 | | protected virtual IEnumerable<(BaseItem Item, MediaSourceType MediaSourceType)> GetAllItemsForMediaSources() |
| | | 1238 | | { |
| | 0 | 1239 | | return Enumerable.Empty<(BaseItem, MediaSourceType)>(); |
| | | 1240 | | } |
| | | 1241 | | |
| | | 1242 | | private MediaSourceInfo GetVersionInfo(bool enablePathSubstitution, BaseItem item, MediaSourceType type, string |
| | | 1243 | | { |
| | 22 | 1244 | | ArgumentNullException.ThrowIfNull(item); |
| | | 1245 | | |
| | 22 | 1246 | | var protocol = item.PathProtocol; |
| | 22 | 1247 | | var itemPath = item.Path; |
| | | 1248 | | |
| | 22 | 1249 | | var info = new MediaSourceInfo |
| | 22 | 1250 | | { |
| | 22 | 1251 | | Id = item.Id.ToString("N", CultureInfo.InvariantCulture), |
| | 22 | 1252 | | Protocol = protocol ?? MediaProtocol.File, |
| | 22 | 1253 | | MediaStreams = MediaSourceManager.GetMediaStreams(item.Id), |
| | 22 | 1254 | | MediaAttachments = MediaSourceManager.GetMediaAttachments(item.Id), |
| | 22 | 1255 | | Name = GetMediaSourceName(item, commonPrefix), |
| | 22 | 1256 | | Path = enablePathSubstitution ? GetMappedPath(item, itemPath, protocol) : itemPath, |
| | 22 | 1257 | | RunTimeTicks = item.RunTimeTicks, |
| | 22 | 1258 | | Container = item.Container, |
| | 22 | 1259 | | Size = item.Size, |
| | 22 | 1260 | | Type = type, |
| | 22 | 1261 | | HasSegments = MediaSegmentManager.IsTypeSupported(item) |
| | 22 | 1262 | | && (protocol is null or MediaProtocol.File) |
| | 22 | 1263 | | && MediaSegmentManager.HasSegments(item.Id) |
| | 22 | 1264 | | }; |
| | | 1265 | | |
| | 22 | 1266 | | if (string.IsNullOrEmpty(info.Path)) |
| | | 1267 | | { |
| | 0 | 1268 | | info.Type = MediaSourceType.Placeholder; |
| | | 1269 | | } |
| | | 1270 | | |
| | 22 | 1271 | | if (info.Protocol == MediaProtocol.File) |
| | | 1272 | | { |
| | 22 | 1273 | | info.ETag = item.DateModified.Ticks.ToString(CultureInfo.InvariantCulture).GetMD5().ToString("N", Cultur |
| | | 1274 | | } |
| | | 1275 | | |
| | 22 | 1276 | | var video = item as Video; |
| | 22 | 1277 | | if (video is not null) |
| | | 1278 | | { |
| | 22 | 1279 | | info.IsoType = video.IsoType; |
| | 22 | 1280 | | info.VideoType = video.VideoType; |
| | 22 | 1281 | | info.Video3DFormat = video.Video3DFormat; |
| | 22 | 1282 | | info.Timestamp = video.Timestamp; |
| | | 1283 | | |
| | 22 | 1284 | | if (video.IsShortcut && !string.IsNullOrEmpty(video.ShortcutPath)) |
| | | 1285 | | { |
| | 0 | 1286 | | var shortcutProtocol = MediaSourceManager.GetPathProtocol(video.ShortcutPath); |
| | | 1287 | | |
| | | 1288 | | // Only allow remote shortcut paths — local file paths in .strm files |
| | | 1289 | | // could be used to read arbitrary files from the server. |
| | 0 | 1290 | | if (shortcutProtocol != MediaProtocol.File) |
| | | 1291 | | { |
| | 0 | 1292 | | info.IsRemote = true; |
| | 0 | 1293 | | info.Path = video.ShortcutPath; |
| | 0 | 1294 | | info.Protocol = shortcutProtocol; |
| | | 1295 | | } |
| | | 1296 | | } |
| | | 1297 | | |
| | 22 | 1298 | | if (string.IsNullOrEmpty(info.Container)) |
| | | 1299 | | { |
| | 22 | 1300 | | if (video.VideoType == VideoType.VideoFile || video.VideoType == VideoType.Iso) |
| | | 1301 | | { |
| | 22 | 1302 | | if (protocol.HasValue && protocol.Value == MediaProtocol.File) |
| | | 1303 | | { |
| | 22 | 1304 | | info.Container = System.IO.Path.GetExtension(item.Path).TrimStart('.'); |
| | | 1305 | | } |
| | | 1306 | | } |
| | | 1307 | | } |
| | | 1308 | | } |
| | | 1309 | | |
| | 22 | 1310 | | if (string.IsNullOrEmpty(info.Container)) |
| | | 1311 | | { |
| | 0 | 1312 | | if (protocol.HasValue && protocol.Value == MediaProtocol.File) |
| | | 1313 | | { |
| | 0 | 1314 | | info.Container = System.IO.Path.GetExtension(item.Path).TrimStart('.'); |
| | | 1315 | | } |
| | | 1316 | | } |
| | | 1317 | | |
| | 22 | 1318 | | if (info.SupportsDirectStream && !string.IsNullOrEmpty(info.Path)) |
| | | 1319 | | { |
| | 22 | 1320 | | info.SupportsDirectStream = MediaSourceManager.SupportsDirectStream(info.Path, info.Protocol); |
| | | 1321 | | } |
| | | 1322 | | |
| | 22 | 1323 | | if (video is not null && video.VideoType != VideoType.VideoFile) |
| | | 1324 | | { |
| | 0 | 1325 | | info.SupportsDirectStream = false; |
| | | 1326 | | } |
| | | 1327 | | |
| | 22 | 1328 | | info.Bitrate = item.TotalBitrate; |
| | 22 | 1329 | | info.InferTotalBitrate(); |
| | | 1330 | | |
| | 22 | 1331 | | return info; |
| | | 1332 | | } |
| | | 1333 | | |
| | | 1334 | | internal string GetMediaSourceName(BaseItem item, string commonPrefix = null) |
| | | 1335 | | { |
| | 48 | 1336 | | var terms = new List<string>(); |
| | | 1337 | | |
| | 48 | 1338 | | var path = item.Path; |
| | 48 | 1339 | | if (item.IsFileProtocol && !string.IsNullOrEmpty(path)) |
| | | 1340 | | { |
| | 48 | 1341 | | var displayName = System.IO.Path.GetFileNameWithoutExtension(path); |
| | | 1342 | | |
| | | 1343 | | // Prefer the suffix that differs from the other versions: strip the prefix shared by |
| | | 1344 | | // all sibling files. This works regardless of folder layout, so it also labels episode |
| | | 1345 | | // versions that share a season folder (e.g. "Greyscale" instead of the full |
| | | 1346 | | // "Show - S01E02 - Title - Greyscale"). The prefix is already retreated to a delimiter |
| | | 1347 | | // boundary (see GetCommonVersionPrefix). |
| | 48 | 1348 | | if (!string.IsNullOrEmpty(commonPrefix) |
| | 48 | 1349 | | && displayName.Length > commonPrefix.Length |
| | 48 | 1350 | | && displayName.StartsWith(commonPrefix, StringComparison.OrdinalIgnoreCase)) |
| | | 1351 | | { |
| | 35 | 1352 | | var name = displayName.AsSpan(commonPrefix.Length).TrimStart([' ', .. VersionDelimiters]); |
| | 35 | 1353 | | if (!name.IsWhiteSpace()) |
| | | 1354 | | { |
| | 35 | 1355 | | terms.Add(name.ToString()); |
| | | 1356 | | } |
| | | 1357 | | } |
| | | 1358 | | |
| | | 1359 | | // Fall back to the containing folder name (the common layout for movie versions, and |
| | | 1360 | | // the path taken when no common prefix could be derived). |
| | 48 | 1361 | | if (terms.Count == 0 && HasLocalAlternateVersions) |
| | | 1362 | | { |
| | 8 | 1363 | | var containingFolderName = System.IO.Path.GetFileName(ContainingFolderPath); |
| | 8 | 1364 | | if (displayName.Length > containingFolderName.Length && displayName.StartsWith(containingFolderName, |
| | | 1365 | | { |
| | 2 | 1366 | | var name = displayName.AsSpan(containingFolderName.Length).TrimStart([' ', .. VersionDelimiters] |
| | 2 | 1367 | | if (!name.IsWhiteSpace()) |
| | | 1368 | | { |
| | 2 | 1369 | | terms.Add(name.ToString()); |
| | | 1370 | | } |
| | | 1371 | | } |
| | | 1372 | | } |
| | | 1373 | | |
| | 48 | 1374 | | if (terms.Count == 0) |
| | | 1375 | | { |
| | 11 | 1376 | | terms.Add(displayName); |
| | | 1377 | | } |
| | | 1378 | | } |
| | | 1379 | | |
| | 48 | 1380 | | if (terms.Count == 0) |
| | | 1381 | | { |
| | 0 | 1382 | | terms.Add(item.Name); |
| | | 1383 | | } |
| | | 1384 | | |
| | 48 | 1385 | | if (item is Video video) |
| | | 1386 | | { |
| | 48 | 1387 | | if (video.Video3DFormat.HasValue) |
| | | 1388 | | { |
| | 0 | 1389 | | terms.Add("3D"); |
| | | 1390 | | } |
| | | 1391 | | |
| | 48 | 1392 | | if (video.VideoType == VideoType.BluRay) |
| | | 1393 | | { |
| | 0 | 1394 | | terms.Add("Bluray"); |
| | | 1395 | | } |
| | 48 | 1396 | | else if (video.VideoType == VideoType.Dvd) |
| | | 1397 | | { |
| | 0 | 1398 | | terms.Add("DVD"); |
| | | 1399 | | } |
| | 48 | 1400 | | else if (video.VideoType == VideoType.Iso) |
| | | 1401 | | { |
| | 0 | 1402 | | if (video.IsoType.HasValue) |
| | | 1403 | | { |
| | 0 | 1404 | | if (video.IsoType.Value == IsoType.BluRay) |
| | | 1405 | | { |
| | 0 | 1406 | | terms.Add("Bluray"); |
| | | 1407 | | } |
| | 0 | 1408 | | else if (video.IsoType.Value == IsoType.Dvd) |
| | | 1409 | | { |
| | 0 | 1410 | | terms.Add("DVD"); |
| | | 1411 | | } |
| | | 1412 | | } |
| | | 1413 | | else |
| | | 1414 | | { |
| | 0 | 1415 | | terms.Add("ISO"); |
| | | 1416 | | } |
| | | 1417 | | } |
| | | 1418 | | } |
| | | 1419 | | |
| | 48 | 1420 | | return string.Join('/', terms); |
| | | 1421 | | } |
| | | 1422 | | |
| | | 1423 | | /// <summary> |
| | | 1424 | | /// Treats a rating or gain that is not a finite number as no value, since NaN and infinity |
| | | 1425 | | /// cannot be stored by every database or written as JSON. |
| | | 1426 | | /// </summary> |
| | | 1427 | | /// <param name="value">The value to check.</param> |
| | | 1428 | | /// <returns><paramref name="value"/> when it is finite or has no value, otherwise <see langword="null"/>.</retu |
| | | 1429 | | private static float? FiniteOrNull(float? value) |
| | 1430 | 1430 | | => value.HasValue && !float.IsFinite(value.Value) ? null : value; |
| | | 1431 | | |
| | | 1432 | | /// <summary> |
| | | 1433 | | /// Derives the prefix shared by the supplied media source items' file names, used to strip the |
| | | 1434 | | /// common part and surface a short version label per source. Returns null when there are fewer |
| | | 1435 | | /// than two file-based sources, since there is nothing to differentiate. |
| | | 1436 | | /// </summary> |
| | | 1437 | | /// <param name="items">The media source items.</param> |
| | | 1438 | | /// <returns>The shared prefix, or null when no useful prefix exists.</returns> |
| | | 1439 | | private static string GetCommonNamePrefix(IReadOnlyList<(BaseItem Item, MediaSourceType MediaSourceType)> items) |
| | | 1440 | | { |
| | 8 | 1441 | | var fileNames = new List<string>(); |
| | 60 | 1442 | | foreach (var (item, _) in items) |
| | | 1443 | | { |
| | 22 | 1444 | | if (item.IsFileProtocol && !string.IsNullOrEmpty(item.Path)) |
| | | 1445 | | { |
| | 22 | 1446 | | fileNames.Add(System.IO.Path.GetFileNameWithoutExtension(item.Path)); |
| | | 1447 | | } |
| | | 1448 | | } |
| | | 1449 | | |
| | 8 | 1450 | | if (fileNames.Count < 2) |
| | | 1451 | | { |
| | 0 | 1452 | | return null; |
| | | 1453 | | } |
| | | 1454 | | |
| | 8 | 1455 | | var prefix = GetCommonVersionPrefix(fileNames); |
| | 8 | 1456 | | return string.IsNullOrEmpty(prefix) ? null : prefix; |
| | | 1457 | | } |
| | | 1458 | | |
| | | 1459 | | /// <summary> |
| | | 1460 | | /// Computes the case-insensitive longest common prefix of the supplied version file names, |
| | | 1461 | | /// retreated to the last delimiter boundary. Retreating keeps the differing suffix intact: |
| | | 1462 | | /// it avoids slicing through a word every version shares (e.g. "Grey" in "Greyscale" and |
| | | 1463 | | /// "Greyish") while still trimming the common part when every version is suffixed (e.g. |
| | | 1464 | | /// "- Greyscale" / "- Colorized"). It prefers a structural delimiter ('-', '_', '.') so a |
| | | 1465 | | /// token shared by the descriptors but separated only by spaces (e.g. a common "2160p ") is |
| | | 1466 | | /// kept in the label, falling back to a space only when no structural delimiter is shared. The |
| | | 1467 | | /// separators mirror the version delimiters recognised by the naming layer (Emby.Naming |
| | | 1468 | | /// VideoFlagDelimiters), except that a dot between digits is a decimal point rather than a |
| | | 1469 | | /// delimiter, so numeric version labels stay whole. |
| | | 1470 | | /// </summary> |
| | | 1471 | | /// <param name="fileNames">The version file names without extension; must contain at least one entry.</param> |
| | | 1472 | | /// <returns>The shared prefix retreated to a separator boundary, or an empty string when none is shared.</retur |
| | | 1473 | | internal static string GetCommonVersionPrefix(IReadOnlyList<string> fileNames) |
| | | 1474 | | { |
| | 20 | 1475 | | var prefix = fileNames[0]; |
| | 94 | 1476 | | for (var i = 1; i < fileNames.Count && prefix.Length > 0; i++) |
| | | 1477 | | { |
| | 27 | 1478 | | var name = fileNames[i]; |
| | 27 | 1479 | | var length = Math.Min(prefix.Length, name.Length); |
| | 27 | 1480 | | var common = 0; |
| | 433 | 1481 | | while (common < length && char.ToUpperInvariant(prefix[common]) == char.ToUpperInvariant(name[common])) |
| | | 1482 | | { |
| | 406 | 1483 | | common++; |
| | | 1484 | | } |
| | | 1485 | | |
| | 27 | 1486 | | prefix = prefix[..common]; |
| | | 1487 | | } |
| | | 1488 | | |
| | | 1489 | | // If the common prefix is itself a whole file name then one version is unlabelled (the |
| | | 1490 | | // base name); the boundary already sits at the end of that name, so don't retreat into it. |
| | 20 | 1491 | | var prefixIsWholeName = false; |
| | 94 | 1492 | | for (var i = 0; i < fileNames.Count; i++) |
| | | 1493 | | { |
| | 36 | 1494 | | if (fileNames[i].Length == prefix.Length) |
| | | 1495 | | { |
| | 9 | 1496 | | prefixIsWholeName = true; |
| | 9 | 1497 | | break; |
| | | 1498 | | } |
| | | 1499 | | } |
| | | 1500 | | |
| | 20 | 1501 | | if (!prefixIsWholeName) |
| | | 1502 | | { |
| | | 1503 | | // Retreat to the last structural delimiter ('-', '_', '.'), skipping dots that are |
| | | 1504 | | // decimal points within a number rather than delimiters (see IsDecimalPoint). |
| | 11 | 1505 | | var cut = prefix.Length; |
| | 71 | 1506 | | while (cut > 0 |
| | 71 | 1507 | | && (Array.IndexOf(VersionDelimiters, prefix[cut - 1]) < 0 |
| | 71 | 1508 | | || IsDecimalPoint(prefix, cut - 1, fileNames))) |
| | | 1509 | | { |
| | 60 | 1510 | | cut--; |
| | | 1511 | | } |
| | | 1512 | | |
| | 11 | 1513 | | if (cut == 0) |
| | | 1514 | | { |
| | 2 | 1515 | | cut = prefix.Length; |
| | 5 | 1516 | | while (cut > 0 && prefix[cut - 1] != ' ') |
| | | 1517 | | { |
| | 3 | 1518 | | cut--; |
| | | 1519 | | } |
| | | 1520 | | } |
| | | 1521 | | |
| | 11 | 1522 | | prefix = prefix[..cut]; |
| | | 1523 | | } |
| | | 1524 | | |
| | 20 | 1525 | | return prefix; |
| | | 1526 | | } |
| | | 1527 | | |
| | | 1528 | | private static bool IsDecimalPoint(string prefix, int index, IReadOnlyList<string> fileNames) |
| | | 1529 | | { |
| | 12 | 1530 | | if (index == 0 || prefix[index] != '.' || !char.IsDigit(prefix[index - 1])) |
| | | 1531 | | { |
| | 8 | 1532 | | return false; |
| | | 1533 | | } |
| | | 1534 | | |
| | 4 | 1535 | | if (index + 1 < prefix.Length) |
| | | 1536 | | { |
| | 0 | 1537 | | return char.IsDigit(prefix[index + 1]); |
| | | 1538 | | } |
| | | 1539 | | |
| | | 1540 | | // The dot ends the prefix, so the character after it is the first one that differs between |
| | | 1541 | | // the versions: only a decimal point when every version continues the number. |
| | 22 | 1542 | | for (var i = 0; i < fileNames.Count; i++) |
| | | 1543 | | { |
| | 8 | 1544 | | if (fileNames[i].Length <= index + 1 || !char.IsDigit(fileNames[i][index + 1])) |
| | | 1545 | | { |
| | 1 | 1546 | | return false; |
| | | 1547 | | } |
| | | 1548 | | } |
| | | 1549 | | |
| | 3 | 1550 | | return true; |
| | | 1551 | | } |
| | | 1552 | | |
| | | 1553 | | public Task RefreshMetadata(CancellationToken cancellationToken) |
| | | 1554 | | { |
| | 82 | 1555 | | return RefreshMetadata(new MetadataRefreshOptions(new DirectoryService(FileSystem)), cancellationToken); |
| | | 1556 | | } |
| | | 1557 | | |
| | | 1558 | | /// <summary> |
| | | 1559 | | /// The base implementation to refresh metadata. |
| | | 1560 | | /// </summary> |
| | | 1561 | | /// <param name="options">The options.</param> |
| | | 1562 | | /// <param name="cancellationToken">The cancellation token.</param> |
| | | 1563 | | /// <returns>true if a provider reports we changed.</returns> |
| | | 1564 | | public async Task<ItemUpdateType> RefreshMetadata(MetadataRefreshOptions options, CancellationToken cancellation |
| | | 1565 | | { |
| | 106 | 1566 | | var requiresSave = false; |
| | | 1567 | | |
| | 106 | 1568 | | if (SupportsOwnedItems) |
| | | 1569 | | { |
| | | 1570 | | try |
| | | 1571 | | { |
| | 72 | 1572 | | if (IsFileProtocol) |
| | | 1573 | | { |
| | 72 | 1574 | | requiresSave = await RefreshedOwnedItems(options, GetFileSystemChildren(options.DirectoryService |
| | | 1575 | | } |
| | | 1576 | | |
| | 72 | 1577 | | await LibraryManager.UpdateImagesAsync(this).ConfigureAwait(false); // ensure all image properties i |
| | 72 | 1578 | | } |
| | 0 | 1579 | | catch (Exception ex) |
| | | 1580 | | { |
| | 0 | 1581 | | Logger.LogError(ex, "Error refreshing owned items for {Path}", Path ?? Name); |
| | 0 | 1582 | | } |
| | | 1583 | | } |
| | | 1584 | | |
| | 106 | 1585 | | var refreshOptions = requiresSave |
| | 106 | 1586 | | ? new MetadataRefreshOptions(options) |
| | 106 | 1587 | | { |
| | 106 | 1588 | | ForceSave = true |
| | 106 | 1589 | | } |
| | 106 | 1590 | | : options; |
| | | 1591 | | |
| | 106 | 1592 | | return await ProviderManager.RefreshSingleItem(this, refreshOptions, cancellationToken).ConfigureAwait(false |
| | 105 | 1593 | | } |
| | | 1594 | | |
| | | 1595 | | protected bool IsVisibleStandaloneInternal(User user, bool checkFolders) |
| | | 1596 | | { |
| | 0 | 1597 | | if (!IsVisible(user)) |
| | | 1598 | | { |
| | 0 | 1599 | | return false; |
| | | 1600 | | } |
| | | 1601 | | |
| | 0 | 1602 | | var parents = GetParents().ToList(); |
| | 0 | 1603 | | if (parents.Any(i => !i.IsVisible(user, true))) |
| | | 1604 | | { |
| | 0 | 1605 | | return false; |
| | | 1606 | | } |
| | | 1607 | | |
| | 0 | 1608 | | if (checkFolders) |
| | | 1609 | | { |
| | 0 | 1610 | | var topParent = parents.Count > 0 ? parents[^1] : this; |
| | | 1611 | | |
| | 0 | 1612 | | if (string.IsNullOrEmpty(topParent.Path)) |
| | | 1613 | | { |
| | 0 | 1614 | | return true; |
| | | 1615 | | } |
| | | 1616 | | |
| | 0 | 1617 | | var itemCollectionFolders = LibraryManager.GetCollectionFolders(this).Select(i => i.Id).ToList(); |
| | | 1618 | | |
| | 0 | 1619 | | if (itemCollectionFolders.Count > 0) |
| | | 1620 | | { |
| | 0 | 1621 | | var blockedMediaFolders = user.GetPreferenceValues<Guid>(PreferenceKind.BlockedMediaFolders); |
| | | 1622 | | IEnumerable<Guid> userCollectionFolderIds; |
| | 0 | 1623 | | if (blockedMediaFolders.Length > 0) |
| | | 1624 | | { |
| | | 1625 | | // User has blocked folders - get all library folders and exclude blocked ones |
| | 0 | 1626 | | userCollectionFolderIds = LibraryManager.GetUserRootFolder().Children |
| | 0 | 1627 | | .Select(i => i.Id) |
| | 0 | 1628 | | .Where(id => !blockedMediaFolders.Contains(id)); |
| | | 1629 | | } |
| | 0 | 1630 | | else if (user.HasPermission(PermissionKind.EnableAllFolders)) |
| | | 1631 | | { |
| | | 1632 | | // User can access all folders - no need to filter |
| | 0 | 1633 | | return true; |
| | | 1634 | | } |
| | | 1635 | | else |
| | | 1636 | | { |
| | | 1637 | | // User has specific enabled folders |
| | 0 | 1638 | | userCollectionFolderIds = user.GetPreferenceValues<Guid>(PreferenceKind.EnabledFolders); |
| | | 1639 | | } |
| | | 1640 | | |
| | 0 | 1641 | | if (!itemCollectionFolders.Any(userCollectionFolderIds.Contains)) |
| | | 1642 | | { |
| | 0 | 1643 | | return false; |
| | | 1644 | | } |
| | | 1645 | | } |
| | | 1646 | | } |
| | | 1647 | | |
| | 0 | 1648 | | return true; |
| | | 1649 | | } |
| | | 1650 | | |
| | | 1651 | | public void SetParent(Folder parent) |
| | | 1652 | | { |
| | 26 | 1653 | | ParentId = parent is null ? Guid.Empty : parent.Id; |
| | 26 | 1654 | | } |
| | | 1655 | | |
| | | 1656 | | /// <summary> |
| | | 1657 | | /// Refreshes owned items such as trailers, theme videos, special features, etc. |
| | | 1658 | | /// Returns true or false indicating if changes were found. |
| | | 1659 | | /// </summary> |
| | | 1660 | | /// <param name="options">The metadata refresh options.</param> |
| | | 1661 | | /// <param name="fileSystemChildren">The list of filesystem children.</param> |
| | | 1662 | | /// <param name="cancellationToken">The cancellation token.</param> |
| | | 1663 | | /// <returns><c>true</c> if any items have changed, else <c>false</c>.</returns> |
| | | 1664 | | protected virtual async Task<bool> RefreshedOwnedItems(MetadataRefreshOptions options, IReadOnlyList<FileSystemM |
| | | 1665 | | { |
| | 74 | 1666 | | if (!SearchesContainingFolderForExtras) |
| | | 1667 | | { |
| | 72 | 1668 | | return false; |
| | | 1669 | | } |
| | | 1670 | | |
| | 2 | 1671 | | if (GetParent() is Folder container |
| | 2 | 1672 | | && container.SearchesContainingFolderForExtras |
| | 2 | 1673 | | && string.Equals(container.Path, ContainingFolderPath, StringComparison.OrdinalIgnoreCase)) |
| | | 1674 | | { |
| | 1 | 1675 | | return false; |
| | | 1676 | | } |
| | | 1677 | | |
| | 1 | 1678 | | return await RefreshExtras(this, options, fileSystemChildren, cancellationToken).ConfigureAwait(false); |
| | 74 | 1679 | | } |
| | | 1680 | | |
| | | 1681 | | protected virtual FileSystemMetadata[] GetFileSystemChildren(IDirectoryService directoryService) |
| | | 1682 | | { |
| | 56 | 1683 | | return directoryService.GetFileSystemEntries(ContainingFolderPath); |
| | | 1684 | | } |
| | | 1685 | | |
| | | 1686 | | private async Task<bool> RefreshExtras(BaseItem item, MetadataRefreshOptions options, IReadOnlyList<FileSystemMe |
| | | 1687 | | { |
| | | 1688 | | // An extra is owned by the version it is named after, so all of them are maintained together. |
| | 1 | 1689 | | var currentExtras = LibraryManager.GetItemList(new InternalItemsQuery() |
| | 1 | 1690 | | { |
| | 1 | 1691 | | OwnerIds = item.GetOwnedVersionIds() |
| | 1 | 1692 | | }).Where(e => e.ExtraType.HasValue).ToList(); |
| | | 1693 | | |
| | 1 | 1694 | | var currentExtraIds = currentExtras.Select(e => e.Id).ToArray(); |
| | | 1695 | | |
| | | 1696 | | // Snapshot the persisted names before resolving, as FindExtras corrects the name on the |
| | | 1697 | | // items it hands back and may well hand back these very instances. |
| | 1 | 1698 | | var currentExtraNames = new Dictionary<Guid, string>(); |
| | 2 | 1699 | | foreach (var extra in currentExtras) |
| | | 1700 | | { |
| | 0 | 1701 | | currentExtraNames[extra.Id] = extra.Name; |
| | | 1702 | | } |
| | | 1703 | | |
| | 1 | 1704 | | var extras = LibraryManager.FindExtras(item, fileSystemChildren, options.DirectoryService).ToArray(); |
| | 1 | 1705 | | var newExtraIds = Array.ConvertAll(extras, x => x.Id); |
| | | 1706 | | |
| | 1 | 1707 | | var renamedExtraIds = extras |
| | 1 | 1708 | | .Where(e => currentExtraNames.TryGetValue(e.Id, out var oldName) && !string.Equals(oldName, e.Name, Stri |
| | 1 | 1709 | | .Select(e => e.Id) |
| | 1 | 1710 | | .ToHashSet(); |
| | | 1711 | | |
| | 1 | 1712 | | var extrasChanged = !currentExtraIds.OrderBy(x => x).SequenceEqual(newExtraIds.OrderBy(x => x)); |
| | | 1713 | | |
| | 1 | 1714 | | if (!extrasChanged && renamedExtraIds.Count == 0 && !options.ReplaceAllMetadata && options.MetadataRefreshMo |
| | | 1715 | | { |
| | | 1716 | | // The owner's dates may only have become known after its extras were created, so keep |
| | | 1717 | | // them in sync even when there is nothing to refresh. |
| | 2 | 1718 | | foreach (var extra in currentExtras) |
| | | 1719 | | { |
| | 0 | 1720 | | if (extra.ExtraType is not null && InheritDatesFromOwner(item, extra)) |
| | | 1721 | | { |
| | 0 | 1722 | | await extra.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwa |
| | | 1723 | | } |
| | | 1724 | | } |
| | | 1725 | | |
| | 1 | 1726 | | return false; |
| | | 1727 | | } |
| | | 1728 | | |
| | 0 | 1729 | | var tasks = extras.Select(i => |
| | 0 | 1730 | | { |
| | 0 | 1731 | | var ownerId = item.GetOwnerIdForExtra(i); |
| | 0 | 1732 | | var subOptions = new MetadataRefreshOptions(options); |
| | 0 | 1733 | | if (!i.OwnerId.Equals(ownerId) || !i.ParentId.IsEmpty() || renamedExtraIds.Contains(i.Id)) |
| | 0 | 1734 | | { |
| | 0 | 1735 | | subOptions.ForceSave = true; |
| | 0 | 1736 | | } |
| | 0 | 1737 | | |
| | 0 | 1738 | | i.OwnerId = ownerId; |
| | 0 | 1739 | | i.ParentId = Guid.Empty; |
| | 0 | 1740 | | |
| | 0 | 1741 | | return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken); |
| | 0 | 1742 | | }); |
| | | 1743 | | |
| | 0 | 1744 | | var removedExtraIds = currentExtraIds.Where(e => !newExtraIds.Contains(e)).ToArray(); |
| | 0 | 1745 | | if (removedExtraIds.Length > 0) |
| | | 1746 | | { |
| | 0 | 1747 | | var removedExtras = LibraryManager.GetItemList(new InternalItemsQuery() |
| | 0 | 1748 | | { |
| | 0 | 1749 | | ItemIds = removedExtraIds |
| | 0 | 1750 | | }); |
| | 0 | 1751 | | foreach (var removedExtra in removedExtras) |
| | | 1752 | | { |
| | | 1753 | | // Only delete items that are actual extras (have ExtraType set) |
| | | 1754 | | // Items with OwnerId but no ExtraType might be alternate versions, not extras |
| | 0 | 1755 | | if (removedExtra.ExtraType.HasValue) |
| | | 1756 | | { |
| | 0 | 1757 | | LibraryManager.DeleteItem(removedExtra, new DeleteOptions() |
| | 0 | 1758 | | { |
| | 0 | 1759 | | DeleteFileLocation = false |
| | 0 | 1760 | | }); |
| | | 1761 | | } |
| | | 1762 | | } |
| | | 1763 | | } |
| | | 1764 | | |
| | 0 | 1765 | | await Task.WhenAll(tasks).ConfigureAwait(false); |
| | | 1766 | | |
| | 0 | 1767 | | return true; |
| | 1 | 1768 | | } |
| | | 1769 | | |
| | | 1770 | | public string GetPresentationUniqueKey() |
| | | 1771 | | { |
| | 0 | 1772 | | return PresentationUniqueKey ?? CreatePresentationUniqueKey(); |
| | | 1773 | | } |
| | | 1774 | | |
| | | 1775 | | public virtual bool RequiresRefresh() |
| | | 1776 | | { |
| | 106 | 1777 | | if (string.IsNullOrEmpty(Path) || DateModified == DateTime.MinValue) |
| | | 1778 | | { |
| | 101 | 1779 | | return false; |
| | | 1780 | | } |
| | | 1781 | | |
| | 5 | 1782 | | var info = FileSystem.GetFileSystemInfo(Path); |
| | | 1783 | | |
| | 5 | 1784 | | return info.Exists && this.HasChanged(info.LastWriteTimeUtc); |
| | | 1785 | | } |
| | | 1786 | | |
| | | 1787 | | public virtual List<string> GetUserDataKeys() |
| | | 1788 | | { |
| | 247 | 1789 | | var list = new List<string>(); |
| | | 1790 | | |
| | 247 | 1791 | | if (SourceType == SourceType.Channel) |
| | | 1792 | | { |
| | 0 | 1793 | | if (!string.IsNullOrEmpty(ExternalId)) |
| | | 1794 | | { |
| | 0 | 1795 | | list.Add(ExternalId); |
| | | 1796 | | } |
| | | 1797 | | } |
| | | 1798 | | |
| | 247 | 1799 | | list.Add(Id.ToString()); |
| | 247 | 1800 | | return list; |
| | | 1801 | | } |
| | | 1802 | | |
| | | 1803 | | internal virtual ItemUpdateType UpdateFromResolvedItem(BaseItem newItem) |
| | | 1804 | | { |
| | 12 | 1805 | | var updateType = ItemUpdateType.None; |
| | | 1806 | | |
| | 12 | 1807 | | if (IsInMixedFolder != newItem.IsInMixedFolder) |
| | | 1808 | | { |
| | 0 | 1809 | | IsInMixedFolder = newItem.IsInMixedFolder; |
| | 0 | 1810 | | updateType |= ItemUpdateType.MetadataImport; |
| | | 1811 | | } |
| | | 1812 | | |
| | 12 | 1813 | | return updateType; |
| | | 1814 | | } |
| | | 1815 | | |
| | | 1816 | | public void AfterMetadataRefresh() |
| | | 1817 | | { |
| | 112 | 1818 | | _sortName = null; |
| | 112 | 1819 | | } |
| | | 1820 | | |
| | | 1821 | | /// <summary> |
| | | 1822 | | /// Gets the preferred metadata language. |
| | | 1823 | | /// </summary> |
| | | 1824 | | /// <returns>System.String.</returns> |
| | | 1825 | | public string GetPreferredMetadataLanguage() |
| | | 1826 | | { |
| | 49 | 1827 | | string lang = PreferredMetadataLanguage; |
| | | 1828 | | |
| | 49 | 1829 | | if (string.IsNullOrEmpty(lang)) |
| | | 1830 | | { |
| | 46 | 1831 | | lang = GetParents() |
| | 46 | 1832 | | .Select(i => i.PreferredMetadataLanguage) |
| | 46 | 1833 | | .FirstOrDefault(i => !string.IsNullOrEmpty(i)); |
| | | 1834 | | } |
| | | 1835 | | |
| | 49 | 1836 | | if (string.IsNullOrEmpty(lang)) |
| | | 1837 | | { |
| | 46 | 1838 | | lang = LibraryManager.GetCollectionFolders(this) |
| | 46 | 1839 | | .Select(i => i.PreferredMetadataLanguage) |
| | 46 | 1840 | | .FirstOrDefault(i => !string.IsNullOrEmpty(i)); |
| | | 1841 | | } |
| | | 1842 | | |
| | 49 | 1843 | | if (string.IsNullOrEmpty(lang)) |
| | | 1844 | | { |
| | 46 | 1845 | | lang = LibraryManager.GetLibraryOptions(this).PreferredMetadataLanguage; |
| | | 1846 | | } |
| | | 1847 | | |
| | 49 | 1848 | | if (string.IsNullOrEmpty(lang)) |
| | | 1849 | | { |
| | 46 | 1850 | | lang = ConfigurationManager.Configuration.PreferredMetadataLanguage; |
| | | 1851 | | } |
| | | 1852 | | |
| | 49 | 1853 | | return lang; |
| | | 1854 | | } |
| | | 1855 | | |
| | | 1856 | | /// <summary> |
| | | 1857 | | /// Gets the preferred metadata country code. |
| | | 1858 | | /// </summary> |
| | | 1859 | | /// <returns>System.String.</returns> |
| | | 1860 | | public string GetPreferredMetadataCountryCode() |
| | | 1861 | | { |
| | 66 | 1862 | | string lang = PreferredMetadataCountryCode; |
| | | 1863 | | |
| | 66 | 1864 | | if (string.IsNullOrEmpty(lang)) |
| | | 1865 | | { |
| | 46 | 1866 | | lang = GetParents() |
| | 46 | 1867 | | .Select(i => i.PreferredMetadataCountryCode) |
| | 46 | 1868 | | .FirstOrDefault(i => !string.IsNullOrEmpty(i)); |
| | | 1869 | | } |
| | | 1870 | | |
| | 66 | 1871 | | if (string.IsNullOrEmpty(lang)) |
| | | 1872 | | { |
| | 46 | 1873 | | lang = LibraryManager.GetCollectionFolders(this) |
| | 46 | 1874 | | .Select(i => i.PreferredMetadataCountryCode) |
| | 46 | 1875 | | .FirstOrDefault(i => !string.IsNullOrEmpty(i)); |
| | | 1876 | | } |
| | | 1877 | | |
| | 66 | 1878 | | if (string.IsNullOrEmpty(lang)) |
| | | 1879 | | { |
| | 46 | 1880 | | lang = LibraryManager.GetLibraryOptions(this).MetadataCountryCode; |
| | | 1881 | | } |
| | | 1882 | | |
| | 66 | 1883 | | if (string.IsNullOrEmpty(lang)) |
| | | 1884 | | { |
| | 46 | 1885 | | lang = ConfigurationManager.Configuration.MetadataCountryCode; |
| | | 1886 | | } |
| | | 1887 | | |
| | 66 | 1888 | | return lang; |
| | | 1889 | | } |
| | | 1890 | | |
| | | 1891 | | /// <summary> |
| | | 1892 | | /// Gets the original language of the item, inheriting from parent items if necessary. |
| | | 1893 | | /// </summary> |
| | | 1894 | | /// <returns>System.String.</returns> |
| | | 1895 | | public virtual string GetInheritedOriginalLanguage() |
| | | 1896 | | { |
| | 0 | 1897 | | return OriginalLanguage; |
| | | 1898 | | } |
| | | 1899 | | |
| | | 1900 | | public virtual bool IsSaveLocalMetadataEnabled() |
| | | 1901 | | { |
| | 114 | 1902 | | if (SourceType == SourceType.Channel) |
| | | 1903 | | { |
| | 0 | 1904 | | return false; |
| | | 1905 | | } |
| | | 1906 | | |
| | 114 | 1907 | | var libraryOptions = LibraryManager.GetLibraryOptions(this); |
| | | 1908 | | |
| | 114 | 1909 | | return libraryOptions.SaveLocalMetadata; |
| | | 1910 | | } |
| | | 1911 | | |
| | | 1912 | | /// <summary> |
| | | 1913 | | /// Determines if a given user has access to this item. |
| | | 1914 | | /// </summary> |
| | | 1915 | | /// <param name="user">The user.</param> |
| | | 1916 | | /// <param name="skipAllowedTagsCheck">Don't check for allowed tags.</param> |
| | | 1917 | | /// <returns><c>true</c> if [is parental allowed] [the specified user]; otherwise, <c>false</c>.</returns> |
| | | 1918 | | /// <exception cref="ArgumentNullException">If user is null.</exception> |
| | | 1919 | | public bool IsParentalAllowed(User user, bool skipAllowedTagsCheck) |
| | | 1920 | | { |
| | 11 | 1921 | | ArgumentNullException.ThrowIfNull(user); |
| | | 1922 | | |
| | 11 | 1923 | | if (!IsVisibleViaTags(user, skipAllowedTagsCheck)) |
| | | 1924 | | { |
| | 0 | 1925 | | return false; |
| | | 1926 | | } |
| | | 1927 | | |
| | 11 | 1928 | | var maxAllowedRating = user.MaxParentalRatingScore; |
| | 11 | 1929 | | var maxAllowedSubRating = user.MaxParentalRatingSubScore; |
| | 11 | 1930 | | var rating = CustomRatingForComparison; |
| | | 1931 | | |
| | 11 | 1932 | | if (string.IsNullOrEmpty(rating)) |
| | | 1933 | | { |
| | 11 | 1934 | | rating = OfficialRatingForComparison; |
| | | 1935 | | } |
| | | 1936 | | |
| | 11 | 1937 | | if (string.IsNullOrEmpty(rating)) |
| | | 1938 | | { |
| | 11 | 1939 | | return !GetBlockUnratedValue(user); |
| | | 1940 | | } |
| | | 1941 | | |
| | 0 | 1942 | | var ratingScore = LocalizationManager.GetRatingScore(rating, GetPreferredMetadataCountryCode()); |
| | | 1943 | | |
| | | 1944 | | // Could not determine rating level |
| | 0 | 1945 | | if (ratingScore is null) |
| | | 1946 | | { |
| | 0 | 1947 | | var isAllowed = !GetBlockUnratedValue(user); |
| | | 1948 | | |
| | 0 | 1949 | | if (!isAllowed) |
| | | 1950 | | { |
| | 0 | 1951 | | Logger.LogDebug("{0} has an unrecognized parental rating of {1}.", Name, rating); |
| | | 1952 | | } |
| | | 1953 | | |
| | 0 | 1954 | | return isAllowed; |
| | | 1955 | | } |
| | | 1956 | | |
| | 0 | 1957 | | if (!maxAllowedRating.HasValue) |
| | | 1958 | | { |
| | 0 | 1959 | | return true; |
| | | 1960 | | } |
| | | 1961 | | |
| | 0 | 1962 | | if (ratingScore.Score != maxAllowedRating.Value) |
| | | 1963 | | { |
| | 0 | 1964 | | return ratingScore.Score < maxAllowedRating.Value; |
| | | 1965 | | } |
| | | 1966 | | |
| | 0 | 1967 | | return !maxAllowedSubRating.HasValue || (ratingScore.SubScore ?? 0) <= maxAllowedSubRating.Value; |
| | | 1968 | | } |
| | | 1969 | | |
| | | 1970 | | public ParentalRatingScore GetParentalRatingScore() |
| | | 1971 | | { |
| | 386 | 1972 | | var rating = CustomRatingForComparison; |
| | | 1973 | | |
| | 386 | 1974 | | if (string.IsNullOrEmpty(rating)) |
| | | 1975 | | { |
| | 380 | 1976 | | rating = OfficialRatingForComparison; |
| | | 1977 | | } |
| | | 1978 | | |
| | 386 | 1979 | | if (string.IsNullOrEmpty(rating)) |
| | | 1980 | | { |
| | 369 | 1981 | | return null; |
| | | 1982 | | } |
| | | 1983 | | |
| | 17 | 1984 | | return LocalizationManager.GetRatingScore(rating, GetPreferredMetadataCountryCode()); |
| | | 1985 | | } |
| | | 1986 | | |
| | | 1987 | | public List<string> GetInheritedTags() |
| | | 1988 | | { |
| | 172 | 1989 | | var list = new List<string>(); |
| | 172 | 1990 | | list.AddRange(Tags); |
| | | 1991 | | |
| | 442 | 1992 | | foreach (var parent in GetParents()) |
| | | 1993 | | { |
| | 49 | 1994 | | list.AddRange(parent.Tags); |
| | | 1995 | | } |
| | | 1996 | | |
| | 362 | 1997 | | foreach (var folder in LibraryManager.GetCollectionFolders(this)) |
| | | 1998 | | { |
| | 9 | 1999 | | list.AddRange(folder.Tags); |
| | | 2000 | | } |
| | | 2001 | | |
| | 172 | 2002 | | return list.Distinct(StringComparer.OrdinalIgnoreCase).ToList(); |
| | | 2003 | | } |
| | | 2004 | | |
| | | 2005 | | protected bool IsVisibleViaTags(User user, bool skipAllowedTagsCheck) |
| | | 2006 | | { |
| | 11 | 2007 | | var blockedTags = user.GetPreference(PreferenceKind.BlockedTags); |
| | 11 | 2008 | | var allowedTags = user.GetPreference(PreferenceKind.AllowedTags); |
| | | 2009 | | |
| | 11 | 2010 | | if (blockedTags.Length == 0 && allowedTags.Length == 0) |
| | | 2011 | | { |
| | 10 | 2012 | | return true; |
| | | 2013 | | } |
| | | 2014 | | |
| | | 2015 | | // Normalize tags using the same logic as database queries |
| | 1 | 2016 | | var normalizedBlockedTags = blockedTags |
| | 1 | 2017 | | .Where(t => !string.IsNullOrWhiteSpace(t)) |
| | 1 | 2018 | | .Select(t => t.GetCleanValue()) |
| | 1 | 2019 | | .ToHashSet(StringComparer.Ordinal); |
| | | 2020 | | |
| | 1 | 2021 | | var normalizedItemTags = GetInheritedTags() |
| | 1 | 2022 | | .Select(t => t.GetCleanValue()) |
| | 1 | 2023 | | .ToHashSet(StringComparer.Ordinal); |
| | | 2024 | | |
| | | 2025 | | // Check blocked tags - item is hidden if it has any blocked tag |
| | 1 | 2026 | | if (normalizedBlockedTags.Overlaps(normalizedItemTags)) |
| | | 2027 | | { |
| | 0 | 2028 | | return false; |
| | | 2029 | | } |
| | | 2030 | | |
| | 1 | 2031 | | var parent = GetParents().FirstOrDefault() ?? this; |
| | 1 | 2032 | | if (parent is UserRootFolder or AggregateFolder or UserView) |
| | | 2033 | | { |
| | 1 | 2034 | | return true; |
| | | 2035 | | } |
| | | 2036 | | |
| | | 2037 | | // Check allowed tags - item must have at least one allowed tag |
| | 0 | 2038 | | if (!skipAllowedTagsCheck && allowedTags.Length > 0) |
| | | 2039 | | { |
| | 0 | 2040 | | var normalizedAllowedTags = allowedTags |
| | 0 | 2041 | | .Where(t => !string.IsNullOrWhiteSpace(t)) |
| | 0 | 2042 | | .Select(t => t.GetCleanValue()) |
| | 0 | 2043 | | .ToHashSet(StringComparer.Ordinal); |
| | | 2044 | | |
| | 0 | 2045 | | if (!normalizedAllowedTags.Overlaps(normalizedItemTags)) |
| | | 2046 | | { |
| | 0 | 2047 | | return false; |
| | | 2048 | | } |
| | | 2049 | | } |
| | | 2050 | | |
| | 0 | 2051 | | return true; |
| | | 2052 | | } |
| | | 2053 | | |
| | | 2054 | | public virtual UnratedItem GetBlockUnratedType() |
| | | 2055 | | { |
| | 157 | 2056 | | if (SourceType == SourceType.Channel) |
| | | 2057 | | { |
| | 0 | 2058 | | return UnratedItem.ChannelContent; |
| | | 2059 | | } |
| | | 2060 | | |
| | 157 | 2061 | | return UnratedItem.Other; |
| | | 2062 | | } |
| | | 2063 | | |
| | | 2064 | | /// <summary> |
| | | 2065 | | /// Gets a bool indicating if access to the unrated item is blocked or not. |
| | | 2066 | | /// </summary> |
| | | 2067 | | /// <param name="user">The configuration.</param> |
| | | 2068 | | /// <returns><c>true</c> if blocked, <c>false</c> otherwise.</returns> |
| | | 2069 | | protected virtual bool GetBlockUnratedValue(User user) |
| | | 2070 | | { |
| | | 2071 | | // Don't block plain folders that are unrated. Let the media underneath get blocked |
| | | 2072 | | // Special folders like series and albums will override this method. |
| | 11 | 2073 | | if (IsFolder || this is IItemByName) |
| | | 2074 | | { |
| | 8 | 2075 | | return false; |
| | | 2076 | | } |
| | | 2077 | | |
| | 3 | 2078 | | return user.GetPreferenceValues<UnratedItem>(PreferenceKind.BlockUnratedItems).Contains(GetBlockUnratedType( |
| | | 2079 | | } |
| | | 2080 | | |
| | | 2081 | | /// <summary> |
| | | 2082 | | /// Determines if this folder should be visible to a given user. |
| | | 2083 | | /// Default is just parental allowed. Can be overridden for more functionality. |
| | | 2084 | | /// </summary> |
| | | 2085 | | /// <param name="user">The user.</param> |
| | | 2086 | | /// <param name="skipAllowedTagsCheck">Don't check for allowed tags.</param> |
| | | 2087 | | /// <returns><c>true</c> if the specified user is visible; otherwise, <c>false</c>.</returns> |
| | | 2088 | | /// <exception cref="ArgumentNullException"><paramref name="user" /> is <c>null</c>.</exception> |
| | | 2089 | | public virtual bool IsVisible(User user, bool skipAllowedTagsCheck = false) |
| | | 2090 | | { |
| | 8 | 2091 | | ArgumentNullException.ThrowIfNull(user); |
| | | 2092 | | |
| | 8 | 2093 | | return IsParentalAllowed(user, skipAllowedTagsCheck); |
| | | 2094 | | } |
| | | 2095 | | |
| | | 2096 | | public virtual bool IsVisibleStandalone(User user) |
| | | 2097 | | { |
| | 0 | 2098 | | if (SourceType == SourceType.Channel) |
| | | 2099 | | { |
| | 0 | 2100 | | return IsVisibleStandaloneInternal(user, false) && Channel.IsChannelVisible(this, user); |
| | | 2101 | | } |
| | | 2102 | | |
| | 0 | 2103 | | return IsVisibleStandaloneInternal(user, true); |
| | | 2104 | | } |
| | | 2105 | | |
| | | 2106 | | public virtual string GetClientTypeName() |
| | | 2107 | | { |
| | 182 | 2108 | | if (IsFolder && SourceType == SourceType.Channel && this is not Channel && this is not Season && this is not |
| | | 2109 | | { |
| | 0 | 2110 | | return "ChannelFolderItem"; |
| | | 2111 | | } |
| | | 2112 | | |
| | 182 | 2113 | | return GetType().Name; |
| | | 2114 | | } |
| | | 2115 | | |
| | | 2116 | | public BaseItemKind GetBaseItemKind() |
| | | 2117 | | { |
| | 422 | 2118 | | return _baseItemKind ??= Enum.Parse<BaseItemKind>(GetClientTypeName()); |
| | | 2119 | | } |
| | | 2120 | | |
| | | 2121 | | /// <summary> |
| | | 2122 | | /// Gets the linked child. |
| | | 2123 | | /// </summary> |
| | | 2124 | | /// <param name="info">The info.</param> |
| | | 2125 | | /// <returns>BaseItem.</returns> |
| | | 2126 | | protected BaseItem GetLinkedChild(LinkedChild info) |
| | | 2127 | | { |
| | | 2128 | | // First get using the cached Id |
| | 0 | 2129 | | if (info.ItemId.HasValue) |
| | | 2130 | | { |
| | 0 | 2131 | | if (info.ItemId.Value.IsEmpty()) |
| | | 2132 | | { |
| | 0 | 2133 | | return null; |
| | | 2134 | | } |
| | | 2135 | | |
| | 0 | 2136 | | var itemById = LibraryManager.GetItemById(info.ItemId.Value); |
| | | 2137 | | |
| | 0 | 2138 | | if (itemById is not null) |
| | | 2139 | | { |
| | 0 | 2140 | | return itemById; |
| | | 2141 | | } |
| | | 2142 | | } |
| | | 2143 | | |
| | 0 | 2144 | | var item = FindLinkedChild(info); |
| | | 2145 | | |
| | | 2146 | | // If still null, log |
| | 0 | 2147 | | if (item is null) |
| | | 2148 | | { |
| | | 2149 | | // Don't keep searching over and over |
| | 0 | 2150 | | info.ItemId = Guid.Empty; |
| | | 2151 | | } |
| | | 2152 | | else |
| | | 2153 | | { |
| | | 2154 | | // Cache the id for next time |
| | 0 | 2155 | | info.ItemId = item.Id; |
| | | 2156 | | } |
| | | 2157 | | |
| | 0 | 2158 | | return item; |
| | | 2159 | | } |
| | | 2160 | | |
| | | 2161 | | #pragma warning disable CS0618 // Type or member is obsolete - fallback for legacy LinkedChild data |
| | | 2162 | | private BaseItem FindLinkedChild(LinkedChild info) |
| | | 2163 | | { |
| | | 2164 | | // First try to find by ItemId (new preferred method) |
| | 0 | 2165 | | if (info.ItemId.HasValue && !info.ItemId.Value.Equals(Guid.Empty)) |
| | | 2166 | | { |
| | 0 | 2167 | | var item = LibraryManager.GetItemById(info.ItemId.Value); |
| | 0 | 2168 | | if (item is not null) |
| | | 2169 | | { |
| | 0 | 2170 | | return item; |
| | | 2171 | | } |
| | | 2172 | | |
| | 0 | 2173 | | Logger.LogWarning("Unable to find linked item by ItemId {0}", info.ItemId); |
| | | 2174 | | } |
| | | 2175 | | |
| | | 2176 | | // Fall back to Path (legacy method) |
| | 0 | 2177 | | var path = info.Path; |
| | 0 | 2178 | | if (!string.IsNullOrEmpty(path)) |
| | | 2179 | | { |
| | 0 | 2180 | | path = FileSystem.MakeAbsolutePath(ContainingFolderPath, path); |
| | | 2181 | | |
| | 0 | 2182 | | var itemByPath = LibraryManager.FindByPath(path, null); |
| | | 2183 | | |
| | 0 | 2184 | | if (itemByPath is null) |
| | | 2185 | | { |
| | 0 | 2186 | | Logger.LogWarning("Unable to find linked item at path {0}", info.Path); |
| | | 2187 | | } |
| | | 2188 | | |
| | 0 | 2189 | | return itemByPath; |
| | | 2190 | | } |
| | | 2191 | | |
| | | 2192 | | // Fall back to LibraryItemId (legacy method) |
| | 0 | 2193 | | if (!string.IsNullOrEmpty(info.LibraryItemId)) |
| | | 2194 | | { |
| | 0 | 2195 | | var item = LibraryManager.GetItemById(info.LibraryItemId); |
| | | 2196 | | |
| | 0 | 2197 | | if (item is null) |
| | | 2198 | | { |
| | 0 | 2199 | | Logger.LogWarning("Unable to find linked item by LibraryItemId {0}", info.LibraryItemId); |
| | | 2200 | | } |
| | | 2201 | | |
| | 0 | 2202 | | return item; |
| | | 2203 | | } |
| | | 2204 | | |
| | 0 | 2205 | | return null; |
| | | 2206 | | } |
| | | 2207 | | #pragma warning restore CS0618 |
| | | 2208 | | |
| | | 2209 | | /// <summary> |
| | | 2210 | | /// Adds a studio to the item. |
| | | 2211 | | /// </summary> |
| | | 2212 | | /// <param name="name">The name.</param> |
| | | 2213 | | /// <exception cref="ArgumentNullException">Throws if name is null.</exception> |
| | | 2214 | | public void AddStudio(string name) |
| | | 2215 | | { |
| | 4 | 2216 | | ArgumentException.ThrowIfNullOrEmpty(name); |
| | 4 | 2217 | | var current = Studios; |
| | | 2218 | | |
| | 4 | 2219 | | if (!current.Contains(name, StringComparison.OrdinalIgnoreCase)) |
| | | 2220 | | { |
| | 4 | 2221 | | int curLen = current.Length; |
| | 4 | 2222 | | if (curLen == 0) |
| | | 2223 | | { |
| | 4 | 2224 | | Studios = [name]; |
| | | 2225 | | } |
| | | 2226 | | else |
| | | 2227 | | { |
| | 0 | 2228 | | Studios = [.. current, name]; |
| | | 2229 | | } |
| | | 2230 | | } |
| | 0 | 2231 | | } |
| | | 2232 | | |
| | | 2233 | | public void SetStudios(IEnumerable<string> names) |
| | | 2234 | | { |
| | 20 | 2235 | | Studios = names.Trimmed().Distinct(StringComparer.OrdinalIgnoreCase).ToArray(); |
| | 20 | 2236 | | } |
| | | 2237 | | |
| | | 2238 | | /// <summary> |
| | | 2239 | | /// Adds a genre to the item. |
| | | 2240 | | /// </summary> |
| | | 2241 | | /// <param name="name">The name.</param> |
| | | 2242 | | /// <exception cref="ArgumentNullException">Throws if name is null.</exception> |
| | | 2243 | | public void AddGenre(string name) |
| | | 2244 | | { |
| | 13 | 2245 | | ArgumentException.ThrowIfNullOrEmpty(name); |
| | | 2246 | | |
| | 13 | 2247 | | var genres = Genres; |
| | 13 | 2248 | | if (!genres.Contains(name, StringComparison.OrdinalIgnoreCase)) |
| | | 2249 | | { |
| | 13 | 2250 | | Genres = [.. genres, name]; |
| | | 2251 | | } |
| | 13 | 2252 | | } |
| | | 2253 | | |
| | | 2254 | | /// <summary> |
| | | 2255 | | /// Marks the played. |
| | | 2256 | | /// </summary> |
| | | 2257 | | /// <param name="user">The user.</param> |
| | | 2258 | | /// <param name="datePlayed">The date played.</param> |
| | | 2259 | | /// <param name="resetPosition">if set to <c>true</c> [reset position].</param> |
| | | 2260 | | /// <exception cref="ArgumentNullException">Throws if user is null.</exception> |
| | | 2261 | | public virtual void MarkPlayed( |
| | | 2262 | | User user, |
| | | 2263 | | DateTime? datePlayed, |
| | | 2264 | | bool resetPosition) |
| | | 2265 | | { |
| | 0 | 2266 | | ArgumentNullException.ThrowIfNull(user); |
| | | 2267 | | |
| | 0 | 2268 | | var data = UserDataManager.GetUserData(user, this) ?? new UserItemData() |
| | 0 | 2269 | | { |
| | 0 | 2270 | | Key = GetUserDataKeys().First(), |
| | 0 | 2271 | | }; |
| | | 2272 | | |
| | 0 | 2273 | | if (datePlayed.HasValue) |
| | | 2274 | | { |
| | | 2275 | | // Increment |
| | 0 | 2276 | | data.PlayCount++; |
| | | 2277 | | } |
| | | 2278 | | |
| | | 2279 | | // Ensure it's at least one |
| | 0 | 2280 | | data.PlayCount = Math.Max(data.PlayCount, 1); |
| | | 2281 | | |
| | 0 | 2282 | | if (resetPosition) |
| | | 2283 | | { |
| | 0 | 2284 | | data.PlaybackPositionTicks = 0; |
| | | 2285 | | } |
| | | 2286 | | |
| | 0 | 2287 | | data.LastPlayedDate = datePlayed ?? data.LastPlayedDate ?? DateTime.UtcNow; |
| | 0 | 2288 | | data.Played = true; |
| | | 2289 | | |
| | 0 | 2290 | | UserDataManager.SaveUserData(user, this, data, UserDataSaveReason.TogglePlayed, CancellationToken.None); |
| | 0 | 2291 | | } |
| | | 2292 | | |
| | | 2293 | | /// <summary> |
| | | 2294 | | /// Marks the unplayed. |
| | | 2295 | | /// </summary> |
| | | 2296 | | /// <param name="user">The user.</param> |
| | | 2297 | | /// <exception cref="ArgumentNullException">Throws if user is null.</exception> |
| | | 2298 | | public virtual void MarkUnplayed(User user) |
| | | 2299 | | { |
| | 0 | 2300 | | ArgumentNullException.ThrowIfNull(user); |
| | | 2301 | | |
| | 0 | 2302 | | var data = UserDataManager.GetUserData(user, this); |
| | | 2303 | | |
| | | 2304 | | // I think it is okay to do this here. |
| | | 2305 | | // if this is only called when a user is manually forcing something to un-played |
| | | 2306 | | // then it probably is what we want to do... |
| | 0 | 2307 | | ResetPlayedState(data); |
| | | 2308 | | |
| | 0 | 2309 | | UserDataManager.SaveUserData(user, this, data, UserDataSaveReason.TogglePlayed, CancellationToken.None); |
| | 0 | 2310 | | } |
| | | 2311 | | |
| | | 2312 | | /// <summary> |
| | | 2313 | | /// Clears the played state on the supplied user data. |
| | | 2314 | | /// </summary> |
| | | 2315 | | /// <param name="data">The user data to reset.</param> |
| | | 2316 | | protected static void ResetPlayedState(UserItemData data) |
| | | 2317 | | { |
| | 2 | 2318 | | ArgumentNullException.ThrowIfNull(data); |
| | | 2319 | | |
| | 2 | 2320 | | data.PlayCount = 0; |
| | 2 | 2321 | | data.PlaybackPositionTicks = 0; |
| | 2 | 2322 | | data.LastPlayedDate = null; |
| | 2 | 2323 | | data.Played = false; |
| | 2 | 2324 | | } |
| | | 2325 | | |
| | | 2326 | | /// <summary> |
| | | 2327 | | /// Do whatever refreshing is necessary when the filesystem pertaining to this item has changed. |
| | | 2328 | | /// </summary> |
| | | 2329 | | public virtual void ChangedExternally() |
| | | 2330 | | { |
| | 0 | 2331 | | ProviderManager.QueueRefresh(Id, new MetadataRefreshOptions(new DirectoryService(FileSystem)), RefreshPriori |
| | 0 | 2332 | | } |
| | | 2333 | | |
| | | 2334 | | /// <summary> |
| | | 2335 | | /// Gets an image. |
| | | 2336 | | /// </summary> |
| | | 2337 | | /// <param name="type">The type.</param> |
| | | 2338 | | /// <param name="imageIndex">Index of the image.</param> |
| | | 2339 | | /// <returns><c>true</c> if the specified type has image; otherwise, <c>false</c>.</returns> |
| | | 2340 | | /// <exception cref="ArgumentException">Backdrops should be accessed using Item.Backdrops.</exception> |
| | | 2341 | | public bool HasImage(ImageType type, int imageIndex) |
| | | 2342 | | { |
| | 153 | 2343 | | return GetImageInfo(type, imageIndex) is not null; |
| | | 2344 | | } |
| | | 2345 | | |
| | | 2346 | | public void SetImage(ItemImageInfo image, int index) |
| | | 2347 | | { |
| | 24 | 2348 | | if (image.Type == ImageType.Chapter) |
| | | 2349 | | { |
| | 0 | 2350 | | throw new ArgumentException("Cannot set chapter images using SetImagePath"); |
| | | 2351 | | } |
| | | 2352 | | |
| | 24 | 2353 | | var existingImage = GetImageInfo(image.Type, index); |
| | | 2354 | | |
| | 24 | 2355 | | if (existingImage is null) |
| | | 2356 | | { |
| | 22 | 2357 | | AddImage(image); |
| | | 2358 | | } |
| | | 2359 | | else |
| | | 2360 | | { |
| | 2 | 2361 | | existingImage.Path = image.Path; |
| | 2 | 2362 | | existingImage.DateModified = image.DateModified; |
| | 2 | 2363 | | existingImage.Width = image.Width; |
| | 2 | 2364 | | existingImage.Height = image.Height; |
| | 2 | 2365 | | existingImage.BlurHash = image.BlurHash; |
| | | 2366 | | } |
| | 2 | 2367 | | } |
| | | 2368 | | |
| | | 2369 | | public void SetImagePath(ImageType type, int index, FileSystemMetadata file) |
| | | 2370 | | { |
| | 49 | 2371 | | if (type == ImageType.Chapter) |
| | | 2372 | | { |
| | 0 | 2373 | | throw new ArgumentException("Cannot set chapter images using SetImagePath"); |
| | | 2374 | | } |
| | | 2375 | | |
| | 49 | 2376 | | var image = GetImageInfo(type, index); |
| | | 2377 | | |
| | 49 | 2378 | | if (image is null) |
| | | 2379 | | { |
| | 48 | 2380 | | AddImage(GetImageInfo(file, type)); |
| | | 2381 | | } |
| | | 2382 | | else |
| | | 2383 | | { |
| | 1 | 2384 | | var imageInfo = GetImageInfo(file, type); |
| | | 2385 | | |
| | 1 | 2386 | | image.Path = file.FullName; |
| | 1 | 2387 | | image.DateModified = imageInfo.DateModified; |
| | | 2388 | | |
| | | 2389 | | // reset these values |
| | 1 | 2390 | | image.Width = 0; |
| | 1 | 2391 | | image.Height = 0; |
| | | 2392 | | } |
| | 1 | 2393 | | } |
| | | 2394 | | |
| | | 2395 | | /// <summary> |
| | | 2396 | | /// Deletes the image. |
| | | 2397 | | /// </summary> |
| | | 2398 | | /// <param name="type">The type.</param> |
| | | 2399 | | /// <param name="index">The index.</param> |
| | | 2400 | | /// <returns>A task.</returns> |
| | | 2401 | | public async Task DeleteImageAsync(ImageType type, int index) |
| | | 2402 | | { |
| | 0 | 2403 | | var info = GetImageInfo(type, index); |
| | | 2404 | | |
| | 0 | 2405 | | if (info is null) |
| | | 2406 | | { |
| | | 2407 | | // Nothing to do |
| | 0 | 2408 | | return; |
| | | 2409 | | } |
| | | 2410 | | |
| | | 2411 | | // Remove from file system |
| | 0 | 2412 | | var path = info.Path; |
| | 0 | 2413 | | if (info.IsLocalFile && !string.IsNullOrWhiteSpace(path)) |
| | | 2414 | | { |
| | 0 | 2415 | | FileSystem.DeleteFile(path); |
| | | 2416 | | } |
| | | 2417 | | |
| | | 2418 | | // Remove from item |
| | 0 | 2419 | | RemoveImage(info); |
| | | 2420 | | |
| | 0 | 2421 | | await UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false); |
| | 0 | 2422 | | } |
| | | 2423 | | |
| | | 2424 | | public void RemoveImage(ItemImageInfo image) |
| | | 2425 | | { |
| | 0 | 2426 | | RemoveImages([image]); |
| | 0 | 2427 | | } |
| | | 2428 | | |
| | | 2429 | | public void RemoveImages(IEnumerable<ItemImageInfo> deletedImages) |
| | | 2430 | | { |
| | 9 | 2431 | | ImageInfos = ImageInfos.Except(deletedImages).ToArray(); |
| | 9 | 2432 | | } |
| | | 2433 | | |
| | | 2434 | | public void AddImage(ItemImageInfo image) |
| | | 2435 | | { |
| | 70 | 2436 | | ImageInfos = [.. ImageInfos, image]; |
| | 70 | 2437 | | } |
| | | 2438 | | |
| | | 2439 | | public virtual async Task UpdateToRepositoryAsync(ItemUpdateType updateReason, CancellationToken cancellationTok |
| | 161 | 2440 | | => await LibraryManager.UpdateItemAsync(this, GetParent(), updateReason, cancellationToken).ConfigureAwait(fals |
| | | 2441 | | |
| | | 2442 | | public async Task ReattachUserDataAsync(CancellationToken cancellationToken) => |
| | 45 | 2443 | | await LibraryManager.ReattachUserDataAsync(this, cancellationToken).ConfigureAwait(false); |
| | | 2444 | | |
| | | 2445 | | /// <summary> |
| | | 2446 | | /// Validates that images within the item are still on the filesystem. |
| | | 2447 | | /// </summary> |
| | | 2448 | | /// <returns><c>true</c> if the images validate, <c>false</c> if not.</returns> |
| | | 2449 | | public bool ValidateImages() |
| | | 2450 | | { |
| | 129 | 2451 | | List<ItemImageInfo> deletedImages = null; |
| | 294 | 2452 | | foreach (var imageInfo in ImageInfos) |
| | | 2453 | | { |
| | 18 | 2454 | | if (!imageInfo.IsLocalFile) |
| | | 2455 | | { |
| | | 2456 | | continue; |
| | | 2457 | | } |
| | | 2458 | | |
| | 18 | 2459 | | if (File.Exists(imageInfo.Path)) |
| | | 2460 | | { |
| | | 2461 | | continue; |
| | | 2462 | | } |
| | | 2463 | | |
| | 3 | 2464 | | (deletedImages ??= []).Add(imageInfo); |
| | | 2465 | | } |
| | | 2466 | | |
| | 129 | 2467 | | var anyImagesRemoved = deletedImages?.Count > 0; |
| | 129 | 2468 | | if (anyImagesRemoved) |
| | | 2469 | | { |
| | 2 | 2470 | | RemoveImages(deletedImages); |
| | | 2471 | | } |
| | | 2472 | | |
| | 129 | 2473 | | return anyImagesRemoved; |
| | | 2474 | | } |
| | | 2475 | | |
| | | 2476 | | /// <summary> |
| | | 2477 | | /// Gets the image path. |
| | | 2478 | | /// </summary> |
| | | 2479 | | /// <param name="imageType">Type of the image.</param> |
| | | 2480 | | /// <param name="imageIndex">Index of the image.</param> |
| | | 2481 | | /// <returns>System.String.</returns> |
| | | 2482 | | /// <exception cref="ArgumentNullException">Item is null.</exception> |
| | | 2483 | | public string GetImagePath(ImageType imageType, int imageIndex) |
| | 2 | 2484 | | => GetImageInfo(imageType, imageIndex)?.Path; |
| | | 2485 | | |
| | | 2486 | | /// <summary> |
| | | 2487 | | /// Gets the image information. |
| | | 2488 | | /// </summary> |
| | | 2489 | | /// <param name="imageType">Type of the image.</param> |
| | | 2490 | | /// <param name="imageIndex">Index of the image.</param> |
| | | 2491 | | /// <returns>ItemImageInfo.</returns> |
| | | 2492 | | public ItemImageInfo GetImageInfo(ImageType imageType, int imageIndex) |
| | | 2493 | | { |
| | 384 | 2494 | | if (imageType == ImageType.Chapter) |
| | | 2495 | | { |
| | 0 | 2496 | | var chapter = ChapterManager.GetChapter(Id, imageIndex); |
| | | 2497 | | |
| | 0 | 2498 | | if (chapter is null) |
| | | 2499 | | { |
| | 0 | 2500 | | return null; |
| | | 2501 | | } |
| | | 2502 | | |
| | 0 | 2503 | | var path = chapter.ImagePath; |
| | | 2504 | | |
| | 0 | 2505 | | if (string.IsNullOrEmpty(path)) |
| | | 2506 | | { |
| | 0 | 2507 | | return null; |
| | | 2508 | | } |
| | | 2509 | | |
| | 0 | 2510 | | return new ItemImageInfo |
| | 0 | 2511 | | { |
| | 0 | 2512 | | Path = path, |
| | 0 | 2513 | | DateModified = chapter.ImageDateModified, |
| | 0 | 2514 | | Type = imageType |
| | 0 | 2515 | | }; |
| | | 2516 | | } |
| | | 2517 | | |
| | 384 | 2518 | | return GetImages(imageType) |
| | 384 | 2519 | | .ElementAtOrDefault(imageIndex); |
| | | 2520 | | } |
| | | 2521 | | |
| | | 2522 | | /// <summary> |
| | | 2523 | | /// Computes image index for given image or raises if no matching image found. |
| | | 2524 | | /// </summary> |
| | | 2525 | | /// <param name="image">Image to compute index for.</param> |
| | | 2526 | | /// <exception cref="ArgumentException">Image index cannot be computed as no matching image found. |
| | | 2527 | | /// </exception> |
| | | 2528 | | /// <returns>Image index.</returns> |
| | | 2529 | | public int GetImageIndex(ItemImageInfo image) |
| | | 2530 | | { |
| | 0 | 2531 | | ArgumentNullException.ThrowIfNull(image); |
| | | 2532 | | |
| | 0 | 2533 | | if (image.Type == ImageType.Chapter) |
| | | 2534 | | { |
| | 0 | 2535 | | var chapters = ChapterManager.GetChapters(Id); |
| | 0 | 2536 | | for (var i = 0; i < chapters.Count; i++) |
| | | 2537 | | { |
| | 0 | 2538 | | if (chapters[i].ImagePath == image.Path) |
| | | 2539 | | { |
| | 0 | 2540 | | return i; |
| | | 2541 | | } |
| | | 2542 | | } |
| | | 2543 | | |
| | 0 | 2544 | | throw new ArgumentException("No chapter index found for image path", image.Path); |
| | | 2545 | | } |
| | | 2546 | | |
| | 0 | 2547 | | var images = GetImages(image.Type).ToArray(); |
| | 0 | 2548 | | for (var i = 0; i < images.Length; i++) |
| | | 2549 | | { |
| | 0 | 2550 | | if (images[i].Path == image.Path) |
| | | 2551 | | { |
| | 0 | 2552 | | return i; |
| | | 2553 | | } |
| | | 2554 | | } |
| | | 2555 | | |
| | 0 | 2556 | | throw new ArgumentException("No image index found for image path", image.Path); |
| | | 2557 | | } |
| | | 2558 | | |
| | | 2559 | | public IEnumerable<ItemImageInfo> GetImages(ImageType imageType) |
| | | 2560 | | { |
| | 504 | 2561 | | if (imageType == ImageType.Chapter) |
| | | 2562 | | { |
| | 0 | 2563 | | throw new ArgumentException("No image info for chapter images"); |
| | | 2564 | | } |
| | | 2565 | | |
| | | 2566 | | // Yield return is more performant than LINQ Where on an Array |
| | 1582 | 2567 | | for (var i = 0; i < ImageInfos.Length; i++) |
| | | 2568 | | { |
| | 313 | 2569 | | var imageInfo = ImageInfos[i]; |
| | 313 | 2570 | | if (imageInfo.Type == imageType) |
| | | 2571 | | { |
| | 167 | 2572 | | yield return imageInfo; |
| | | 2573 | | } |
| | | 2574 | | } |
| | 478 | 2575 | | } |
| | | 2576 | | |
| | | 2577 | | /// <summary> |
| | | 2578 | | /// Adds the images, updating metadata if they already are part of this item. |
| | | 2579 | | /// </summary> |
| | | 2580 | | /// <param name="imageType">Type of the image.</param> |
| | | 2581 | | /// <param name="images">The images.</param> |
| | | 2582 | | /// <returns><c>true</c> if images were added or updated, <c>false</c> otherwise.</returns> |
| | | 2583 | | /// <exception cref="ArgumentException">Cannot call AddImages with chapter images.</exception> |
| | | 2584 | | public bool AddImages(ImageType imageType, List<FileSystemMetadata> images) |
| | | 2585 | | { |
| | 5 | 2586 | | if (imageType == ImageType.Chapter) |
| | | 2587 | | { |
| | 0 | 2588 | | throw new ArgumentException("Cannot call AddImages with chapter images"); |
| | | 2589 | | } |
| | | 2590 | | |
| | 5 | 2591 | | var existingImages = GetImages(imageType) |
| | 5 | 2592 | | .ToList(); |
| | | 2593 | | |
| | 5 | 2594 | | var newImageList = new List<FileSystemMetadata>(); |
| | 5 | 2595 | | var imageUpdated = false; |
| | | 2596 | | |
| | 30 | 2597 | | foreach (var newImage in images) |
| | | 2598 | | { |
| | 10 | 2599 | | if (newImage is null) |
| | | 2600 | | { |
| | 0 | 2601 | | throw new ArgumentException("null image found in list"); |
| | | 2602 | | } |
| | | 2603 | | |
| | 10 | 2604 | | var existing = existingImages |
| | 10 | 2605 | | .Find(i => string.Equals(i.Path, newImage.FullName, StringComparison.OrdinalIgnoreCase)); |
| | | 2606 | | |
| | 10 | 2607 | | if (existing is null) |
| | | 2608 | | { |
| | 4 | 2609 | | newImageList.Add(newImage); |
| | | 2610 | | } |
| | | 2611 | | else |
| | | 2612 | | { |
| | 6 | 2613 | | if (existing.IsLocalFile) |
| | | 2614 | | { |
| | 6 | 2615 | | var newDateModified = FileSystem.GetLastWriteTimeUtc(newImage); |
| | | 2616 | | |
| | | 2617 | | // If date changed then we need to reset saved image dimensions. Stores such as PostgreSQL keep |
| | | 2618 | | // only microseconds, so an exact comparison would treat every unchanged image as modified. |
| | 6 | 2619 | | if (Math.Abs((existing.DateModified - newDateModified).TotalSeconds) > 1 && (existing.Width > 0 |
| | | 2620 | | { |
| | 2 | 2621 | | existing.Width = 0; |
| | 2 | 2622 | | existing.Height = 0; |
| | 2 | 2623 | | imageUpdated = true; |
| | | 2624 | | } |
| | | 2625 | | |
| | 6 | 2626 | | existing.DateModified = newDateModified; |
| | | 2627 | | } |
| | | 2628 | | } |
| | | 2629 | | } |
| | | 2630 | | |
| | 5 | 2631 | | if (newImageList.Count > 0) |
| | | 2632 | | { |
| | 2 | 2633 | | ImageInfos = ImageInfos.Concat(newImageList.Select(i => GetImageInfo(i, imageType))).ToArray(); |
| | | 2634 | | } |
| | | 2635 | | |
| | 5 | 2636 | | return imageUpdated || newImageList.Count > 0; |
| | | 2637 | | } |
| | | 2638 | | |
| | | 2639 | | private ItemImageInfo GetImageInfo(FileSystemMetadata file, ImageType type) |
| | | 2640 | | { |
| | 53 | 2641 | | return new ItemImageInfo |
| | 53 | 2642 | | { |
| | 53 | 2643 | | Path = file.FullName, |
| | 53 | 2644 | | Type = type, |
| | 53 | 2645 | | DateModified = FileSystem.GetLastWriteTimeUtc(file) |
| | 53 | 2646 | | }; |
| | | 2647 | | } |
| | | 2648 | | |
| | | 2649 | | /// <summary> |
| | | 2650 | | /// Gets the file system path to delete when the item is to be deleted. |
| | | 2651 | | /// </summary> |
| | | 2652 | | /// <returns>The metadata for the deleted paths.</returns> |
| | | 2653 | | public virtual IEnumerable<FileSystemMetadata> GetDeletePaths() |
| | | 2654 | | { |
| | 0 | 2655 | | return new[] |
| | 0 | 2656 | | { |
| | 0 | 2657 | | FileSystem.GetFileSystemInfo(Path) |
| | 0 | 2658 | | }.Concat(GetLocalMetadataFilesToDelete()); |
| | | 2659 | | } |
| | | 2660 | | |
| | | 2661 | | protected List<FileSystemMetadata> GetLocalMetadataFilesToDelete() |
| | | 2662 | | { |
| | 0 | 2663 | | if (IsFolder || !IsInMixedFolder) |
| | | 2664 | | { |
| | 0 | 2665 | | return []; |
| | | 2666 | | } |
| | | 2667 | | |
| | 0 | 2668 | | var filename = System.IO.Path.GetFileNameWithoutExtension(Path); |
| | | 2669 | | |
| | 0 | 2670 | | return FileSystem.GetFiles(System.IO.Path.GetDirectoryName(Path), _supportedExtensions, false, false) |
| | 0 | 2671 | | .Where(i => System.IO.Path.GetFileNameWithoutExtension(i.FullName).StartsWith(filename, StringComparison |
| | 0 | 2672 | | .ToList(); |
| | | 2673 | | } |
| | | 2674 | | |
| | | 2675 | | public bool AllowsMultipleImages(ImageType type) |
| | | 2676 | | { |
| | 23 | 2677 | | return type == ImageType.Backdrop || type == ImageType.Chapter; |
| | | 2678 | | } |
| | | 2679 | | |
| | | 2680 | | public Task SwapImagesAsync(ImageType type, int index1, int index2) |
| | | 2681 | | { |
| | 0 | 2682 | | if (!AllowsMultipleImages(type)) |
| | | 2683 | | { |
| | 0 | 2684 | | throw new ArgumentException("The change index operation is only applicable to backdrops and screen shots |
| | | 2685 | | } |
| | | 2686 | | |
| | 0 | 2687 | | var info1 = GetImageInfo(type, index1); |
| | 0 | 2688 | | var info2 = GetImageInfo(type, index2); |
| | | 2689 | | |
| | 0 | 2690 | | if (info1 is null || info2 is null) |
| | | 2691 | | { |
| | | 2692 | | // Nothing to do |
| | 0 | 2693 | | return Task.CompletedTask; |
| | | 2694 | | } |
| | | 2695 | | |
| | 0 | 2696 | | if (!info1.IsLocalFile || !info2.IsLocalFile) |
| | | 2697 | | { |
| | | 2698 | | // TODO: Not supported yet |
| | 0 | 2699 | | return Task.CompletedTask; |
| | | 2700 | | } |
| | | 2701 | | |
| | 0 | 2702 | | var path1 = info1.Path; |
| | 0 | 2703 | | var path2 = info2.Path; |
| | | 2704 | | |
| | 0 | 2705 | | FileSystem.SwapFiles(path1, path2); |
| | | 2706 | | |
| | | 2707 | | // Refresh these values |
| | 0 | 2708 | | info1.DateModified = FileSystem.GetLastWriteTimeUtc(info1.Path); |
| | 0 | 2709 | | info2.DateModified = FileSystem.GetLastWriteTimeUtc(info2.Path); |
| | | 2710 | | |
| | 0 | 2711 | | info1.Width = 0; |
| | 0 | 2712 | | info1.Height = 0; |
| | 0 | 2713 | | info2.Width = 0; |
| | 0 | 2714 | | info2.Height = 0; |
| | | 2715 | | |
| | 0 | 2716 | | return UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None); |
| | | 2717 | | } |
| | | 2718 | | |
| | | 2719 | | public virtual bool IsPlayed(User user, UserItemData userItemData) |
| | | 2720 | | { |
| | 0 | 2721 | | userItemData ??= UserDataManager.GetUserData(user, this); |
| | | 2722 | | |
| | 0 | 2723 | | return userItemData is not null && userItemData.Played; |
| | | 2724 | | } |
| | | 2725 | | |
| | | 2726 | | public bool IsFavoriteOrLiked(User user, UserItemData userItemData) |
| | | 2727 | | { |
| | 0 | 2728 | | userItemData ??= UserDataManager.GetUserData(user, this); |
| | | 2729 | | |
| | 0 | 2730 | | return userItemData is not null && (userItemData.IsFavorite || (userItemData.Likes ?? false)); |
| | | 2731 | | } |
| | | 2732 | | |
| | | 2733 | | public virtual bool IsUnplayed(User user, UserItemData userItemData) |
| | | 2734 | | { |
| | 0 | 2735 | | ArgumentNullException.ThrowIfNull(user); |
| | | 2736 | | |
| | 0 | 2737 | | userItemData ??= UserDataManager.GetUserData(user, this); |
| | | 2738 | | |
| | 0 | 2739 | | return userItemData is null || !userItemData.Played; |
| | | 2740 | | } |
| | | 2741 | | |
| | | 2742 | | ItemLookupInfo IHasLookupInfo<ItemLookupInfo>.GetLookupInfo() |
| | | 2743 | | { |
| | 49 | 2744 | | return GetItemLookupInfo<ItemLookupInfo>(); |
| | | 2745 | | } |
| | | 2746 | | |
| | | 2747 | | protected T GetItemLookupInfo<T>() |
| | | 2748 | | where T : ItemLookupInfo, new() |
| | | 2749 | | { |
| | 49 | 2750 | | return new T |
| | 49 | 2751 | | { |
| | 49 | 2752 | | Path = Path, |
| | 49 | 2753 | | MetadataCountryCode = GetPreferredMetadataCountryCode(), |
| | 49 | 2754 | | MetadataLanguage = GetPreferredMetadataLanguage(), |
| | 49 | 2755 | | Name = GetNameForMetadataLookup(), |
| | 49 | 2756 | | OriginalTitle = OriginalTitle, |
| | 49 | 2757 | | ProviderIds = ProviderIds, |
| | 49 | 2758 | | IndexNumber = IndexNumber, |
| | 49 | 2759 | | ParentIndexNumber = ParentIndexNumber, |
| | 49 | 2760 | | Year = ProductionYear, |
| | 49 | 2761 | | PremiereDate = PremiereDate |
| | 49 | 2762 | | }; |
| | | 2763 | | } |
| | | 2764 | | |
| | | 2765 | | protected virtual string GetNameForMetadataLookup() |
| | | 2766 | | { |
| | 49 | 2767 | | return Name; |
| | | 2768 | | } |
| | | 2769 | | |
| | | 2770 | | /// <summary> |
| | | 2771 | | /// This is called before any metadata refresh and returns true if changes were made. |
| | | 2772 | | /// </summary> |
| | | 2773 | | /// <param name="replaceAllMetadata">Whether to replace all metadata.</param> |
| | | 2774 | | /// <returns>true if the item has change, else false.</returns> |
| | | 2775 | | public virtual bool BeforeMetadataRefresh(bool replaceAllMetadata) |
| | | 2776 | | { |
| | 46 | 2777 | | _sortName = null; |
| | | 2778 | | |
| | 46 | 2779 | | var hasChanges = false; |
| | | 2780 | | |
| | 46 | 2781 | | if (string.IsNullOrEmpty(Name) && !string.IsNullOrEmpty(Path)) |
| | | 2782 | | { |
| | 0 | 2783 | | Name = System.IO.Path.GetFileNameWithoutExtension(Path); |
| | 0 | 2784 | | hasChanges = true; |
| | | 2785 | | } |
| | | 2786 | | |
| | 46 | 2787 | | return hasChanges; |
| | | 2788 | | } |
| | | 2789 | | |
| | | 2790 | | protected static string GetMappedPath(BaseItem item, string path, MediaProtocol? protocol) |
| | | 2791 | | { |
| | 0 | 2792 | | if (protocol == MediaProtocol.File) |
| | | 2793 | | { |
| | 0 | 2794 | | return LibraryManager.GetPathAfterNetworkSubstitution(path, item); |
| | | 2795 | | } |
| | | 2796 | | |
| | 0 | 2797 | | return path; |
| | | 2798 | | } |
| | | 2799 | | |
| | | 2800 | | public virtual void FillUserDataDtoValues( |
| | | 2801 | | UserItemDataDto dto, |
| | | 2802 | | UserItemData userData, |
| | | 2803 | | BaseItemDto itemDto, |
| | | 2804 | | User user, |
| | | 2805 | | DtoOptions fields, |
| | | 2806 | | (int Played, int Total)? precomputedCounts = null) |
| | | 2807 | | { |
| | 0 | 2808 | | if (RunTimeTicks.HasValue) |
| | | 2809 | | { |
| | 0 | 2810 | | double pct = RunTimeTicks.Value; |
| | | 2811 | | |
| | 0 | 2812 | | if (pct > 0) |
| | | 2813 | | { |
| | 0 | 2814 | | pct = userData.PlaybackPositionTicks / pct; |
| | | 2815 | | |
| | 0 | 2816 | | if (pct > 0) |
| | | 2817 | | { |
| | 0 | 2818 | | dto.PlayedPercentage = 100 * pct; |
| | | 2819 | | } |
| | | 2820 | | } |
| | | 2821 | | } |
| | 0 | 2822 | | } |
| | | 2823 | | |
| | | 2824 | | /// <summary> |
| | | 2825 | | /// Applies the owner's premiere date and production year to an owned item, returning whether anything changed. |
| | | 2826 | | /// </summary> |
| | | 2827 | | /// <param name="owner">The owner.</param> |
| | | 2828 | | /// <param name="ownedItem">The owned item.</param> |
| | | 2829 | | /// <returns><c>true</c> if the owned item was changed, else <c>false</c>.</returns> |
| | | 2830 | | internal static bool InheritDatesFromOwner(BaseItem owner, BaseItem ownedItem) |
| | | 2831 | | { |
| | | 2832 | | // Extras have no release date of their own, so the owner's is authoritative. |
| | 4 | 2833 | | var changed = false; |
| | | 2834 | | |
| | 4 | 2835 | | if (owner.ProductionYear is not null && ownedItem.ProductionYear != owner.ProductionYear) |
| | | 2836 | | { |
| | 2 | 2837 | | ownedItem.ProductionYear = owner.ProductionYear; |
| | 2 | 2838 | | changed = true; |
| | | 2839 | | } |
| | | 2840 | | |
| | 4 | 2841 | | if (owner.PremiereDate is not null && ownedItem.PremiereDate != owner.PremiereDate) |
| | | 2842 | | { |
| | 2 | 2843 | | ownedItem.PremiereDate = owner.PremiereDate; |
| | 2 | 2844 | | changed = true; |
| | | 2845 | | } |
| | | 2846 | | |
| | 4 | 2847 | | return changed; |
| | | 2848 | | } |
| | | 2849 | | |
| | | 2850 | | protected async Task RefreshMetadataForOwnedItem(BaseItem ownedItem, bool copyTitleMetadata, MetadataRefreshOpti |
| | | 2851 | | { |
| | 0 | 2852 | | var newOptions = new MetadataRefreshOptions(options) |
| | 0 | 2853 | | { |
| | 0 | 2854 | | SearchResult = null |
| | 0 | 2855 | | }; |
| | | 2856 | | |
| | 0 | 2857 | | var item = this; |
| | | 2858 | | |
| | 0 | 2859 | | if (copyTitleMetadata) |
| | | 2860 | | { |
| | | 2861 | | // Take some data from the main item, for querying purposes |
| | 0 | 2862 | | if (!item.Genres.SequenceEqual(ownedItem.Genres, StringComparer.Ordinal)) |
| | | 2863 | | { |
| | 0 | 2864 | | newOptions.ForceSave = true; |
| | 0 | 2865 | | ownedItem.Genres = item.Genres; |
| | | 2866 | | } |
| | | 2867 | | |
| | 0 | 2868 | | if (!item.Studios.SequenceEqual(ownedItem.Studios, StringComparer.Ordinal)) |
| | | 2869 | | { |
| | 0 | 2870 | | newOptions.ForceSave = true; |
| | 0 | 2871 | | ownedItem.Studios = item.Studios; |
| | | 2872 | | } |
| | | 2873 | | |
| | 0 | 2874 | | if (!item.ProductionLocations.SequenceEqual(ownedItem.ProductionLocations, StringComparer.Ordinal)) |
| | | 2875 | | { |
| | 0 | 2876 | | newOptions.ForceSave = true; |
| | 0 | 2877 | | ownedItem.ProductionLocations = item.ProductionLocations; |
| | | 2878 | | } |
| | | 2879 | | |
| | 0 | 2880 | | if (item.CommunityRating != ownedItem.CommunityRating) |
| | | 2881 | | { |
| | 0 | 2882 | | ownedItem.CommunityRating = item.CommunityRating; |
| | 0 | 2883 | | newOptions.ForceSave = true; |
| | | 2884 | | } |
| | | 2885 | | |
| | 0 | 2886 | | if (item.CriticRating != ownedItem.CriticRating) |
| | | 2887 | | { |
| | 0 | 2888 | | ownedItem.CriticRating = item.CriticRating; |
| | 0 | 2889 | | newOptions.ForceSave = true; |
| | | 2890 | | } |
| | | 2891 | | |
| | 0 | 2892 | | if (!string.Equals(item.Overview, ownedItem.Overview, StringComparison.Ordinal)) |
| | | 2893 | | { |
| | 0 | 2894 | | ownedItem.Overview = item.Overview; |
| | 0 | 2895 | | newOptions.ForceSave = true; |
| | | 2896 | | } |
| | | 2897 | | |
| | 0 | 2898 | | if (!string.Equals(item.OfficialRating, ownedItem.OfficialRating, StringComparison.Ordinal)) |
| | | 2899 | | { |
| | 0 | 2900 | | ownedItem.OfficialRating = item.OfficialRating; |
| | 0 | 2901 | | newOptions.ForceSave = true; |
| | | 2902 | | } |
| | | 2903 | | |
| | 0 | 2904 | | if (!string.Equals(item.CustomRating, ownedItem.CustomRating, StringComparison.Ordinal)) |
| | | 2905 | | { |
| | 0 | 2906 | | ownedItem.CustomRating = item.CustomRating; |
| | 0 | 2907 | | newOptions.ForceSave = true; |
| | | 2908 | | } |
| | | 2909 | | |
| | 0 | 2910 | | if (InheritDatesFromOwner(item, ownedItem)) |
| | | 2911 | | { |
| | 0 | 2912 | | newOptions.ForceSave = true; |
| | | 2913 | | } |
| | | 2914 | | } |
| | | 2915 | | |
| | 0 | 2916 | | await ownedItem.RefreshMetadata(newOptions, cancellationToken).ConfigureAwait(false); |
| | 0 | 2917 | | } |
| | | 2918 | | |
| | | 2919 | | protected async Task RefreshMetadataForOwnedVideo(MetadataRefreshOptions options, bool copyTitleMetadata, string |
| | | 2920 | | { |
| | 0 | 2921 | | var newOptions = new MetadataRefreshOptions(options) |
| | 0 | 2922 | | { |
| | 0 | 2923 | | SearchResult = null |
| | 0 | 2924 | | }; |
| | | 2925 | | |
| | 0 | 2926 | | var id = LibraryManager.GetNewItemId(path, typeof(Video)); |
| | | 2927 | | |
| | | 2928 | | // Try to retrieve it from the db. If we don't find it, use the resolved version |
| | 0 | 2929 | | if (LibraryManager.GetItemById(id) is not Video video) |
| | | 2930 | | { |
| | 0 | 2931 | | video = LibraryManager.ResolvePath(FileSystem.GetFileSystemInfo(path)) as Video; |
| | | 2932 | | |
| | 0 | 2933 | | newOptions.ForceSave = true; |
| | | 2934 | | } |
| | | 2935 | | |
| | 0 | 2936 | | if (video is null) |
| | | 2937 | | { |
| | 0 | 2938 | | return; |
| | | 2939 | | } |
| | | 2940 | | |
| | 0 | 2941 | | if (video.OwnerId.IsEmpty()) |
| | | 2942 | | { |
| | 0 | 2943 | | video.OwnerId = Id; |
| | | 2944 | | } |
| | | 2945 | | |
| | 0 | 2946 | | await RefreshMetadataForOwnedItem(video, copyTitleMetadata, newOptions, cancellationToken).ConfigureAwait(fa |
| | 0 | 2947 | | } |
| | | 2948 | | |
| | | 2949 | | public string GetEtag(User user) |
| | | 2950 | | { |
| | 6 | 2951 | | var list = GetEtagValues(user); |
| | | 2952 | | |
| | 6 | 2953 | | return string.Join('|', list).GetMD5().ToString("N", CultureInfo.InvariantCulture); |
| | | 2954 | | } |
| | | 2955 | | |
| | | 2956 | | protected virtual List<string> GetEtagValues(User user) |
| | | 2957 | | { |
| | 6 | 2958 | | return |
| | 6 | 2959 | | [ |
| | 6 | 2960 | | DateLastSaved.Ticks.ToString(CultureInfo.InvariantCulture) |
| | 6 | 2961 | | ]; |
| | | 2962 | | } |
| | | 2963 | | |
| | | 2964 | | public virtual IEnumerable<Guid> GetAncestorIds() |
| | | 2965 | | { |
| | 171 | 2966 | | return GetParents().Select(i => i.Id).Concat(LibraryManager.GetCollectionFolders(this).Select(i => i.Id)); |
| | | 2967 | | } |
| | | 2968 | | |
| | | 2969 | | public BaseItem GetTopParent() |
| | | 2970 | | { |
| | 171 | 2971 | | if (IsTopParent) |
| | | 2972 | | { |
| | 27 | 2973 | | return this; |
| | | 2974 | | } |
| | | 2975 | | |
| | 144 | 2976 | | return GetParents().FirstOrDefault(parent => parent.IsTopParent); |
| | | 2977 | | } |
| | | 2978 | | |
| | | 2979 | | public virtual IEnumerable<Guid> GetIdsForAncestorQuery() |
| | | 2980 | | { |
| | 103 | 2981 | | return [Id]; |
| | | 2982 | | } |
| | | 2983 | | |
| | | 2984 | | public virtual double? GetRefreshProgress() |
| | | 2985 | | { |
| | 0 | 2986 | | return null; |
| | | 2987 | | } |
| | | 2988 | | |
| | | 2989 | | public virtual ItemUpdateType OnMetadataChanged() |
| | | 2990 | | { |
| | 386 | 2991 | | var updateType = ItemUpdateType.None; |
| | | 2992 | | |
| | 386 | 2993 | | var item = this; |
| | | 2994 | | |
| | 386 | 2995 | | var rating = item.GetParentalRatingScore(); |
| | 386 | 2996 | | if (rating is not null) |
| | | 2997 | | { |
| | 2 | 2998 | | if (rating.Score != item.InheritedParentalRatingValue) |
| | | 2999 | | { |
| | 2 | 3000 | | item.InheritedParentalRatingValue = rating.Score; |
| | 2 | 3001 | | updateType |= ItemUpdateType.MetadataImport; |
| | | 3002 | | } |
| | | 3003 | | |
| | 2 | 3004 | | if (rating.SubScore != item.InheritedParentalRatingSubValue) |
| | | 3005 | | { |
| | 0 | 3006 | | item.InheritedParentalRatingSubValue = rating.SubScore; |
| | 0 | 3007 | | updateType |= ItemUpdateType.MetadataImport; |
| | | 3008 | | } |
| | | 3009 | | } |
| | | 3010 | | else |
| | | 3011 | | { |
| | 384 | 3012 | | if (item.InheritedParentalRatingValue is not null) |
| | | 3013 | | { |
| | 1 | 3014 | | item.InheritedParentalRatingValue = null; |
| | 1 | 3015 | | item.InheritedParentalRatingSubValue = null; |
| | 1 | 3016 | | updateType |= ItemUpdateType.MetadataImport; |
| | | 3017 | | } |
| | | 3018 | | } |
| | | 3019 | | |
| | 386 | 3020 | | return updateType; |
| | | 3021 | | } |
| | | 3022 | | |
| | | 3023 | | /// <summary> |
| | | 3024 | | /// Updates the official rating based on content and returns true or false indicating if it changed. |
| | | 3025 | | /// </summary> |
| | | 3026 | | /// <param name="children">Media children.</param> |
| | | 3027 | | /// <returns><c>true</c> if the rating was updated; otherwise <c>false</c>.</returns> |
| | | 3028 | | public bool UpdateRatingToItems(IReadOnlyList<BaseItem> children) |
| | | 3029 | | { |
| | 0 | 3030 | | var currentOfficialRating = OfficialRating; |
| | | 3031 | | |
| | | 3032 | | // Gather all possible ratings |
| | 0 | 3033 | | var ratings = children |
| | 0 | 3034 | | .Select(i => i.OfficialRating) |
| | 0 | 3035 | | .Where(i => !string.IsNullOrEmpty(i)) |
| | 0 | 3036 | | .Distinct(StringComparer.OrdinalIgnoreCase) |
| | 0 | 3037 | | .Select(rating => (rating, LocalizationManager.GetRatingScore(rating, GetPreferredMetadataCountryCode()) |
| | 0 | 3038 | | .OrderBy(i => i.Item2 is null ? 1001 : i.Item2.Score) |
| | 0 | 3039 | | .ThenBy(i => i.Item2 is null ? 1001 : i.Item2.SubScore) |
| | 0 | 3040 | | .Select(i => i.rating); |
| | | 3041 | | |
| | 0 | 3042 | | OfficialRating = ratings.FirstOrDefault() ?? currentOfficialRating; |
| | | 3043 | | |
| | 0 | 3044 | | return !string.Equals( |
| | 0 | 3045 | | currentOfficialRating ?? string.Empty, |
| | 0 | 3046 | | OfficialRating ?? string.Empty, |
| | 0 | 3047 | | StringComparison.OrdinalIgnoreCase); |
| | | 3048 | | } |
| | | 3049 | | |
| | | 3050 | | public IReadOnlyList<BaseItem> GetThemeSongs(User user = null) |
| | | 3051 | | { |
| | 0 | 3052 | | return GetThemeSongs(user, Array.Empty<(ItemSortBy, SortOrder)>()); |
| | | 3053 | | } |
| | | 3054 | | |
| | | 3055 | | public IReadOnlyList<BaseItem> GetThemeSongs(User user, IEnumerable<(ItemSortBy SortBy, SortOrder SortOrder)> or |
| | | 3056 | | { |
| | 0 | 3057 | | return LibraryManager.Sort(GetExtras(user).Where(e => e.ExtraType == Model.Entities.ExtraType.ThemeSong), us |
| | | 3058 | | } |
| | | 3059 | | |
| | | 3060 | | public IReadOnlyList<BaseItem> GetThemeVideos(User user = null) |
| | | 3061 | | { |
| | 0 | 3062 | | return GetThemeVideos(user, Array.Empty<(ItemSortBy, SortOrder)>()); |
| | | 3063 | | } |
| | | 3064 | | |
| | | 3065 | | public IReadOnlyList<BaseItem> GetThemeVideos(User user, IEnumerable<(ItemSortBy SortBy, SortOrder SortOrder)> o |
| | | 3066 | | { |
| | 0 | 3067 | | return LibraryManager.Sort(GetExtras(user).Where(e => e.ExtraType == Model.Entities.ExtraType.ThemeVideo), u |
| | | 3068 | | } |
| | | 3069 | | |
| | | 3070 | | /// <summary> |
| | | 3071 | | /// Gets the ids of the items whose owned extras belong to this item. |
| | | 3072 | | /// </summary> |
| | | 3073 | | /// <returns>An array containing the owner ids.</returns> |
| | | 3074 | | protected virtual Guid[] GetExtraOwnerIds() |
| | | 3075 | | { |
| | 6 | 3076 | | return [Id]; |
| | | 3077 | | } |
| | | 3078 | | |
| | | 3079 | | /// <summary> |
| | | 3080 | | /// Gets the ids of this item and the versions of it whose extras it maintains. |
| | | 3081 | | /// </summary> |
| | | 3082 | | /// <returns>An array containing the version ids.</returns> |
| | | 3083 | | protected virtual Guid[] GetOwnedVersionIds() |
| | | 3084 | | { |
| | 0 | 3085 | | return [Id]; |
| | | 3086 | | } |
| | | 3087 | | |
| | | 3088 | | /// <summary> |
| | | 3089 | | /// Gets the id of the version an extra belongs to. |
| | | 3090 | | /// </summary> |
| | | 3091 | | /// <param name="extra">The extra.</param> |
| | | 3092 | | /// <returns>The id of the owning version.</returns> |
| | | 3093 | | protected virtual Guid GetOwnerIdForExtra(BaseItem extra) |
| | | 3094 | | { |
| | 0 | 3095 | | return Id; |
| | | 3096 | | } |
| | | 3097 | | |
| | | 3098 | | /// <summary> |
| | | 3099 | | /// Get all extras associated with this item, sorted by <see cref="SortName"/>. |
| | | 3100 | | /// </summary> |
| | | 3101 | | /// <param name="user">The user to apply parental restrictions for, or <c>null</c> to skip restriction checks.</ |
| | | 3102 | | /// <returns>An enumerable containing the items.</returns> |
| | | 3103 | | public IEnumerable<BaseItem> GetExtras(User user = null) |
| | | 3104 | | { |
| | 6 | 3105 | | return LibraryManager.GetItemList(new InternalItemsQuery(user) |
| | 6 | 3106 | | { |
| | 6 | 3107 | | OwnerIds = GetExtraOwnerIds(), |
| | 6 | 3108 | | OrderBy = [(ItemSortBy.SortName, SortOrder.Ascending)] |
| | 6 | 3109 | | }); |
| | | 3110 | | } |
| | | 3111 | | |
| | | 3112 | | /// <summary> |
| | | 3113 | | /// Get all extras with specific types that are associated with this item. |
| | | 3114 | | /// </summary> |
| | | 3115 | | /// <param name="extraTypes">The types of extras to retrieve.</param> |
| | | 3116 | | /// <param name="user">The user to apply parental restrictions for, or <c>null</c> to skip restriction checks.</ |
| | | 3117 | | /// <returns>An enumerable containing the extras.</returns> |
| | | 3118 | | public IEnumerable<BaseItem> GetExtras(IReadOnlyCollection<ExtraType> extraTypes, User user = null) |
| | | 3119 | | { |
| | 0 | 3120 | | return LibraryManager.GetItemList(new InternalItemsQuery(user) |
| | 0 | 3121 | | { |
| | 0 | 3122 | | OwnerIds = GetExtraOwnerIds(), |
| | 0 | 3123 | | ExtraTypes = extraTypes.ToArray(), |
| | 0 | 3124 | | OrderBy = [(ItemSortBy.SortName, SortOrder.Ascending)] |
| | 0 | 3125 | | }); |
| | | 3126 | | } |
| | | 3127 | | |
| | | 3128 | | public virtual long GetRunTimeTicksForPlayState() |
| | | 3129 | | { |
| | 0 | 3130 | | return RunTimeTicks ?? 0; |
| | | 3131 | | } |
| | | 3132 | | |
| | | 3133 | | /// <inheritdoc /> |
| | | 3134 | | public override bool Equals(object obj) |
| | | 3135 | | { |
| | 138 | 3136 | | return obj is BaseItem baseItem && this.Equals(baseItem); |
| | | 3137 | | } |
| | | 3138 | | |
| | | 3139 | | /// <inheritdoc /> |
| | 345 | 3140 | | public bool Equals(BaseItem other) => other is not null && other.Id.Equals(Id); |
| | | 3141 | | |
| | | 3142 | | /// <inheritdoc /> |
| | 141 | 3143 | | public override int GetHashCode() => HashCode.Combine(Id); |
| | | 3144 | | } |
| | | 3145 | | } |