public ActionResult <IEnumerable <BaseItemDto> > GetAncestors([FromRoute, Required] Guid itemId, [FromQuery] Guid?userId)
{
var item = _libraryManager.GetItemById(itemId);
if (item == null)
{
return(NotFound("Item not found"));
}
var baseItemDtos = new List <BaseItemDto>();
var user = userId.HasValue && !userId.Equals(Guid.Empty)
? _userManager.GetUserById(userId.Value)
: null;
var dtoOptions = new DtoOptions().AddClientFields(Request);
BaseItem?parent = item.GetParent();
while (parent != null)
{
if (user != null)
{
parent = TranslateParentItem(parent, user);
}
baseItemDtos.Add(_dtoService.GetBaseItemDto(parent, dtoOptions, user));
parent = parent?.GetParent();
}
return(baseItemDtos);
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
if (!x.IndexNumber.HasValue && !y.IndexNumber.HasValue)
{
return(0);
}
if (!x.IndexNumber.HasValue)
{
return(-1);
}
if (!y.IndexNumber.HasValue)
{
return(1);
}
return(x.IndexNumber.Value.CompareTo(y.IndexNumber.Value));
}
/// <summary>
/// Gets the affected base item.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>BaseItem.</returns>
private BaseItem?GetAffectedBaseItem(string path)
{
BaseItem?item = null;
while (item == null && !string.IsNullOrEmpty(path))
{
item = _libraryManager.FindByPath(path, null);
path = System.IO.Path.GetDirectoryName(path) ?? string.Empty;
}
if (item != null)
{
// If the item has been deleted find the first valid parent that still exists
while (!Directory.Exists(item.Path) && !File.Exists(item.Path))
{
item = item.GetOwner() ?? item.GetParent();
if (item == null)
{
break;
}
}
}
return(item);
}
/// <summary>
/// Gets the date.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>DateTime.</returns>
private static DateTime GetDate(BaseItem?x)
{
if (x == null)
{
return(DateTime.MinValue);
}
if (x.PremiereDate.HasValue)
{
return(x.PremiereDate.Value);
}
if (x.ProductionYear.HasValue)
{
try
{
return(new DateTime(x.ProductionYear.Value, 1, 1, 0, 0, 0, DateTimeKind.Utc));
}
catch (ArgumentOutOfRangeException)
{
// Don't blow up if the item has a bad ProductionYear, just return MinValue
}
}
return(DateTime.MinValue);
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
var episode1 = x as Episode;
var episode2 = y as Episode;
if (episode1 == null)
{
if (episode2 == null)
{
return(0);
}
return(1);
}
if (episode2 == null)
{
return(-1);
}
return(Compare(episode1, episode2));
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>System.String.</returns>
private static string?GetValue(BaseItem?x)
{
if (x is not Audio audio)
{
return(string.Empty);
}
return(audio.Artists.Count == 0 ? null : audio.Artists[0]);
}
private async Task SendNotification(NotificationRequest notification, BaseItem?relatedItem)
{
try
{
await _notificationManager.SendNotification(notification, relatedItem, CancellationToken.None).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error sending notification");
}
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
return((x.CommunityRating ?? 0).CompareTo(y.CommunityRating ?? 0));
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
return(string.Compare(x.Name, y.Name, StringComparison.CurrentCultureIgnoreCase));
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
return(DateTime.Compare(x.DateCreated, y.DateCreated));
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
var levelX = string.IsNullOrEmpty(x.OfficialRating) ? 0 : _localization.GetRatingLevel(x.OfficialRating) ?? 0;
var levelY = string.IsNullOrEmpty(y.OfficialRating) ? 0 : _localization.GetRatingLevel(y.OfficialRating) ?? 0;
return(levelX.CompareTo(levelY));
}
/// <summary>
/// Gets the date.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>DateTime.</returns>
private static int GetValue(BaseItem?x)
{
if (x == null)
{
return(0);
}
if (x.ProductionYear.HasValue)
{
return(x.ProductionYear.Value);
}
if (x.PremiereDate.HasValue)
{
return(x.PremiereDate.Value.Year);
}
return(0);
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
if (x.PremiereDate.HasValue && y.PremiereDate.HasValue)
{
var val = DateTime.Compare(x.PremiereDate.Value, y.PremiereDate.Value);
if (val != 0)
{
// return val;
}
}
var episode1 = x as Episode;
var episode2 = y as Episode;
if (episode1 == null)
{
if (episode2 == null)
{
return(0);
}
return(1);
}
if (episode2 == null)
{
return(-1);
}
return(Compare(episode1, episode2));
}
/// <inheritdoc />
public Task SendNotification(NotificationRequest request, BaseItem?relatedItem, CancellationToken cancellationToken)
{
var notificationType = request.NotificationType;
var options = string.IsNullOrEmpty(notificationType) ?
null :
GetConfiguration().GetOptions(notificationType);
var users = GetUserIds(request, options)
.Select(i => _userManager.GetUserById(i))
.Where(i => relatedItem == null || relatedItem.IsVisibleStandalone(i))
.ToArray();
var title = request.Name;
var description = request.Description;
var tasks = _services.Where(i => IsEnabled(i, notificationType))
.Select(i => SendNotification(request, i, users, title, description, cancellationToken));
return(Task.WhenAll(tasks));
}
public ActionResult <QueryFiltersLegacy> GetQueryFiltersLegacy(
[FromQuery] Guid?userId,
[FromQuery] Guid?parentId,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] BaseItemKind[] includeItemTypes,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] string[] mediaTypes)
{
var user = userId.HasValue && !userId.Equals(Guid.Empty)
? _userManager.GetUserById(userId.Value)
: null;
BaseItem?item = null;
if (includeItemTypes.Length != 1 ||
!(includeItemTypes[0] == BaseItemKind.BoxSet ||
includeItemTypes[0] == BaseItemKind.Playlist ||
includeItemTypes[0] == BaseItemKind.Trailer ||
includeItemTypes[0] == BaseItemKind.Program))
{
item = _libraryManager.GetParentItem(parentId, user?.Id);
}
var query = new InternalItemsQuery
{
User = user,
MediaTypes = mediaTypes,
IncludeItemTypes = includeItemTypes,
Recursive = true,
EnableTotalRecordCount = false,
DtoOptions = new DtoOptions
{
Fields = new[] { ItemFields.Genres, ItemFields.Tags },
EnableImages = false,
EnableUserData = false
}
};
if (item is not Folder folder)
{
return(new QueryFiltersLegacy());
}
var itemList = folder.GetItemList(query);
return(new QueryFiltersLegacy
{
Years = itemList.Select(i => i.ProductionYear ?? -1)
.Where(i => i > 0)
.Distinct()
.OrderBy(i => i)
.ToArray(),
Genres = itemList.SelectMany(i => i.Genres)
.DistinctNames()
.OrderBy(i => i)
.ToArray(),
Tags = itemList
.SelectMany(i => i.Tags)
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(i => i)
.ToArray(),
OfficialRatings = itemList
.Select(i => i.OfficialRating)
.Where(i => !string.IsNullOrWhiteSpace(i))
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(i => i)
.ToArray()
});
}
public void Compare_GivenNull_ThrowsArgumentNullException(BaseItem?x, BaseItem?y)
{
var cmp = new AiredEpisodeOrderComparer();
Assert.Throws <ArgumentNullException>(() => cmp.Compare(x, y));
}
public ActionResult <QueryFilters> GetQueryFilters(
[FromQuery] Guid?userId,
[FromQuery] Guid?parentId,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] BaseItemKind[] includeItemTypes,
[FromQuery] bool?isAiring,
[FromQuery] bool?isMovie,
[FromQuery] bool?isSports,
[FromQuery] bool?isKids,
[FromQuery] bool?isNews,
[FromQuery] bool?isSeries,
[FromQuery] bool?recursive)
{
var user = userId.HasValue && !userId.Equals(Guid.Empty)
? _userManager.GetUserById(userId.Value)
: null;
BaseItem?parentItem = null;
if (includeItemTypes.Length == 1 &&
(includeItemTypes[0] == BaseItemKind.BoxSet ||
includeItemTypes[0] == BaseItemKind.Playlist ||
includeItemTypes[0] == BaseItemKind.Trailer ||
includeItemTypes[0] == BaseItemKind.Program))
{
parentItem = null;
}
else if (parentId.HasValue)
{
parentItem = _libraryManager.GetItemById(parentId.Value);
}
var filters = new QueryFilters();
var genreQuery = new InternalItemsQuery(user)
{
IncludeItemTypes = includeItemTypes,
DtoOptions = new DtoOptions
{
Fields = Array.Empty <ItemFields>(),
EnableImages = false,
EnableUserData = false
},
IsAiring = isAiring,
IsMovie = isMovie,
IsSports = isSports,
IsKids = isKids,
IsNews = isNews,
IsSeries = isSeries
};
if ((recursive ?? true) || parentItem is UserView || parentItem is ICollectionFolder)
{
genreQuery.AncestorIds = parentItem == null?Array.Empty <Guid>() : new[] { parentItem.Id };
}
else
{
genreQuery.Parent = parentItem;
}
if (includeItemTypes.Length == 1 &&
(includeItemTypes[0] == BaseItemKind.MusicAlbum ||
includeItemTypes[0] == BaseItemKind.MusicVideo ||
includeItemTypes[0] == BaseItemKind.MusicArtist ||
includeItemTypes[0] == BaseItemKind.Audio))
{
filters.Genres = _libraryManager.GetMusicGenres(genreQuery).Items.Select(i => new NameGuidPair
{
Name = i.Item.Name,
Id = i.Item.Id
}).ToArray();
}
else
{
filters.Genres = _libraryManager.GetGenres(genreQuery).Items.Select(i => new NameGuidPair
{
Name = i.Item.Name,
Id = i.Item.Id
}).ToArray();
}
return(filters);
}
public ActionResult <QueryResult <BaseItemDto> > GetItems(
[FromRoute, Required] Guid?uId,
[FromQuery] Guid?userId,
[FromQuery] string?maxOfficialRating,
[FromQuery] bool?hasThemeSong,
[FromQuery] bool?hasThemeVideo,
[FromQuery] bool?hasSubtitles,
[FromQuery] bool?hasSpecialFeature,
[FromQuery] bool?hasTrailer,
[FromQuery] string?adjacentTo,
[FromQuery] int?parentIndexNumber,
[FromQuery] bool?hasParentalRating,
[FromQuery] bool?isHd,
[FromQuery] bool?is4K,
[FromQuery] string?locationTypes,
[FromQuery] string?excludeLocationTypes,
[FromQuery] bool?isMissing,
[FromQuery] bool?isUnaired,
[FromQuery] double?minCommunityRating,
[FromQuery] double?minCriticRating,
[FromQuery] DateTime?minPremiereDate,
[FromQuery] DateTime?minDateLastSaved,
[FromQuery] DateTime?minDateLastSavedForUser,
[FromQuery] DateTime?maxPremiereDate,
[FromQuery] bool?hasOverview,
[FromQuery] bool?hasImdbId,
[FromQuery] bool?hasTmdbId,
[FromQuery] bool?hasTvdbId,
[FromQuery] string?excludeItemIds,
[FromQuery] int?startIndex,
[FromQuery] int?limit,
[FromQuery] bool?recursive,
[FromQuery] string?searchTerm,
[FromQuery] string?sortOrder,
[FromQuery] string?parentId,
[FromQuery] string?fields,
[FromQuery] string?excludeItemTypes,
[FromQuery] string?includeItemTypes,
[FromQuery] string?filters,
[FromQuery] bool?isFavorite,
[FromQuery] string?mediaTypes,
[FromQuery] string?imageTypes,
[FromQuery] string?sortBy,
[FromQuery] bool?isPlayed,
[FromQuery] string?genres,
[FromQuery] string?officialRatings,
[FromQuery] string?tags,
[FromQuery] string?years,
[FromQuery] bool?enableUserData,
[FromQuery] int?imageTypeLimit,
[FromQuery] string?enableImageTypes,
[FromQuery] string?person,
[FromQuery] string?personIds,
[FromQuery] string?personTypes,
[FromQuery] string?studios,
[FromQuery] string?artists,
[FromQuery] string?excludeArtistIds,
[FromQuery] string?artistIds,
[FromQuery] string?albumArtistIds,
[FromQuery] string?contributingArtistIds,
[FromQuery] string?albums,
[FromQuery] string?albumIds,
[FromQuery] string?ids,
[FromQuery] string?videoTypes,
[FromQuery] string?minOfficialRating,
[FromQuery] bool?isLocked,
[FromQuery] bool?isPlaceHolder,
[FromQuery] bool?hasOfficialRating,
[FromQuery] bool?collapseBoxSetItems,
[FromQuery] int?minWidth,
[FromQuery] int?minHeight,
[FromQuery] int?maxWidth,
[FromQuery] int?maxHeight,
[FromQuery] bool?is3D,
[FromQuery] string?seriesStatus,
[FromQuery] string?nameStartsWithOrGreater,
[FromQuery] string?nameStartsWith,
[FromQuery] string?nameLessThan,
[FromQuery] string?studioIds,
[FromQuery] string?genreIds,
[FromQuery] bool enableTotalRecordCount = true,
[FromQuery] bool?enableImages = true)
{
// use user id route parameter over query parameter
userId = uId ?? userId;
var user = userId.HasValue && !userId.Equals(Guid.Empty)
? _userManager.GetUserById(userId.Value)
: null;
var dtoOptions = new DtoOptions()
.AddItemFields(fields)
.AddClientFields(Request)
.AddAdditionalDtoOptions(enableImages, enableUserData, imageTypeLimit, enableImageTypes);
if (string.Equals(includeItemTypes, "Playlist", StringComparison.OrdinalIgnoreCase) ||
string.Equals(includeItemTypes, "BoxSet", StringComparison.OrdinalIgnoreCase))
{
parentId = null;
}
BaseItem?item = null;
QueryResult <BaseItem> result;
if (!string.IsNullOrEmpty(parentId))
{
item = _libraryManager.GetItemById(parentId);
}
item ??= _libraryManager.GetUserRootFolder();
if (!(item is Folder folder))
{
folder = _libraryManager.GetUserRootFolder();
}
if (folder is IHasCollectionType hasCollectionType &&
string.Equals(hasCollectionType.CollectionType, CollectionType.Playlists, StringComparison.OrdinalIgnoreCase))
{
recursive = true;
includeItemTypes = "Playlist";
}
bool isInEnabledFolder = user !.GetPreference(PreferenceKind.EnabledFolders).Any(i => new Guid(i) == item.Id)
// Assume all folders inside an EnabledChannel are enabled
|| user.GetPreference(PreferenceKind.EnabledChannels).Any(i => new Guid(i) == item.Id)
// Assume all items inside an EnabledChannel are enabled
|| user.GetPreference(PreferenceKind.EnabledChannels).Any(i => new Guid(i) == item.ChannelId);
var collectionFolders = _libraryManager.GetCollectionFolders(item);
foreach (var collectionFolder in collectionFolders)
{
if (user.GetPreference(PreferenceKind.EnabledFolders).Contains(
collectionFolder.Id.ToString("N", CultureInfo.InvariantCulture),
StringComparer.OrdinalIgnoreCase))
{
isInEnabledFolder = true;
}
}
if (!(item is UserRootFolder) &&
!isInEnabledFolder &&
!user.HasPermission(PermissionKind.EnableAllFolders) &&
!user.HasPermission(PermissionKind.EnableAllChannels))
{
_logger.LogWarning("{UserName} is not permitted to access Library {ItemName}.", user.Username, item.Name);
return(Unauthorized($"{user.Username} is not permitted to access Library {item.Name}."));
}
if ((recursive.HasValue && recursive.Value) || !string.IsNullOrEmpty(ids) || !(item is UserRootFolder))
{
var query = new InternalItemsQuery(user !)
{
IsPlayed = isPlayed,
MediaTypes = RequestHelpers.Split(mediaTypes, ',', true),
IncludeItemTypes = RequestHelpers.Split(includeItemTypes, ',', true),
ExcludeItemTypes = RequestHelpers.Split(excludeItemTypes, ',', true),
Recursive = recursive ?? false,
OrderBy = RequestHelpers.GetOrderBy(sortBy, sortOrder),
IsFavorite = isFavorite,
Limit = limit,
StartIndex = startIndex,
IsMissing = isMissing,
IsUnaired = isUnaired,
CollapseBoxSetItems = collapseBoxSetItems,
NameLessThan = nameLessThan,
NameStartsWith = nameStartsWith,
NameStartsWithOrGreater = nameStartsWithOrGreater,
HasImdbId = hasImdbId,
IsPlaceHolder = isPlaceHolder,
IsLocked = isLocked,
MinWidth = minWidth,
MinHeight = minHeight,
MaxWidth = maxWidth,
MaxHeight = maxHeight,
Is3D = is3D,
HasTvdbId = hasTvdbId,
HasTmdbId = hasTmdbId,
HasOverview = hasOverview,
HasOfficialRating = hasOfficialRating,
HasParentalRating = hasParentalRating,
HasSpecialFeature = hasSpecialFeature,
HasSubtitles = hasSubtitles,
HasThemeSong = hasThemeSong,
HasThemeVideo = hasThemeVideo,
HasTrailer = hasTrailer,
IsHD = isHd,
Is4K = is4K,
Tags = RequestHelpers.Split(tags, '|', true),
OfficialRatings = RequestHelpers.Split(officialRatings, '|', true),
Genres = RequestHelpers.Split(genres, '|', true),
ArtistIds = RequestHelpers.GetGuids(artistIds),
AlbumArtistIds = RequestHelpers.GetGuids(albumArtistIds),
ContributingArtistIds = RequestHelpers.GetGuids(contributingArtistIds),
GenreIds = RequestHelpers.GetGuids(genreIds),
StudioIds = RequestHelpers.GetGuids(studioIds),
Person = person,
PersonIds = RequestHelpers.GetGuids(personIds),
PersonTypes = RequestHelpers.Split(personTypes, ',', true),
Years = RequestHelpers.Split(years, ',', true).Select(int.Parse).ToArray(),
ImageTypes = RequestHelpers.Split(imageTypes, ',', true).Select(v => Enum.Parse <ImageType>(v, true)).ToArray(),
VideoTypes = RequestHelpers.Split(videoTypes, ',', true).Select(v => Enum.Parse <VideoType>(v, true)).ToArray(),
AdjacentTo = adjacentTo,
ItemIds = RequestHelpers.GetGuids(ids),
MinCommunityRating = minCommunityRating,
MinCriticRating = minCriticRating,
ParentId = string.IsNullOrWhiteSpace(parentId) ? Guid.Empty : new Guid(parentId),
ParentIndexNumber = parentIndexNumber,
EnableTotalRecordCount = enableTotalRecordCount,
ExcludeItemIds = RequestHelpers.GetGuids(excludeItemIds),
DtoOptions = dtoOptions,
SearchTerm = searchTerm,
MinDateLastSaved = minDateLastSaved?.ToUniversalTime(),
MinDateLastSavedForUser = minDateLastSavedForUser?.ToUniversalTime(),
MinPremiereDate = minPremiereDate?.ToUniversalTime(),
MaxPremiereDate = maxPremiereDate?.ToUniversalTime(),
};
if (!string.IsNullOrWhiteSpace(ids) || !string.IsNullOrWhiteSpace(searchTerm))
{
query.CollapseBoxSetItems = false;
}
foreach (var filter in RequestHelpers.GetFilters(filters !))
{
switch (filter)
{
case ItemFilter.Dislikes:
query.IsLiked = false;
break;
case ItemFilter.IsFavorite:
query.IsFavorite = true;
break;
case ItemFilter.IsFavoriteOrLikes:
query.IsFavoriteOrLiked = true;
break;
case ItemFilter.IsFolder:
query.IsFolder = true;
break;
case ItemFilter.IsNotFolder:
query.IsFolder = false;
break;
case ItemFilter.IsPlayed:
query.IsPlayed = true;
break;
case ItemFilter.IsResumable:
query.IsResumable = true;
break;
case ItemFilter.IsUnplayed:
query.IsPlayed = false;
break;
case ItemFilter.Likes:
query.IsLiked = true;
break;
}
}
// Filter by Series Status
if (!string.IsNullOrEmpty(seriesStatus))
{
query.SeriesStatuses = seriesStatus.Split(',').Select(d => (SeriesStatus)Enum.Parse(typeof(SeriesStatus), d, true)).ToArray();
}
// ExcludeLocationTypes
if (!string.IsNullOrEmpty(excludeLocationTypes))
{
if (excludeLocationTypes.Split(',').Select(d => (LocationType)Enum.Parse(typeof(LocationType), d, true)).ToArray().Contains(LocationType.Virtual))
{
query.IsVirtualItem = false;
}
}
if (!string.IsNullOrEmpty(locationTypes))
{
var requestedLocationTypes = locationTypes.Split(',');
if (requestedLocationTypes.Length > 0 && requestedLocationTypes.Length < 4)
{
query.IsVirtualItem = requestedLocationTypes.Contains(LocationType.Virtual.ToString());
}
}
// Min official rating
if (!string.IsNullOrWhiteSpace(minOfficialRating))
{
query.MinParentalRating = _localization.GetRatingLevel(minOfficialRating);
}
// Max official rating
if (!string.IsNullOrWhiteSpace(maxOfficialRating))
{
query.MaxParentalRating = _localization.GetRatingLevel(maxOfficialRating);
}
// Artists
if (!string.IsNullOrEmpty(artists))
{
query.ArtistIds = artists.Split('|').Select(i =>
{
try
{
return(_libraryManager.GetArtist(i, new DtoOptions(false)));
}
catch
{
return(null);
}
}).Where(i => i != null).Select(i => i !.Id).ToArray();
}
// ExcludeArtistIds
if (!string.IsNullOrWhiteSpace(excludeArtistIds))
{
query.ExcludeArtistIds = RequestHelpers.GetGuids(excludeArtistIds);
}
if (!string.IsNullOrWhiteSpace(albumIds))
{
query.AlbumIds = RequestHelpers.GetGuids(albumIds);
}
// Albums
if (!string.IsNullOrEmpty(albums))
{
query.AlbumIds = albums.Split('|').SelectMany(i =>
{
return(_libraryManager.GetItemIds(new InternalItemsQuery {
IncludeItemTypes = new[] { nameof(MusicAlbum) }, Name = i, Limit = 1
}));
}).ToArray();
}
// Studios
if (!string.IsNullOrEmpty(studios))
{
query.StudioIds = studios.Split('|').Select(i =>
{
try
{
return(_libraryManager.GetStudio(i));
}
catch
{
return(null);
}
}).Where(i => i != null).Select(i => i !.Id).ToArray();
}
// Apply default sorting if none requested
if (query.OrderBy.Count == 0)
{
// Albums by artist
if (query.ArtistIds.Length > 0 && query.IncludeItemTypes.Length == 1 && string.Equals(query.IncludeItemTypes[0], "MusicAlbum", StringComparison.OrdinalIgnoreCase))
{
query.OrderBy = new[] { new ValueTuple <string, SortOrder>(ItemSortBy.ProductionYear, SortOrder.Descending), new ValueTuple <string, SortOrder>(ItemSortBy.SortName, SortOrder.Ascending) };
}
}
result = folder.GetItems(query);
}
else
{
var itemsArray = folder.GetChildren(user, true);
result = new QueryResult <BaseItem> {
Items = itemsArray, TotalRecordCount = itemsArray.Count, StartIndex = 0
};
}
return(new QueryResult <BaseItemDto> {
StartIndex = startIndex.GetValueOrDefault(), TotalRecordCount = result.TotalRecordCount, Items = _dtoService.GetBaseItemDtos(result.Items, dtoOptions, user)
});
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
return(Guid.NewGuid().CompareTo(Guid.NewGuid()));
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
return(string.Compare(GetValue(x), GetValue(y), StringComparison.CurrentCultureIgnoreCase));
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>System.String.</returns>
private static string?GetValue(BaseItem?x)
{
var audio = x as IHasAlbumArtist;
return(audio?.AlbumArtists.FirstOrDefault());
}
private static float GetValue(BaseItem?x)
{
return(x?.CriticRating ?? 0);
}
/// <summary>
/// Get data object from <see cref="BaseItem"/>.
/// </summary>
/// <param name="dataObject">The existing data object.</param>
/// <param name="item">Instance of the <see cref="BaseItem"/>.</param>
/// <returns>The data object.</returns>
public static Dictionary <string, object> AddBaseItemData(this Dictionary <string, object> dataObject, BaseItem?item)
{
if (item is null)
{
return(dataObject);
}
dataObject["Timestamp"] = DateTime.Now;
dataObject["UtcTimestamp"] = DateTime.UtcNow;
dataObject["Name"] = item.Name.Escape();
dataObject["Overview"] = item.Overview.Escape();
dataObject["Tagline"] = item.Tagline.Escape();
dataObject["ItemId"] = item.Id;
dataObject["ItemType"] = item.GetType().Name.Escape();
dataObject["RunTimeTicks"] = item.RunTimeTicks ?? 0;
dataObject["RunTime"] = TimeSpan.FromTicks(item.RunTimeTicks ?? 0).ToString(@"hh\:mm\:ss", CultureInfo.InvariantCulture);
if (item.ProductionYear is not null)
{
dataObject["Year"] = item.ProductionYear;
}
switch (item)
{
case Season season:
if (!string.IsNullOrEmpty(season.Series?.Name))
{
dataObject["SeriesName"] = season.Series.Name.Escape();
}
if (season.Series?.ProductionYear is not null)
{
dataObject["Year"] = season.Series.ProductionYear;
}
if (season.IndexNumber is not null)
{
dataObject["SeasonNumber"] = season.IndexNumber;
dataObject["SeasonNumber00"] = season.IndexNumber.Value.ToString("00", CultureInfo.InvariantCulture);
dataObject["SeasonNumber000"] = season.IndexNumber.Value.ToString("000", CultureInfo.InvariantCulture);
}
break;
case Episode episode:
if (!string.IsNullOrEmpty(episode.Series?.Name))
{
dataObject["SeriesName"] = episode.Series.Name.Escape();
}
if (episode.Season?.IndexNumber is not null)
{
dataObject["SeasonNumber"] = episode.Season.IndexNumber;
dataObject["SeasonNumber00"] = episode.Season.IndexNumber.Value.ToString("00", CultureInfo.InvariantCulture);
dataObject["SeasonNumber000"] = episode.Season.IndexNumber.Value.ToString("000", CultureInfo.InvariantCulture);
}
if (episode.IndexNumber is not null)
{
dataObject["EpisodeNumber"] = episode.IndexNumber;
dataObject["EpisodeNumber00"] = episode.IndexNumber.Value.ToString("00", CultureInfo.InvariantCulture);
dataObject["EpisodeNumber000"] = episode.IndexNumber.Value.ToString("000", CultureInfo.InvariantCulture);
}
if (episode.IndexNumberEnd is not null)
{
dataObject["EpisodeNumberEnd"] = episode.IndexNumberEnd;
dataObject["EpisodeNumberEnd00"] = episode.IndexNumberEnd.Value.ToString("00", CultureInfo.InvariantCulture);
dataObject["EpisodeNumberEnd000"] = episode.IndexNumberEnd.Value.ToString("000", CultureInfo.InvariantCulture);
}
if (episode.Series?.ProductionYear is not null)
{
dataObject["Year"] = episode.Series.ProductionYear;
}
break;
case Audio audio:
if (!string.IsNullOrEmpty(audio.Album))
{
dataObject["Album"] = audio.Album;
}
if (audio.Artists.Count != 0)
{
// Should all artists be sent?
dataObject["Artist"] = audio.Artists[0];
}
if (audio.ProductionYear is not null)
{
dataObject["Year"] = audio.ProductionYear;
}
break;
case MusicAlbum album:
if (album.Artists.Count != 0)
{
// Should all artists be sent?
dataObject["Artist"] = album.Artists[0];
}
if (album.ProductionYear is not null)
{
dataObject["Year"] = album.ProductionYear;
}
break;
}
foreach (var(providerKey, providerValue) in item.ProviderIds)
{
dataObject[$"Provider_{providerKey.ToLowerInvariant()}"] = providerValue;
}
var itemMediaStreams = item.GetMediaStreams();
if (itemMediaStreams is not null)
{
var streamCounter = new Dictionary <MediaStreamType, int>();
foreach (var mediaStream in itemMediaStreams)
{
streamCounter.TryGetValue(mediaStream.Type, out var count);
streamCounter[mediaStream.Type] = count + 1;
var baseKey = $"{mediaStream.Type}_{count}";
switch (mediaStream.Type)
{
case MediaStreamType.Audio:
{
dataObject[baseKey + "_Title"] = mediaStream.DisplayTitle;
dataObject[baseKey + "_Type"] = mediaStream.Type.ToString();
dataObject[baseKey + "_Language"] = mediaStream.Language;
dataObject[baseKey + "_Codec"] = mediaStream.Codec;
dataObject[baseKey + "_Channels"] = mediaStream.Channels ?? 0;
dataObject[baseKey + "_Bitrate"] = mediaStream.BitRate ?? 0;
dataObject[baseKey + "_SampleRate"] = mediaStream.SampleRate ?? 0;
dataObject[baseKey + "_Default"] = mediaStream.IsDefault;
break;
}
case MediaStreamType.Video:
{
dataObject[baseKey + "_Title"] = mediaStream.DisplayTitle;
dataObject[baseKey + "_Type"] = mediaStream.Type.ToString();
dataObject[baseKey + "_Codec"] = mediaStream.Codec;
dataObject[baseKey + "_Profile"] = mediaStream.Profile;
dataObject[baseKey + "_Level"] = mediaStream.Level ?? 0;
dataObject[baseKey + "_Height"] = mediaStream.Height ?? 0;
dataObject[baseKey + "_Width"] = mediaStream.Width ?? 0;
dataObject[baseKey + "_AspectRatio"] = mediaStream.AspectRatio;
dataObject[baseKey + "_Interlaced"] = mediaStream.IsInterlaced;
dataObject[baseKey + "_FrameRate"] = mediaStream.RealFrameRate ?? 0;
dataObject[baseKey + "_VideoRange"] = mediaStream.VideoRange;
dataObject[baseKey + "_ColorSpace"] = mediaStream.ColorSpace;
dataObject[baseKey + "_ColorTransfer"] = mediaStream.ColorTransfer;
dataObject[baseKey + "_ColorPrimaries"] = mediaStream.ColorPrimaries;
dataObject[baseKey + "_PixelFormat"] = mediaStream.PixelFormat;
dataObject[baseKey + "_RefFrames"] = mediaStream.RefFrames ?? 0;
break;
}
case MediaStreamType.Subtitle:
dataObject[baseKey + "_Title"] = mediaStream.DisplayTitle;
dataObject[baseKey + "_Type"] = mediaStream.Type.ToString();
dataObject[baseKey + "_Language"] = mediaStream.Language;
dataObject[baseKey + "_Codec"] = mediaStream.Codec;
dataObject[baseKey + "_Default"] = mediaStream.IsDefault;
dataObject[baseKey + "_Forced"] = mediaStream.IsForced;
dataObject[baseKey + "_External"] = mediaStream.IsExternal;
break;
}
}
}
return(dataObject);
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
return(GetValue(x).CompareTo(GetValue(y)));
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>System.String.</returns>
private static int GetValue(BaseItem?x)
{
return(x?.IsFolder ?? true ? 0 : 1);
}
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem?x, BaseItem?y)
{
return(string.Compare(GetValue(x), GetValue(y), StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>System.String.</returns>
private static string?GetValue(BaseItem?x)
{
return(x is Audio audio ? audio.Album : string.Empty);
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="x">The x.</param>
/// <returns>System.String.</returns>
private static string?GetValue(BaseItem?x)
{
var audio = x as Audio;
return(audio == null ? string.Empty : audio.Album);
}