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