public static Task <WebBoolResult> ProcessAsync(IOwinContext context, string playlistId, string positions)
{
// get the playlist
PlaylistRawData playlistRawData = ServiceRegistration.Get <IMediaLibrary>().ExportPlaylist(Guid.Parse(playlistId));
string[] splitIds = positions.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string p in splitIds)
{
int position = int.Parse(p);
if (position < 0 || position >= playlistRawData.MediaItemIds.Count)
{
throw new BadRequestException(string.Format("Index out of bound for removing playlist item: {0}", position));
}
playlistRawData.MediaItemIds.RemoveAt(position);
}
// save playlist
ServiceRegistration.Get <IMediaLibrary>().SavePlaylist(playlistRawData);
return(System.Threading.Tasks.Task.FromResult(new WebBoolResult {
Result = true
}));
}
internal static async Task <(string Name, IEnumerable <MediaItem> Items)> LoadPlayListAsync(Guid playlistId)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
Guid[] necessaryMIATypes = new Guid[]
{
ProviderResourceAspect.ASPECT_ID,
MediaAspect.ASPECT_ID,
};
Guid[] optionalMIATypes = new Guid[]
{
AudioAspect.ASPECT_ID,
VideoAspect.ASPECT_ID,
ImageAspect.ASPECT_ID,
MovieAspect.ASPECT_ID,
EpisodeAspect.ASPECT_ID,
GenreAspect.ASPECT_ID,
VideoStreamAspect.ASPECT_ID,
};
PlaylistRawData playlistData = await cd.ExportPlaylistAsync(playlistId);
List <MediaItem> items = new List <MediaItem>();
foreach (var cluster in CollectionUtils.Cluster(playlistData.MediaItemIds, 1000))
{
items.AddRange(await cd.LoadCustomPlaylistAsync(cluster, necessaryMIATypes, optionalMIATypes));
}
return(playlistData.Name, items);
}
public static Task <WebBoolResult> ProcessAsync(IOwinContext context, string playlistId, WebMediaType type, int?position, List <string> ids)
{
if (ids.Count == 0)
{
throw new BadRequestException(String.Format("AddPlaylistItems: id array is empty - itemIds: {0}", ids));
}
// get the playlist
PlaylistRawData playlistRawData = ServiceRegistration.Get <IMediaLibrary>().ExportPlaylist(Guid.Parse(playlistId));
// clear the data
playlistRawData.MediaItemIds.Clear();
// insert the data
foreach (var itemId in ids)
{
playlistRawData.MediaItemIds.Add(Guid.Parse(itemId));
}
// save playlist
ServiceRegistration.Get <IMediaLibrary>().SavePlaylist(playlistRawData);
return(Task.FromResult(new WebBoolResult {
Result = true
}));
}
protected void RunImportOperationAsync(IContentDirectory cd, IList <string> mediaFiles)
{
ILogger logger = ServiceRegistration.Get <ILogger>();
_importPlaylistOperation = new ImportPlaylistOperation();
IList <Guid> items = _importPlaylistOperation.Execute(mediaFiles, GetShareLocation());
if (items == null)
{
logger.Info("PlaylistImportModel: Playlist import cancelled");
return;
}
IDialogManager dialogManager = ServiceRegistration.Get <IDialogManager>();
if (items.Count == 0)
{
dialogManager.ShowDialog(Consts.RES_PLAYLIST_SAVE_FAILED_TITLE,
Consts.RES_NO_ITEMS_WERE_IMPORTED_SKIPPING_SAVE_TEXT, DialogType.OkDialog, false, DialogButtonType.Ok);
return;
}
string playlistName = PlaylistName;
PlaylistRawData playlistRawData = new PlaylistRawData(Guid.NewGuid(), playlistName, ManagePlaylistsModel.ConvertAVTypeToPlaylistType(AVType.Audio), items);
try
{
cd.SavePlaylist(playlistRawData);
dialogManager.ShowDialog(Consts.RES_PLAYLIST_SAVED_SUCCESSFULLY_TITLE,
LocalizationHelper.Translate(Consts.RES_PLAYLIST_SAVED_SUCCESSFULLY_TEXT, playlistName), DialogType.OkDialog, false, DialogButtonType.Ok);
}
catch (Exception e)
{
dialogManager.ShowDialog(Consts.RES_PLAYLIST_SAVE_FAILED_TITLE, e.Message, DialogType.OkDialog, false, DialogButtonType.Ok);
}
_importPlaylistOperation = null;
}
internal static Task SavePlayListAsync(Guid playlistId, string name, string type, IEnumerable <Guid> items)
{
PlaylistRawData data = new PlaylistRawData(playlistId, name, type, items);
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
return(cd.SavePlaylistAsync(data));
}
public async Task <bool> LoadPlaylist()
{
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
if (cd == null)
{
ShowServerNotConnectedDialog();
return(false);
}
// Big playlists cannot be loaded in one single step. We have several problems if we try to do so:
// 1) Loading the playlist at once at the server results in one huge SQL IN statement which might break the SQL engine
// 2) The time to load the playlist might lead the UPnP call to break because of the timeout when calling methods
// 3) The resulting UPnP XML document might be too big to fit into memory
// For that reason, we load the playlist in two steps:
// 1) Load media item ids in the playlist
// 2) Load media items in clusters - for each cluster, an own query will be executed at the content directory
PlaylistRawData playlistData = await cd.ExportPlaylistAsync(_playlistId);
List <MediaItem> result = new List <MediaItem>();
foreach (IList <Guid> itemIds in CollectionUtils.Cluster(playlistData.MediaItemIds, 500))
{
result.AddRange(await cd.LoadCustomPlaylistAsync(itemIds, Consts.NECESSARY_AUDIO_MIAS, Consts.EMPTY_GUID_ENUMERATION));
}
_mediaItems = result;
return(true);
}
public static Task <IList <WebPlaylistItem> > ProcessAsync(IOwinContext context, string playlistId, string filter, WebSortField?sort, WebSortOrder?order)
{
// get the playlist
PlaylistRawData playlistRawData = ServiceRegistration.Get <IMediaLibrary>().ExportPlaylist(Guid.Parse(playlistId));
IFilter searchFilter = new MediaItemIdFilter(playlistRawData.MediaItemIds);
IList <MediaItem> items = MediaLibraryAccess.Search(context, BasicNecessaryMIATypeIds, BasicOptionalMIATypeIds, searchFilter);
if (items.Count == 0)
{
return(System.Threading.Tasks.Task.FromResult <IList <WebPlaylistItem> >(new List <WebPlaylistItem>()));
}
var tracks = items.Select(item => MusicTrackBasic(item))
.Filter(filter);
// sort and filter
if (sort != null && order != null)
{
tracks = tracks.SortWebMusicTrackBasic(sort, order);
}
var output = tracks.Select(t => new WebPlaylistItem(t));
return(System.Threading.Tasks.Task.FromResult <IList <WebPlaylistItem> >(output.ToList()));
}
public async Task SavePlaylistAsync(PlaylistRawData playlistData)
{
CpAction action = GetAction("X_MediaPortal_SavePlaylist");
IList <object> inParameters = new List <object> {
playlistData
};
await action.InvokeAsync(inParameters);
}
protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue)
{
reader.ReadStartElement();
PlaylistRawData result = PlaylistRawData.Deserialize(reader);
reader.ReadEndElement(); // End of enclosing element
return(result);
}
public void ExportPlaylistRawData(PlaylistRawData data)
{
IList <Guid> idList = data.MediaItemIds;
idList.Clear();
lock (_syncObj)
CollectionUtils.AddAll(idList, _itemList.Select(item => item.MediaItemId));
}
public void SavePlaylist(PlaylistRawData playlistData)
{
CpAction action = GetAction("SavePlaylist");
IList <object> inParameters = new List <object> {
playlistData
};
action.InvokeAction(inParameters);
}
public static Task <WebStringResult> ProcessAsync(IOwinContext context, string playlistName)
{
Guid playListGuid = Guid.NewGuid();
PlaylistRawData playlistRawData = new PlaylistRawData(playListGuid, playlistName, String.Empty);
ServiceRegistration.Get <IMediaLibrary>().SavePlaylist(playlistRawData);
return(Task.FromResult(new WebStringResult {
Result = playListGuid.ToString()
}));
}
public bool LoadPlaylist()
{
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
if (cd == null)
{
ShowServerNotConnectedDialog();
return(false);
}
PlaylistRawData playlistData = cd.ExportPlaylist(_playlistId);
_mediaItems = cd.LoadCustomPlaylist(playlistData.MediaItemIds, Consts.NECESSARY_AUDIO_MIAS, Consts.EMPTY_GUID_ENUMERATION);
return(true);
}
public static void SaveCurrentPlaylist()
{
IPlayerContextManager pcm = ServiceRegistration.Get <IPlayerContextManager>();
IPlayerContext pc = pcm.GetPlayerContext(PlayerChoice.CurrentPlayer);
IPlaylist playlist = pc == null ? null : pc.Playlist;
if (playlist == null)
{
ServiceRegistration.Get <ILogger>().Warn("ManagePlaylistsModel: No playlist available to save");
return;
}
PlaylistRawData playlistData = new PlaylistRawData(Guid.NewGuid(), string.Empty, ConvertAVTypeToPlaylistType(pc.AVType));
playlist.ExportPlaylistRawData(playlistData);
SavePlaylist(playlistData);
}
public static void SavePlaylist(PlaylistRawData playlistData)
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
if (ContainsLocalMediaItems(playlistData))
{
SaveFailed(Consts.RES_SAVE_PLAYLIST_FAILED_LOCAL_MEDIAITEMS_TEXT);
}
else
{
workflowManager.NavigatePush(Consts.WF_STATE_ID_PLAYLIST_SAVE_EDIT_NAME, new NavigationContextConfig
{
AdditionalContextVariables = new Dictionary <string, object>
{
{ Consts.KEY_PLAYLIST_DATA, playlistData }
}
});
}
}
public void LoadPlaylist()
{
IDialogManager dialogManager = ServiceRegistration.Get <IDialogManager>();
if (_playlist == null)
{
dialogManager.ShowDialog(SkinBase.General.Consts.RES_SYSTEM_ERROR, Consts.RES_PLAYLIST_LOAD_NO_PLAYLIST, DialogType.OkDialog, false, null);
return;
}
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
AVType? avType = ConvertPlaylistTypeToAVType(_playlist.PlaylistType);
if (cd == null || !avType.HasValue)
{
dialogManager.ShowDialog(SkinBase.General.Consts.RES_SYSTEM_ERROR, Consts.RES_PLAYLIST_LOAD_ERROR_LOADING, DialogType.OkDialog, false, null);
return;
}
Guid[] necessaryMIATypes = new Guid[]
{
ProviderResourceAspect.ASPECT_ID,
MediaAspect.ASPECT_ID,
};
Guid[] optionalMIATypes = new Guid[]
{
AudioAspect.ASPECT_ID,
VideoAspect.ASPECT_ID,
ImageAspect.ASPECT_ID,
};
// Big playlists cannot be loaded in one single step. We have several problems if we try to do so:
// 1) Loading the playlist at once at the server results in one huge SQL IN statement which might break the SQL engine
// 2) The time to load the playlist might lead the UPnP call to break because of the timeout when calling methods
// 3) The resulting UPnP XML document might be too big to fit into memory
// For that reason, we load the playlist in two steps:
// 1) Load media item ids in the playlist
// 2) Load media items in clusters - for each cluster, an own query will be executed at the content directory
PlaylistRawData playlistData = cd.ExportPlaylist(_playlist.PlaylistId);
PlayItemsModel.CheckQueryPlayAction(() => CollectionUtils.Cluster(playlistData.MediaItemIds, 1000).SelectMany(itemIds =>
cd.LoadCustomPlaylist(itemIds, necessaryMIATypes, optionalMIATypes)), avType.Value);
}
public static Task <WebBoolResult> ProcessAsync(IOwinContext context, string playlistId, int oldPosition, int newPosition)
{
// get the playlist
PlaylistRawData playlistRawData = ServiceRegistration.Get <IMediaLibrary>().ExportPlaylist(Guid.Parse(playlistId));
if (oldPosition < 0 || oldPosition >= playlistRawData.MediaItemIds.Count || newPosition < 0 && newPosition >= playlistRawData.MediaItemIds.Count)
{
throw new BadRequestException(string.Format("Indexes out of bound for moving playlist item"));
}
var item = playlistRawData.MediaItemIds[oldPosition];
playlistRawData.MediaItemIds.RemoveAt(oldPosition);
playlistRawData.MediaItemIds.Insert(newPosition, item);
// save playlist
ServiceRegistration.Get <IMediaLibrary>().SavePlaylist(playlistRawData);
return(System.Threading.Tasks.Task.FromResult(new WebBoolResult {
Result = true
}));
}
public static Task <WebBoolResult> ProcessAsync(IOwinContext context, string playlistId, WebMediaType type, string id, int?position)
{
// get the playlist
PlaylistRawData playlistRawData = ServiceRegistration.Get <IMediaLibrary>().ExportPlaylist(Guid.Parse(playlistId));
// insert the data
if (position > -1 && position < playlistRawData.MediaItemIds.Count)
{
playlistRawData.MediaItemIds.Insert(position.Value, Guid.Parse(id)); // List{0,1,2} -Insert@index:1Value:5-> List{0,5,1,2}
}
else
{
playlistRawData.MediaItemIds.Add(Guid.Parse(id));
}
// save playlist
ServiceRegistration.Get <IMediaLibrary>().SavePlaylist(playlistRawData);
return(Task.FromResult(new WebBoolResult {
Result = true
}));
}
public void SavePlaylistAndFinish()
{
PlaylistRawData playlistData = (PlaylistRawData)_playlist;
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
try
{
if (ServerPlaylists.GetPlaylists().Any(p => p.Name == playlistData.Name))
{
SaveFailed(LocalizationHelper.Translate(Consts.RES_SAVE_PLAYLIST_FAILED_PLAYLIST_ALREADY_EXISTS, playlistData.Name));
}
else
{
ServerPlaylists.SavePlaylist(playlistData);
_message = LocalizationHelper.Translate(Consts.RES_SAVE_PLAYLIST_SUCCESSFUL_TEXT, playlistData.Name);
workflowManager.NavigatePush(Consts.WF_STATE_ID_PLAYLIST_SAVE_SUCCESSFUL);
}
}
catch (Exception e)
{
SaveFailed(LocalizationHelper.Translate(Consts.RES_SAVE_PLAYLIST_FAILED_TEXT, e.Message));
}
}
protected override void DoSerializeValue(object value, bool forceSimpleValue, XmlWriter writer)
{
PlaylistRawData playlistData = (PlaylistRawData)value;
playlistData.Serialize(writer);
}
public void SavePlaylist(PlaylistRawData playlistData)
{
throw new NotImplementedException();
}
public static void SavePlaylist(PlaylistRawData playlistData)
{
IContentDirectory contentDirectory = GetContentDirectoryService();
contentDirectory.SavePlaylist(playlistData);
}
protected static bool ContainsLocalMediaItems(PlaylistRawData playlistData)
{
return(playlistData.MediaItemIds.Any(mediaItemId => mediaItemId == Guid.Empty));
}
