alteropen/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2026-06-08 00:39:25 +01:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

Moved some entities to the main project

Browse Source
This commit is contained in:
LukePulverenti Luke Pulverenti luke pulverenti
2012-09-10 21:34:02 -04:00
parent b1df61f7ce
commit 2467ca9668
73 changed files with 212 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
MediaBrowser.Model/Entities/Audio.cs
View File

@@ -1,14 +0,0 @@

namespace MediaBrowser.Model.Entities
{
public class Audio : BaseItem
{
public int BitRate { get; set; }
public int Channels { get; set; }
public int SampleRate { get; set; }
public string Artist { get; set; }
public string Album { get; set; }
public string AlbumArtist { get; set; }
}
}

25
MediaBrowser.Model/Entities/BaseEntity.cs
View File

@@ -1,25 +0,0 @@
using System;
namespace MediaBrowser.Model.Entities
{
/// <summary>
/// Provides a base entity for all of our types
/// </summary>
public abstract class BaseEntity
{
public string Name { get; set; }
public Guid Id { get; set; }
public string PrimaryImagePath { get; set; }
public DateTime DateCreated { get; set; }
public DateTime DateModified { get; set; }
public override string ToString()
{
return Name;
}
}
}

172
MediaBrowser.Model/Entities/BaseItem.cs
View File

@@ -1,172 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace MediaBrowser.Model.Entities
{
public abstract class BaseItem : BaseEntity, IHasProviderIds
{
public string SortName { get; set; }
/// <summary>
/// When the item first debuted. For movies this could be premiere date, episodes would be first aired
/// </summary>
public DateTime? PremiereDate { get; set; }
public string Path { get; set; }
public Folder Parent { get; set; }
public string LogoImagePath { get; set; }
public string ArtImagePath { get; set; }
public string ThumbnailImagePath { get; set; }
public string BannerImagePath { get; set; }
public IEnumerable<string> BackdropImagePaths { get; set; }
public string OfficialRating { get; set; }
public string CustomRating { get; set; }
public string CustomPin { get; set; }
public string Language { get; set; }
public string Overview { get; set; }
public List<string> Taglines { get; set; }
/// <summary>
/// Using a Dictionary to prevent duplicates
/// </summary>
public Dictionary<string,PersonInfo> People { get; set; }
public List<string> Studios { get; set; }
public List<string> Genres { get; set; }
public string DisplayMediaType { get; set; }
public float? UserRating { get; set; }
public long? RunTimeTicks { get; set; }
public string AspectRatio { get; set; }
public int? ProductionYear { get; set; }
/// <summary>
/// If the item is part of a series, this is it's number in the series.
/// This could be episode number, album track number, etc.
/// </summary>
public int? IndexNumber { get; set; }
/// <summary>
/// For an episode this could be the season number, or for a song this could be the disc number.
/// </summary>
public int? ParentIndexNumber { get; set; }
public IEnumerable<Video> LocalTrailers { get; set; }
public string TrailerUrl { get; set; }
public Dictionary<string, string> ProviderIds { get; set; }
public Dictionary<Guid, UserItemData> UserData { get; set; }
public UserItemData GetUserData(User user, bool createIfNull)
{
if (UserData == null || !UserData.ContainsKey(user.Id))
{
if (createIfNull)
{
AddUserData(user, new UserItemData());
}
else
{
return null;
}
}
return UserData[user.Id];
}
private void AddUserData(User user, UserItemData data)
{
if (UserData == null)
{
UserData = new Dictionary<Guid, UserItemData>();
}
UserData[user.Id] = data;
}
/// <summary>
/// Determines if a given user has access to this item
/// </summary>
internal bool IsParentalAllowed(User user)
{
return true;
}
/// <summary>
/// Finds an item by ID, recursively
/// </summary>
public virtual BaseItem FindItemById(Guid id)
{
if (Id == id)
{
return this;
}
if (LocalTrailers != null)
{
return LocalTrailers.FirstOrDefault(i => i.Id == id);
}
return null;
}
public virtual bool IsFolder
{
get
{
return false;
}
}
/// <summary>
/// Determines if the item is considered new based on user settings
/// </summary>
public bool IsRecentlyAdded(User user)
{
return (DateTime.UtcNow - DateCreated).TotalDays < user.RecentItemDays;
}
public void AddPerson(PersonInfo person)
{
if (People == null)
{
People = new Dictionary<string, PersonInfo>(StringComparer.OrdinalIgnoreCase);
}
People[person.Name] = person;
}
/// <summary>
/// Marks the item as either played or unplayed
/// </summary>
public virtual void SetPlayedStatus(User user, bool wasPlayed)
{
UserItemData data = GetUserData(user, true);
if (wasPlayed)
{
data.PlayCount = Math.Max(data.PlayCount, 1);
}
else
{
data.PlayCount = 0;
data.PlaybackPositionTicks = 0;
}
}
}
}

322
MediaBrowser.Model/Entities/Folder.cs
View File

@@ -1,322 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace MediaBrowser.Model.Entities
{
public class Folder : BaseItem
{
public override bool IsFolder
{
get
{
return true;
}
}
public bool IsRoot { get; set; }
public bool IsVirtualFolder
{
get
{
return Parent != null && Parent.IsRoot;
}
}
public IEnumerable<BaseItem> Children { get; set; }
/// <summary>
/// Gets allowed children of an item
/// </summary>
public IEnumerable<BaseItem> GetParentalAllowedChildren(User user)
{
return Children.Where(c => c.IsParentalAllowed(user));
}
/// <summary>
/// Gets allowed recursive children of an item
/// </summary>
public IEnumerable<BaseItem> GetParentalAllowedRecursiveChildren(User user)
{
foreach (var item in GetParentalAllowedChildren(user))
{
yield return item;
var subFolder = item as Folder;
if (subFolder != null)
{
foreach (var subitem in subFolder.GetParentalAllowedRecursiveChildren(user))
{
yield return subitem;
}
}
}
}
/// <summary>
/// Since it can be slow to make all of these calculations at once, this method will provide a way to get them all back together
/// </summary>
public ItemSpecialCounts GetSpecialCounts(User user)
{
ItemSpecialCounts counts = new ItemSpecialCounts();
IEnumerable<BaseItem> recursiveChildren = GetParentalAllowedRecursiveChildren(user);
counts.RecentlyAddedItemCount = GetRecentlyAddedItems(recursiveChildren, user).Count();
counts.RecentlyAddedUnPlayedItemCount = GetRecentlyAddedUnplayedItems(recursiveChildren, user).Count();
counts.InProgressItemCount = GetInProgressItems(recursiveChildren, user).Count();
counts.PlayedPercentage = GetPlayedPercentage(recursiveChildren, user);
return counts;
}
/// <summary>
/// Finds all recursive items within a top-level parent that contain the given genre and are allowed for the current user
/// </summary>
public IEnumerable<BaseItem> GetItemsWithGenre(string genre, User user)
{
return GetParentalAllowedRecursiveChildren(user).Where(f => f.Genres != null && f.Genres.Any(s => s.Equals(genre, StringComparison.OrdinalIgnoreCase)));
}
/// <summary>
/// Finds all recursive items within a top-level parent that contain the given year and are allowed for the current user
/// </summary>
public IEnumerable<BaseItem> GetItemsWithYear(int year, User user)
{
return GetParentalAllowedRecursiveChildren(user).Where(f => f.ProductionYear.HasValue && f.ProductionYear == year);
}
/// <summary>
/// Finds all recursive items within a top-level parent that contain the given studio and are allowed for the current user
/// </summary>
public IEnumerable<BaseItem> GetItemsWithStudio(string studio, User user)
{
return GetParentalAllowedRecursiveChildren(user).Where(f => f.Studios != null && f.Studios.Any(s => s.Equals(studio, StringComparison.OrdinalIgnoreCase)));
}
/// <summary>
/// Finds all recursive items within a top-level parent that the user has marked as a favorite
/// </summary>
public IEnumerable<BaseItem> GetFavoriteItems(User user)
{
return GetParentalAllowedRecursiveChildren(user).Where(c =>
{
UserItemData data = c.GetUserData(user, false);
if (data != null)
{
return data.IsFavorite;
}
return false;
});
}
/// <summary>
/// Finds all recursive items within a top-level parent that contain the given person and are allowed for the current user
/// </summary>
public IEnumerable<BaseItem> GetItemsWithPerson(string person, User user)
{
return GetParentalAllowedRecursiveChildren(user).Where(c =>
{
if (c.People != null)
{
return c.People.ContainsKey(person);
}
return false;
});
}
/// <summary>
/// Finds all recursive items within a top-level parent that contain the given person and are allowed for the current user
/// </summary>
/// <param name="personType">Specify this to limit results to a specific PersonType</param>
public IEnumerable<BaseItem> GetItemsWithPerson(string person, string personType, User user)
{
return GetParentalAllowedRecursiveChildren(user).Where(c =>
{
if (c.People != null)
{
return c.People.ContainsKey(person) && c.People[person].Type.Equals(personType, StringComparison.OrdinalIgnoreCase);
}
return false;
});
}
/// <summary>
/// Gets all recently added items (recursive) within a folder, based on configuration and parental settings
/// </summary>
public IEnumerable<BaseItem> GetRecentlyAddedItems(User user)
{
return GetRecentlyAddedItems(GetParentalAllowedRecursiveChildren(user), user);
}
/// <summary>
/// Gets all recently added unplayed items (recursive) within a folder, based on configuration and parental settings
/// </summary>
public IEnumerable<BaseItem> GetRecentlyAddedUnplayedItems(User user)
{
return GetRecentlyAddedUnplayedItems(GetParentalAllowedRecursiveChildren(user), user);
}
/// <summary>
/// Gets all in-progress items (recursive) within a folder
/// </summary>
public IEnumerable<BaseItem> GetInProgressItems(User user)
{
return GetInProgressItems(GetParentalAllowedRecursiveChildren(user), user);
}
/// <summary>
/// Takes a list of items and returns the ones that are recently added
/// </summary>
private static IEnumerable<BaseItem> GetRecentlyAddedItems(IEnumerable<BaseItem> itemSet, User user)
{
return itemSet.Where(i => !(i.IsFolder) && i.IsRecentlyAdded(user));
}
/// <summary>
/// Takes a list of items and returns the ones that are recently added and unplayed
/// </summary>
private static IEnumerable<BaseItem> GetRecentlyAddedUnplayedItems(IEnumerable<BaseItem> itemSet, User user)
{
return GetRecentlyAddedItems(itemSet, user).Where(i =>
{
var userdata = i.GetUserData(user, false);
return userdata == null || userdata.PlayCount == 0;
});
}
/// <summary>
/// Takes a list of items and returns the ones that are in progress
/// </summary>
private static IEnumerable<BaseItem> GetInProgressItems(IEnumerable<BaseItem> itemSet, User user)
{
return itemSet.Where(i =>
{
if (i.IsFolder)
{
return false;
}
var userdata = i.GetUserData(user, false);
return userdata != null && userdata.PlaybackPositionTicks > 0;
});
}
/// <summary>
/// Gets the total played percentage for a set of items
/// </summary>
private static decimal GetPlayedPercentage(IEnumerable<BaseItem> itemSet, User user)
{
itemSet = itemSet.Where(i => !(i.IsFolder));
if (!itemSet.Any())
{
return 0;
}
decimal totalPercent = 0;
foreach (BaseItem item in itemSet)
{
UserItemData data = item.GetUserData(user, false);
if (data == null)
{
continue;
}
if (data.PlayCount > 0)
{
totalPercent += 100;
}
else if (data.PlaybackPositionTicks > 0 && item.RunTimeTicks.HasValue)
{
decimal itemPercent = data.PlaybackPositionTicks;
itemPercent /= item.RunTimeTicks.Value;
totalPercent += itemPercent;
}
}
return totalPercent / itemSet.Count();
}
/// <summary>
/// Marks the item as either played or unplayed
/// </summary>
public override void SetPlayedStatus(User user, bool wasPlayed)
{
base.SetPlayedStatus(user, wasPlayed);
// Now sweep through recursively and update status
foreach (BaseItem item in GetParentalAllowedChildren(user))
{
item.SetPlayedStatus(user, wasPlayed);
}
}
/// <summary>
/// Finds an item by ID, recursively
/// </summary>
public override BaseItem FindItemById(Guid id)
{
var result = base.FindItemById(id);
if (result != null)
{
return result;
}
foreach (BaseItem item in Children)
{
result = item.FindItemById(id);
if (result != null)
{
return result;
}
}
return null;
}
/// <summary>
/// Finds an item by path, recursively
/// </summary>
public BaseItem FindByPath(string path)
{
if (Path.Equals(path, StringComparison.OrdinalIgnoreCase))
{
return this;
}
foreach (BaseItem item in Children)
{
var folder = item as Folder;
if (folder != null)
{
var foundItem = folder.FindByPath(path);
if (foundItem != null)
{
return foundItem;
}
}
else if (item.Path.Equals(path, StringComparison.OrdinalIgnoreCase))
{
return item;
}
}
return null;
}
}
}

7
MediaBrowser.Model/Entities/Genre.cs
View File

@@ -1,7 +0,0 @@

namespace MediaBrowser.Model.Entities
{
public class Genre : BaseEntity
{
}
}

43
MediaBrowser.Model/Entities/ItemSpecialCounts.cs
View File

@@ -20,4 +20,47 @@ namespace MediaBrowser.Model.Entities
[ProtoMember(4)]
public decimal PlayedPercentage { get; set; }
}
[ProtoContract]
public class AudioStream
{
[ProtoMember(1)]
public string Codec { get; set; }
[ProtoMember(2)]
public string Language { get; set; }
[ProtoMember(3)]
public int BitRate { get; set; }
[ProtoMember(4)]
public int Channels { get; set; }
[ProtoMember(5)]
public int SampleRate { get; set; }
[ProtoMember(6)]
public bool IsDefault { get; set; }
}
[ProtoContract]
public class SubtitleStream
{
[ProtoMember(1)]
public string Language { get; set; }
[ProtoMember(2)]
public bool IsDefault { get; set; }
[ProtoMember(3)]
public bool IsForced { get; set; }
}
public enum VideoType
{
VideoFile,
Iso,
DVD,
BluRay
}
}

7
MediaBrowser.Model/Entities/Movies/BoxSet.cs
View File

@@ -1,7 +0,0 @@

namespace MediaBrowser.Model.Entities.Movies
{
public class BoxSet : Folder
{
}
}

31
MediaBrowser.Model/Entities/Movies/Movie.cs
View File

@@ -1,31 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
namespace MediaBrowser.Model.Entities.Movies
{
public class Movie : Video
{
public IEnumerable<Video> SpecialFeatures { get; set; }
/// <summary>
/// Finds an item by ID, recursively
/// </summary>
public override BaseItem FindItemById(Guid id)
{
var item = base.FindItemById(id);
if (item != null)
{
return item;
}
if (SpecialFeatures != null)
{
return SpecialFeatures.FirstOrDefault(i => i.Id == id);
}
return null;
}
}
}

25
MediaBrowser.Model/Entities/Person.cs
View File

@@ -1,25 +0,0 @@

namespace MediaBrowser.Model.Entities
{
/// <summary>
/// This is the full Person object that can be retrieved with all of it's data.
/// </summary>
public class Person : BaseEntity
{
}
/// <summary>
/// This is the small Person stub that is attached to BaseItems
/// </summary>
public class PersonInfo
{
public string Name { get; set; }
public string Overview { get; set; }
public string Type { get; set; }
public override string ToString()
{
return Name;
}
}
}

7
MediaBrowser.Model/Entities/Studio.cs
View File

@@ -1,7 +0,0 @@

namespace MediaBrowser.Model.Entities
{
public class Studio : BaseEntity
{
}
}

7
MediaBrowser.Model/Entities/TV/Episode.cs
View File

@@ -1,7 +0,0 @@

namespace MediaBrowser.Model.Entities.TV
{
public class Episode : Video
{
}
}

28
MediaBrowser.Model/Entities/TV/Season.cs
View File

@@ -1,28 +0,0 @@
using System;
namespace MediaBrowser.Model.Entities.TV
{
public class Season : Folder
{
/// <summary>
/// Store these to reduce disk access in Episode Resolver
/// </summary>
public string[] MetadataFiles { get; set; }
/// <summary>
/// Determines if the metafolder contains a given file
/// </summary>
public bool ContainsMetadataFile(string file)
{
for (int i = 0; i < MetadataFiles.Length; i++)
{
if (MetadataFiles[i].Equals(file, StringComparison.OrdinalIgnoreCase))
{
return true;
}
}
return false;
}
}
}

12
MediaBrowser.Model/Entities/TV/Series.cs
View File

@@ -1,12 +0,0 @@
using System;
using System.Collections.Generic;
namespace MediaBrowser.Model.Entities.TV
{
public class Series : Folder
{
public string Status { get; set; }
public IEnumerable<DayOfWeek> AirDays { get; set; }
public string AirTime { get; set; }
}
}

21
MediaBrowser.Model/Entities/User.cs
View File

@@ -1,21 +0,0 @@
using System;
namespace MediaBrowser.Model.Entities
{
public class User : BaseEntity
{
public string Password { get; set; }
public string MaxParentalRating { get; set; }
public int RecentItemDays { get; set; }
public User()
{
RecentItemDays = 14;
}
public DateTime? LastLoginDate { get; set; }
public DateTime? LastActivityDate { get; set; }
}
}

67
MediaBrowser.Model/Entities/UserItemData.cs
View File

@@ -1,67 +0,0 @@
using System;
using System.Runtime.Serialization;
namespace MediaBrowser.Model.Entities
{
public class UserItemData
{
private float? _Rating = null;
/// <summary>
/// Gets or sets the users 0-10 rating
/// </summary>
public float? Rating
{
get
{
return _Rating;
}
set
{
if (value.HasValue)
{
if (value.Value < 0 || value.Value > 10)
{
throw new InvalidOperationException("A 0-10 rating is required for UserItemData.");
}
}
_Rating = value;
}
}
public long PlaybackPositionTicks { get; set; }
public int PlayCount { get; set; }
public bool IsFavorite { get; set; }
/// <summary>
/// This is an interpreted property to indicate likes or dislikes
/// This should never be serialized.
/// </summary>
[IgnoreDataMember]
public bool? Likes
{
get
{
if (Rating != null)
{
return Rating >= 6.5;
}
return null;
}
set
{
if (value.HasValue)
{
Rating = value.Value ? 10 : 1;
}
else
{
Rating = null;
}
}
}
}
}

63
MediaBrowser.Model/Entities/Video.cs
View File

@@ -1,63 +0,0 @@
using System.Collections.Generic;
using ProtoBuf;
namespace MediaBrowser.Model.Entities
{
public class Video : BaseItem
{
public VideoType VideoType { get; set; }
public List<SubtitleStream> Subtitles { get; set; }
public List<AudioStream> AudioStreams { get; set; }
public int Height { get; set; }
public int Width { get; set; }
public string ScanType { get; set; }
public float FrameRate { get; set; }
public int BitRate { get; set; }
public string Codec { get; set; }
}
[ProtoContract]
public class AudioStream
{
[ProtoMember(1)]
public string Codec { get; set; }
[ProtoMember(2)]
public string Language { get; set; }
[ProtoMember(3)]
public int BitRate { get; set; }
[ProtoMember(4)]
public int Channels { get; set; }
[ProtoMember(5)]
public int SampleRate { get; set; }
[ProtoMember(6)]
public bool IsDefault { get; set; }
}
[ProtoContract]
public class SubtitleStream
{
[ProtoMember(1)]
public string Language { get; set; }
[ProtoMember(2)]
public bool IsDefault { get; set; }
[ProtoMember(3)]
public bool IsForced { get; set; }
}
public enum VideoType
{
VideoFile,
Iso,
DVD,
BluRay
}
}

7
MediaBrowser.Model/Entities/Year.cs
View File

@@ -1,7 +0,0 @@

namespace MediaBrowser.Model.Entities
{
public class Year : BaseEntity
{
}
}

16
MediaBrowser.Model/MediaBrowser.Model.csproj
View File

@@ -44,31 +44,15 @@
<Compile Include="DTO\DTOUser.cs" />
<Compile Include="DTO\VideoInfo.cs" />
<Compile Include="DTO\VideoOutputFormats.cs" />
<Compile Include="Entities\Audio.cs" />
<Compile Include="Entities\BaseEntity.cs" />
<Compile Include="Entities\BaseItem.cs" />
<Compile Include="DTO\IBNItem.cs" />
<Compile Include="Entities\Folder.cs" />
<Compile Include="Entities\Genre.cs" />
<Compile Include="Entities\ImageType.cs" />
<Compile Include="Entities\IHasProviderIds.cs" />
<Compile Include="Entities\ItemSpecialCounts.cs" />
<Compile Include="Entities\MetadataProviders.cs" />
<Compile Include="Entities\Movies\BoxSet.cs" />
<Compile Include="Entities\Movies\Movie.cs" />
<Compile Include="Entities\Person.cs" />
<Compile Include="Entities\Studio.cs" />
<Compile Include="Entities\TV\Episode.cs" />
<Compile Include="Entities\TV\Season.cs" />
<Compile Include="Entities\TV\Series.cs" />
<Compile Include="Entities\Video.cs" />
<Compile Include="Entities\Year.cs" />
<Compile Include="Plugins\BasePluginConfiguration.cs" />
<Compile Include="DTO\PluginInfo.cs" />
<Compile Include="Progress\TaskProgress.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Entities\User.cs" />
<Compile Include="Entities\UserItemData.cs" />
<Compile Include="Weather\WeatherForecast.cs" />
<Compile Include="Weather\WeatherInfo.cs" />
<Compile Include="Weather\WeatherStatus.cs" />