public static IEnumerable <T> SortChannelList <T>(this IEnumerable <T> list, WebSortField?sortInput, WebSortOrder?orderInput) where T : WebChannelBasic
{
switch (sortInput)
{
case WebSortField.Title:
return(list.OrderBy(x => x.Title, orderInput));
case WebSortField.NaturalTitle:
return(list.OrderByNatural(x => x.Title, orderInput));
case WebSortField.User:
default:
// There are two ways to order channels in MediaPortal:
// - The SortOrder property of a channel (SortOrder field in channel table)
// - The order in which the channels are in a group (SortOrder field in GroupMap table). This isn't exposed as a property
// somehwere, we just get the items in this order from TvBusinessLayer and have to deal with it.
// While using the first makes more sense from a programmers POV, the user expects the second one, so let's use that
// one here, which means that we don't sort.
if (orderInput.HasValue && orderInput.Value == WebSortOrder.Desc)
{
return(list.Reverse());
}
return(list);
}
}
public static Task <IList <WebGenre> > ProcessAsync(IOwinContext context, WebSortField?sort, WebSortOrder?order)
{
ISet <Guid> necessaryMIATypes = new HashSet <Guid>();
necessaryMIATypes.Add(MediaAspect.ASPECT_ID);
necessaryMIATypes.Add(SeriesAspect.ASPECT_ID);
HomogenousMap items = MediaLibraryAccess.GetGroups(context, necessaryMIATypes, GenreAspect.ATTR_GENRE);
if (items.Count == 0)
{
return(Task.FromResult <IList <WebGenre> >(new List <WebGenre>()));
}
var output = (from item in items where item.Key is string select new WebGenre {
Title = item.Key.ToString()
});
// sort
if (sort != null && order != null)
{
output = output.SortWebGenre(sort, order);
}
return(Task.FromResult <IList <WebGenre> >(output.ToList()));
}
public static IEnumerable <T> SortWebActor <T>(this IEnumerable <T> list, WebSortField?sortInput, WebSortOrder?orderInput) where T : WebActor
{
switch (sortInput)
{
case WebSortField.Title:
default:
return(list.OrderBy(x => x.Title, orderInput));
}
}
public static IEnumerable <T> SortGroupList <T>(this IEnumerable <T> list, WebSortField?sortInput, WebSortOrder?orderInput) where T : WebChannelGroup
{
switch (sortInput)
{
case WebSortField.Title:
return(list.OrderBy(x => x.GroupName, orderInput));
case WebSortField.User:
default:
return(list.OrderBy(x => x.SortOrder, orderInput));
}
}
public static async Task <IList <WebGenre> > ProcessAsync(IOwinContext context, int start, int end, string filter, WebSortField?sort, WebSortOrder?order)
{
var output = (await GetMusicGenres.ProcessAsync(context, sort, order))
.Filter(filter);
// get range
output = output.TakeRange(start, end);
return(output.ToList());
}
public static Task <IList <WebDriveBasic> > ProcessAsync(IOwinContext context, WebSortField?sort, WebSortOrder?order)
{
List <WebDriveBasic> output = DriveBasic();
// sort and filter
if (sort != null && order != null)
{
output = output.AsQueryable().SortMediaItemList(sort, order).ToList();
}
return(System.Threading.Tasks.Task.FromResult <IList <WebDriveBasic> >(output));
}
public static Task <IList <WebMovieBasic> > ProcessAsync(IOwinContext context, string filter, WebSortField?sort, WebSortOrder?order)
{
IList <MediaItem> items = MediaLibraryAccess.GetMediaItemsByAspect(context, BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds, null);
if (items.Count == 0)
{
return(System.Threading.Tasks.Task.FromResult <IList <WebMovieBasic> >(new List <WebMovieBasic>()));
}
var output = items.Select(item => MovieBasic(item))
.Filter(filter);
// sort and filter
if (sort != null && order != null)
{
output = output.Filter(filter).SortWebMovieBasic(sort, order);
}
return(System.Threading.Tasks.Task.FromResult <IList <WebMovieBasic> >(output.ToList()));
}
public static async Task <IList <WebTVEpisodeDetailed> > ProcessAsync(IOwinContext context, string id, int start, int end, string filter, WebSortField?sort, WebSortOrder?order)
{
var output = (await GetTVEpisodesDetailedForTVShow.ProcessAsync(context, id, sort, order))
.Filter(filter);
// get range
output = output.TakeRange(start, end);
return(output.ToList());
}
public static IOrderedQueryable <T> SortMediaItemList <T>(this IQueryable <T> list, WebSortField?sortInput, WebSortOrder?orderInput, WebSortField defaultSort, WebSortOrder defaultOrder)
{
// parse arguments
if (orderInput != null && orderInput != WebSortOrder.Asc && orderInput != WebSortOrder.Desc)
{
Log.Warn("Invalid OrderBy value {0} given", orderInput);
throw new Exception("Invalid OrderBy value specified");
}
WebSortField sort = sortInput.HasValue ? sortInput.Value : defaultSort;
WebSortOrder order = orderInput.HasValue ? orderInput.Value : defaultOrder;
// do the actual sorting
try
{
switch (sort)
{
// generic
case WebSortField.Title:
return(list.OrderBy(x => ((ITitleSortable)x).Title, order));
case WebSortField.DateAdded:
return(list.OrderBy(x => ((IDateAddedSortable)x).DateAdded, order));
case WebSortField.Year:
return(list.OrderBy(x => ((IYearSortable)x).Year, order));
case WebSortField.Genre:
return(list.OrderBy(x => ((IGenreSortable)x).Genres.First(), order));
case WebSortField.Rating:
return(list.OrderBy(x => ((IRatingSortable)x).Rating, order));
case WebSortField.Categories:
return(list.OrderBy(x => ((ICategorySortable)x).Categories.First().Title, order));
case WebSortField.Type:
return(list.OrderBy(x => ((ITypeSortable)x).Type, order));
// music
case WebSortField.MusicTrackNumber:
return(list.OrderBy(x => ((IMusicTrackNumberSortable)x).TrackNumber, order));
case WebSortField.MusicComposer:
return(list.OrderBy(x => ((IMusicComposerSortable)x).Composer.First(), order));
// tv
case WebSortField.TVEpisodeNumber:
return(list.OrderBy(x => ((ITVEpisodeNumberSortable)x).SeasonNumber, order).ThenBy(x => ((ITVEpisodeNumberSortable)x).EpisodeNumber, order));
case WebSortField.TVSeasonNumber:
return(list.OrderBy(x => ((ITVSeasonNumberSortable)x).SeasonNumber, order));
case WebSortField.TVDateAired:
return(list.OrderBy(x => ((ITVDateAiredSortable)x).FirstAired, order));
// picture
case WebSortField.PictureDateTaken:
return(list.OrderBy(x => ((IPictureDateTakenSortable)x).DateTaken, order));
default:
Log.Warn("Invalid SortBy value {0}", sortInput);
throw new Exception("Sorting on this property is not supported for this media type");
}
}
catch (Exception ex)
{
Log.Warn(String.Format("Tried to do invalid sorting; actual values SortBy={0}, OrderBy={1}", sort, order), ex);
throw new Exception("Sorting on this property is not supported for this media type");
}
}
public static async Task <IList <WebChannelGroup> > ProcessAsync(IOwinContext context, int start, int end, WebSortField?sort, WebSortOrder?order)
{
if (!ServiceRegistration.IsRegistered <ITvProvider>())
{
throw new BadRequestException("GetGroupsByRange: ITvProvider not found");
}
var groups = await TVAccess.GetGroupsAsync(context);
List <WebChannelGroup> output = new List <WebChannelGroup>();
foreach (var group in groups)
{
output.Add(ChannelGroup(group));
}
// sort
if (sort != null && order != null)
{
output = output.SortGroupList(sort, order).ToList();
}
// get range
output = output.TakeRange(start, end).ToList();
return(output);
}
public static Task <IList <WebActor> > ProcessAsync(IOwinContext context, string filter, WebSortField?sort, WebSortOrder?order)
{
ISet <Guid> necessaryMIATypes = new HashSet <Guid>();
necessaryMIATypes.Add(MediaAspect.ASPECT_ID);
necessaryMIATypes.Add(PersonAspect.ASPECT_ID);
IList <MediaItem> items = MediaLibraryAccess.GetMediaItemsByGroup(context, PersonAspect.ROLE_ACTOR, SeriesAspect.ROLE_SERIES, Guid.Empty, necessaryMIATypes, null);
if (items.Count == 0)
{
return(System.Threading.Tasks.Task.FromResult <IList <WebActor> >(new List <WebActor>()));
}
var output = items.Select(a => new WebActor(a.GetAspect(PersonAspect.Metadata).GetAttributeValue <string>(PersonAspect.ATTR_PERSON_NAME)))
.Filter(filter);
if (sort != null && order != null)
{
output.SortWebActor(sort, order);
}
return(System.Threading.Tasks.Task.FromResult <IList <WebActor> >(output.ToList()));
}
public static Task <IList <WebFilesystemItem> > ProcessAsync(IOwinContext context, string id, WebSortField?sort, WebSortOrder?order)
{
string path = Base64.Decode(id);
// File listing
List <WebFilesystemItem> files = new List <WebFilesystemItem>();
if (!string.IsNullOrEmpty(path) && Directory.Exists(path))
{
files = new DirectoryInfo(path).GetFiles().Select(file => FilesystemItem(file)).ToList();
}
// Folder listing
List <WebFilesystemItem> folders = new List <WebFilesystemItem>();
if (!string.IsNullOrEmpty(path) && Directory.Exists(path))
{
folders = new DirectoryInfo(path).GetDirectories().Select(dir => FilesystemItem(dir)).ToList();
}
List <WebFilesystemItem> output = files.Concat(folders).ToList();
// sort
if (sort != null && order != null)
{
output = output.AsQueryable().SortMediaItemList(sort, order).ToList();
}
return(System.Threading.Tasks.Task.FromResult <IList <WebFilesystemItem> >(output));
}
public static IEnumerable <T> SortWebMusicTrackBasic <T>(this IEnumerable <T> list, WebSortField?sortInput, WebSortOrder?orderInput) where T : WebMusicTrackBasic
{
switch (sortInput)
{
case WebSortField.Title:
return(list.OrderBy(x => x.Title, orderInput));
case WebSortField.DateAdded:
return(list.OrderBy(x => x.DateAdded, orderInput));
case WebSortField.Year:
return(list.OrderBy(x => x.Year, orderInput));
case WebSortField.Genre:
return(list.OrderBy(x => x.Genres, orderInput));
case WebSortField.Rating:
return(list.OrderBy(x => x.Rating, orderInput));
case WebSortField.MusicTrackNumber:
return(list.OrderBy(x => x.TrackNumber, orderInput));
case WebSortField.Type:
return(list.OrderBy(x => x.Type, orderInput));
default:
return(list.OrderBy(x => x.Title, orderInput));
}
}
public static async Task <IList <WebMusicArtistBasic> > ProcessAsync(IOwinContext context, int start, int end, string filter, WebSortField?sort, WebSortOrder?order)
{
IList <WebMusicArtistBasic> output = await GetMusicArtistsBasic.ProcessAsync(context, filter, sort, order);
output = output.TakeRange(start, end).ToList();
return(output);
}
public static Task <IList <WebFileBasic> > ProcessAsync(IOwinContext context, string id, WebSortField?sort, WebSortOrder?order)
{
List <WebFileBasic> output = new List <WebFileBasic>();
string path = Base64.Decode(id);
if (!string.IsNullOrEmpty(path) && Directory.Exists(path))
{
output = new DirectoryInfo(path).GetFiles().Select(file => FileBasic(file)).ToList();
}
// sort
if (sort != null && order != null)
{
output = output.AsQueryable().SortMediaItemList(sort, order).ToList();
}
return(System.Threading.Tasks.Task.FromResult <IList <WebFileBasic> >(output));
}
public static Task <IList <WebTVEpisodeDetailed> > ProcessAsync(IOwinContext context, string id, WebSortField?sort, WebSortOrder?order)
{
IList <MediaItem> episodes = MediaLibraryAccess.GetMediaItemsByGroup(context, EpisodeAspect.ROLE_EPISODE, SeriesAspect.ROLE_SERIES, Guid.Parse(id), DetailedNecessaryMIATypeIds, DetailedOptionalMIATypeIds);
var output = new List <WebTVEpisodeDetailed>();
if (episodes.Count == 0)
{
return(Task.FromResult <IList <WebTVEpisodeDetailed> >(output));
}
output.AddRange(episodes.Select(episode => EpisodeDetailed(episode, Guid.Parse(id))));
// sort
if (sort != null && order != null)
{
output = output.SortWebTVEpisodeDetailed(sort, order).ToList();
}
return(Task.FromResult <IList <WebTVEpisodeDetailed> >(output));
}
public static async Task <IList <WebTVShowDetailed> > ProcessAsync(IOwinContext context, int start, int end, string filter, WebSortField?sort, WebSortOrder?order)
{
var output = await GetTVShowsDetailed.ProcessAsync(context, filter, sort, order);
// get range
output = output.TakeRange(start, end).ToList();
return(output);
}
public static IEnumerable <T> SortScheduledRecordingList <T>(this IEnumerable <T> list, WebSortField?sortInput, WebSortOrder?orderInput) where T : WebScheduledRecording
{
switch (sortInput)
{
case WebSortField.Channel:
return(list.OrderBy(x => x.ChannelId, orderInput));
case WebSortField.StartTime:
return(list.OrderBy(x => x.StartTime, orderInput));
case WebSortField.NaturalTitle:
return(list.OrderByNatural(x => x.Title, orderInput));
case WebSortField.Title:
default:
return(list.OrderBy(x => x.Title, orderInput));
}
}
public static Task <IList <WebTVEpisodeBasic> > ProcessAsync(IOwinContext context, string id, WebSortField?sort, WebSortOrder?order)
{
// Get all episodes for this season
IList <MediaItem> episodes = MediaLibraryAccess.GetMediaItemsByGroup(context, EpisodeAspect.ROLE_EPISODE, SeasonAspect.ROLE_SEASON, Guid.Parse(id), BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds);
if (episodes.Count == 0)
{
return(Task.FromResult <IList <WebTVEpisodeBasic> >(new List <WebTVEpisodeBasic>()));
}
var output = episodes.Select(episode => EpisodeBasic(episode, null, Guid.Parse(id)));
// sort
if (sort != null && order != null)
{
output = output.SortWebTVEpisodeBasic(sort, order);
}
return(Task.FromResult <IList <WebTVEpisodeBasic> >(output.ToList()));
}
public static Task <IList <WebMusicArtistBasic> > ProcessAsync(IOwinContext context, string filter, WebSortField?sort, WebSortOrder?order)
{
var items = MediaLibraryAccess.GetMediaItemsByGroup(context, PersonAspect.ROLE_ARTIST, AudioAspect.ROLE_TRACK, Guid.Empty, BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds);
if (items.Count == 0)
{
return(System.Threading.Tasks.Task.FromResult <IList <WebMusicArtistBasic> >(new List <WebMusicArtistBasic>()));
}
var output = items.Select(mi => MusicArtistBasic(mi)).Filter(filter);
// sort and filter
if (sort != null && order != null)
{
output = output.SortWebMusicArtistBasic(sort, order);
}
return(System.Threading.Tasks.Task.FromResult <IList <WebMusicArtistBasic> >(output.ToList()));
}
public static Task <IList <WebMusicTrackDetailed> > ProcessAsync(IOwinContext context, string id, string filter, WebSortField?sort, WebSortOrder?order)
{
if (id == null)
{
throw new BadRequestException("GetMusicTracksDetailedForAlbum: id is null");
}
IList <MediaItem> tracks = MediaLibraryAccess.GetMediaItemsByGroup(context, AudioAspect.ROLE_TRACK, AudioAlbumAspect.ROLE_ALBUM, Guid.Parse(id), BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds);
if (tracks.Count == 0)
{
return(Task.FromResult <IList <WebMusicTrackDetailed> >(new List <WebMusicTrackDetailed>()));
}
var output = tracks.Select(t => MusicTrackDetailed(t)).ToList();
// sort
if (sort != null && order != null)
{
output = output.SortWebMusicTrackBasic(sort, order).ToList();
}
// assign artists
AssignArtists(context, output);
return(Task.FromResult <IList <WebMusicTrackDetailed> >(output));
}
public static async Task <IList <WebPlaylistItem> > ProcessAsync(IOwinContext context, string playlistId, int start, int end, string filter, WebSortField?sort, WebSortOrder?order)
{
var output = await GetPlaylistItems.ProcessAsync(context, playlistId, filter, sort, order);
// get range
output = output.TakeRange(start, end).ToList();
return(output);
}
public static IOrderedQueryable <T> SortMediaItemList <T>(this IQueryable <T> list, WebSortField?sortInput, WebSortOrder?orderInput, WebSortField defaultSort)
{
return(SortMediaItemList <T>(list, sortInput, orderInput, defaultSort, WebSortOrder.Asc));
}
public static Task <IList <WebRecordingBasic> > ProcessAsync(IOwinContext context, WebSortField?sort, WebSortOrder?order, string filter = null)
{
if (!ServiceRegistration.IsRegistered <ITvProvider>())
{
throw new BadRequestException("GetRecordings: ITvProvider not found");
}
IList <MediaItem> items = MediaLibraryAccess.GetMediaItemsByAspect(context, BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds);
List <WebRecordingBasic> output = items.Select(item => RecordingBasic(item)).ToList();
// sort and filter
if (sort != null && order != null)
{
output = output.Filter(filter).SortRecordingList(sort, order).ToList();
}
else
{
output = output.Filter(filter).ToList();
}
return(System.Threading.Tasks.Task.FromResult <IList <WebRecordingBasic> >(output));
}
public static async Task <IList <WebChannelBasic> > ProcessAsync(IOwinContext context, string groupId, WebSortField?sort, WebSortOrder?order)
{
List <WebChannelBasic> output = new List <WebChannelBasic>();
if (!ServiceRegistration.IsRegistered <ITvProvider>())
{
throw new BadRequestException("GetRadioChannelsBasic: ITvProvider not found");
}
var channels = await TVAccess.GetGroupChannelsAsync(context, groupId != null?int.Parse(groupId) : (int?)null);
output.AddRange(channels.Where(x => x.MediaType == MediaType.Radio).Select(channel => ChannelBasic(channel)));
// sort
if (sort != null && order != null)
{
output = output.SortChannelList(sort, order).ToList();
}
return(output);
}
public static async Task <IList <WebTVEpisodeBasic> > ProcessAsync(IOwinContext context, string id, int start, int end, WebSortField?sort, WebSortOrder?order)
{
var output = await GetTVEpisodesBasicForTVShow.ProcessAsync(context, id, sort, order);
// get range
output = output.TakeRange(start, end).ToList();
return(output);
}
public static async Task <IList <WebScheduleBasic> > ProcessAsync(IOwinContext context, string filter, WebSortField?sort, WebSortOrder?order)
{
if (!ServiceRegistration.IsRegistered <ITvProvider>())
{
throw new BadRequestException("GetSchedules: ITvProvider not found");
}
IScheduleControlAsync scheduleControl = ServiceRegistration.Get <ITvProvider>() as IScheduleControlAsync;
var schedules = await TVAccess.GetSchedulesAsync(context);
List <WebScheduleBasic> output = schedules.Select(schedule => ScheduleBasic(schedule)).ToList();
// sort and filter
if (sort != null && order != null)
{
output = output.Filter(filter).SortScheduleList(sort, order).ToList();
}
else
{
output = output.Filter(filter).ToList();
}
return(output);
}
public static Task <IList <WebPictureDetailed> > ProcessAsync(IOwinContext context, string filter, WebSortField?sort, WebSortOrder?order)
{
IList <MediaItem> items = MediaLibraryAccess.GetMediaItemsByAspect(context, BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds);
if (items.Count == 0)
{
return(System.Threading.Tasks.Task.FromResult <IList <WebPictureDetailed> >(new List <WebPictureDetailed>()));
}
var output = items.Select(i => PictureDetailed(i)).ToList();
// sort and filter
if (sort != null && order != null)
{
output = output.AsQueryable().Filter(filter).SortMediaItemList(sort, order).ToList();
}
else
{
output = output.Filter(filter).ToList();
}
return(System.Threading.Tasks.Task.FromResult <IList <WebPictureDetailed> >(output));
}
public static async Task <IList <WebGenre> > ProcessAsync(IOwinContext context, int start, int end, WebSortField?sort, WebSortOrder?order)
{
IEnumerable <WebGenre> output = await GetTVShowGenres.ProcessAsync(context, sort, order);
// get range
output = output.TakeRange(start, end);
return(output.ToList());
}
public static IOrderedQueryable <T> SortMediaItemList <T>(this IQueryable <T> list, WebSortField?sortInput, WebSortOrder?orderInput, WebSortField defaultSort, WebSortOrder defaultOrder)
{
// parse arguments
if (orderInput != null && orderInput != WebSortOrder.Asc && orderInput != WebSortOrder.Desc)
{
Log.Warn("Invalid OrderBy value {0} given", orderInput);
throw new Exception("Invalid OrderBy value specified");
}
WebSortField sort = sortInput.HasValue ? sortInput.Value : defaultSort;
WebSortOrder order = orderInput.HasValue ? orderInput.Value : defaultOrder;
// do the actual sorting
try
{
switch (sort)
{
// generic
case WebSortField.Title:
return(list.OrderBy(x => ((ITitleSortable)x).Title, order));
case WebSortField.NaturalTitle:
return(list.OrderByNatural(x => ((ITitleSortable)x).Title, order));
case WebSortField.DateAdded:
return(list.OrderBy(x => ((IDateAddedSortable)x).DateAdded, order));
case WebSortField.Year:
return(list.OrderBy(x => ((IYearSortable)x).Year, order));
case WebSortField.Genre:
return(list.OrderBy(x => ((IGenreSortable)x).Genres.First(), order));
case WebSortField.Rating:
return(list.OrderBy(x => ((IRatingSortable)x).Rating, order));
case WebSortField.Categories:
return(list.OrderBy(x => ((ICategorySortable)x).Categories.First().Title, order));
case WebSortField.Type:
return(list.OrderBy(x => ((ITypeSortable)x).Type, order));
// music
case WebSortField.MusicTrackNumber:
return(list.OrderBy(x => ((IMusicTrackNumberSortable)x).DiscNumber, order).ThenBy(x => ((IMusicTrackNumberSortable)x).TrackNumber, order));
case WebSortField.MusicComposer:
return(list.OrderBy(x => ((IMusicComposerSortable)x).Composer.First(), order));
// tv
case WebSortField.TVEpisodeNumber:
return(list.OrderBy(x => ((ITVEpisodeNumberSortable)x).SeasonNumber, order).ThenBy(x => ((ITVEpisodeNumberSortable)x).EpisodeNumber, order));
case WebSortField.TVSeasonNumber:
return(list.OrderBy(x => ((ITVSeasonNumberSortable)x).SeasonNumber, order));
case WebSortField.TVDateAired:
return(list.OrderBy(x => ((ITVDateAiredSortable)x).FirstAired, order));
// picture
case WebSortField.PictureDateTaken:
return(list.OrderBy(x => ((IPictureDateTakenSortable)x).DateTaken, order));
default:
Log.Warn("Invalid SortBy value {0}", sortInput);
throw new Exception("Sorting on this property is not supported for this media type");
}
}
catch (Exception ex)
{
Log.Warn(String.Format("Executing OrderBy(sortBy={0}, orderBy={1}) on list failed, sort parameters are invalid or list iterator failed " +
"(might be caused by an invalid or unexpected database or a broken query).", sort, order), ex);
throw new Exception("Failed to load data from source, please see the log file for more details.");
}
}