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