Exemplo n.º 1
0
        /// <summary>
        /// Executes the specified param.
        /// </summary>
        /// <param name="param">The param.</param>
        /// <param name="result">The result.</param>
        /// <returns></returns>
        public OpResult Execute(string param, NowPlayingList nowPlaying, MediaItem currentMedia)
        {
            OpResult opResult = new OpResult();
            opResult.StatusCode = OpStatusCode.Json;

            if (currentMedia != null)
            {
                opResult.ContentText = JsonConvert.SerializeObject(currentMedia, Formatting.Indented);
                return opResult;
            }
            else if (param.IndexOf("-help") >= 0)
            {
                opResult.StatusCode = OpStatusCode.Ok;
                opResult = showHelp(opResult);
                return opResult;
            }

            debug_last_action = "Execute: Start";
            bool should_enqueue = true;
            int size_x = 0;
            int size_y = 0;
            string create_playlist_name = null;
            string playlist_query = null;
            string template = "";
            string cache_fn = make_cache_fn(String.Format("{0}-{1}.txt", which_command, param));
            string cache_body = "";
            try
            {
                IWMPMediaCollection2 collection = (IWMPMediaCollection2)Player.mediaCollection;
                IWMPPlaylistCollection playlistCollection = (IWMPPlaylistCollection)Player.playlistCollection;

                int ver = Player.mediaCollection.getByAttribute("MediaType", "Audio").count;
                string cache_ver = String.Format("{0}", ver);
                cache_body = get_cached(cache_fn, cache_ver);
                if (cache_body.Length != 0 && create_playlist_name == null && playlist_query == null && !m_stats_only)
                {
                    opResult.ContentText = setCachedFlag(cache_body);
                    return opResult;
                }

                IWMPQuery query = collection.createQuery();
                IWMPPlaylistArray playlists = null;
                IWMPPlaylist mediaPlaylist = null;
                IWMPMedia media_item;

                ArrayList query_indexes = new ArrayList();

                Library metadata = new Library(m_stats_only);

                bool has_query = false;
                bool has_exact_query = false;

                string query_text = "";
                string query_type = "";

                debug_last_action = "Execution: Parsing params";

                request_params = HttpUtility.UrlEncode(param);

                if (param.Contains("create-playlist:"))
                {
                    create_playlist_name = param.Substring(param.IndexOf("create-playlist:") + "create-playlist:".Length);
                    create_playlist_name = trim_parameter(create_playlist_name);
                }

                if (param.Contains("exact-genre:"))
                {
                    string genre = param.Substring(param.IndexOf("exact-genre:") + "exact-genre:".Length);
                    genre = trim_parameter(genre);
                    query.addCondition("WM/Genre", "Equals", genre);
                    genre_filter = genre;
                    query_text = genre;
                    query_type = "Genre";
                    has_query = true;
                    has_exact_query = true;
                }
                else if (param.Contains("genre:*"))
                {
                    string genre = param.Substring(param.IndexOf("genre:*") + "genre:*".Length);
                    genre = trim_parameter(genre);
                    query.addCondition("WM/Genre", "BeginsWith", genre);
                    query.beginNextGroup();
                    query.addCondition("WM/Genre", "Contains", " " + genre);
                    genre_filter = genre;
                    query_text = genre;
                    query_type = "Genre";
                    has_query = true;
                }
                else if (param.Contains("genre:"))
                {
                    string genre = param.Substring(param.IndexOf("genre:") + "genre:".Length);
                    genre = trim_parameter(genre);
                    query.addCondition("WM/Genre", "BeginsWith", genre);
                    genre_filter = genre;
                    query_text = genre;
                    query_type = "Genre";
                    has_query = true;
                }

                if (param.Contains("exact-artist:"))
                {
                    string artist = param.Substring(param.IndexOf("exact-artist:") + "exact-artist:".Length);
                    artist = trim_parameter(artist);
                    query.addCondition("Author", "Equals", artist);
                    artist_filter = artist;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += artist;
                    query_type += "Artist";
                    has_query = true;
                    has_exact_query = true;
                }
                else if (param.Contains("exact-album-artist:"))
                {
                    string album_artist = param.Substring(param.IndexOf("exact-album-artist:") + "exact-album-artist:".Length);
                    album_artist = trim_parameter(album_artist);
                    query.addCondition("WM/AlbumArtist", "Equals", album_artist);
                    artist_filter = album_artist;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += album_artist;
                    query_type += "Album Artist";
                    has_query = true;
                    has_exact_query = true;
                }
                else if (param.Contains("album-artist:*"))
                {
                    string album_artist = param.Substring(param.IndexOf("album-artist:*") + "album-artist:*".Length);
                    album_artist = trim_parameter(album_artist);
                    query.addCondition("WM/AlbumArtist", "BeginsWith", album_artist);
                    query.beginNextGroup();
                    query.addCondition("WM/AlbumArtist", "Contains", " " + album_artist);
                    artist_filter = album_artist;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += album_artist;
                    query_type += "Album Artist";
                    has_query = true;
                }
                else if (param.Contains("album-artist:"))
                {
                    string album_artist = param.Substring(param.IndexOf("album-artist:") + "album-artist:".Length);
                    album_artist = trim_parameter(album_artist);
                    query.addCondition("WM/AlbumArtist", "BeginsWith", album_artist);
                    artist_filter = album_artist;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += album_artist;
                    query_type += "Album Artist";
                    has_query = true;
                }
                else if (param.Contains("artist:*"))
                {
                    string artist = param.Substring(param.IndexOf("artist:*") + "artist:*".Length);
                    artist = trim_parameter(artist);
                    query.addCondition("Author", "BeginsWith", artist);
                    query.beginNextGroup();
                    query.addCondition("Author", "Contains", " " + artist);
                    artist_filter = artist;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += artist;
                    query_type += "Artist";
                    has_query = true;
                }
                else if (param.Contains("artist:"))
                {
                    string artist = param.Substring(param.IndexOf("artist:") + "artist:".Length);
                    artist = trim_parameter(artist);
                    query.addCondition("Author", "BeginsWith", artist);
                    artist_filter = artist;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += artist;
                    query_type += "Artist";
                    has_query = true;
                }

                if (param.Contains("exact-album:"))
                {
                    string album = param.Substring(param.IndexOf("exact-album:") + "exact-album:".Length);
                    album = trim_parameter(album);
                    query.addCondition("WM/AlbumTitle", "Equals", album);
                    album_filter = album;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += album;
                    query_type += "Album";
                    has_query = true;
                    has_exact_query = true;
                }
                else if (param.Contains("album:"))
                {
                    string album = param.Substring(param.IndexOf("album:") + "album:".Length);
                    album = trim_parameter(album);
                    query.addCondition("WM/AlbumTitle", "BeginsWith", album);
                    album_filter = album;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += album;
                    query_type += "Album";
                    has_query = true;
                }

                //This is not for a query but rather for playing/enqueing exact songs
                if (param.Contains("exact-song:"))
                {
                    string song = param.Substring(param.IndexOf("exact-song:") + "exact-song:".Length);
                    song = trim_parameter(song);
                    song_filter = song;
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_text += song;
                    query_type += "Song";
                    has_exact_query = true;
                }

                if (param.Contains("exact-playlist:"))
                {
                    playlist_query = param.Substring(param.IndexOf("exact-playlist:") + "exact-playlist:".Length);
                    playlist_query = trim_parameter(playlist_query);
                }

                // Indexes specified?
                if (param.Contains("indexes:"))
                {
                    string indexes = param.Substring(param.IndexOf("indexes:") + "indexes:".Length);
                    if (indexes.IndexOf(" ") >= 0) indexes = indexes.Substring(0, indexes.IndexOf(" "));
                    string[] s_idx = indexes.Split(',');
                    foreach (string s in s_idx)
                    {
                        if (s.Length > 0) query_indexes.Add(Int16.Parse(s));
                    }
                    if (query_text.Length > 0)
                    {
                        query_text += ": ";
                        query_type += "/";
                    }
                    query_type += "Tracks";
                    has_query = true;
                }

                if (!has_query) query_type = query_text = "All";

                // Cover size specified?
                if (param.Contains("size-x:"))
                {
                    string tmp_size = param.Substring(param.IndexOf("size-x:") + "size-x:".Length);
                    if (tmp_size.IndexOf(" ") >= 0) tmp_size = tmp_size.Substring(0, tmp_size.IndexOf(" "));
                    size_x = Convert.ToInt32(tmp_size);
                }
                if (param.Contains("size-y:"))
                {
                    string tmp_size = param.Substring(param.IndexOf("size-y:") + "size-y:".Length);
                    if (tmp_size.IndexOf(" ") >= 0) tmp_size = tmp_size.Substring(0, tmp_size.IndexOf(" "));
                    size_y = Convert.ToInt32(tmp_size);
                }
                // Use Custom Template?
                if (param.Contains("template:"))
                {
                    template = param.Substring(param.IndexOf("template:") + "template:".Length);
                    if (template.IndexOf(" ") >= 0) template = template.Substring(0, template.IndexOf(" "));
                }

                if (which_command == PLAY) should_enqueue = false;

                switch (which_command)
                {
                    case CLEAR_CACHE:
                        opResult.StatusCode = OpStatusCode.Ok;
                        clear_cache();
                        return opResult;
                    case LIST_GENRES:
                        if (create_playlist_name != null)
                        {
                            IWMPPlaylist genre_playlist = collection.getPlaylistByQuery(query, "Audio", "WM/Genre", true);
                            add_to_playlist(opResult, has_query, genre_playlist, create_playlist_name);
                            opResult.StatusCode = OpStatusCode.Ok;
                        }
                        else
                        {
                            IWMPStringCollection genres;
                            if (has_query)
                            {
                                genres = collection.getStringCollectionByQuery("WM/Genre", query, "Audio", "WM/Genre", true);
                            }
                            else
                            {
                                genres = collection.getAttributeStringCollection("WM/Genre", "Audio");
                            }
                            if (genres != null && genres.count > 0)
                            {
                                result_count = 0;
                                for (int k = 0; k < genres.count; k++)
                                {
                                    string item = genres.Item(k);
                                    if (item != null && !item.Equals(""))
                                    {
                                        if (!m_stats_only) metadata.addGenre(item);
                                        else result_count++;
                                    }
                                }
                                opResult.ResultCount = result_count;
                                metadata.trimToSize();
                                opResult = serializeObject(opResult, metadata, cache_fn, cache_ver);
                            }
                            else
                            {
                                opResult.StatusCode = OpStatusCode.BadRequest;
                                opResult.StatusText = "No genres found!";
                            }
                        }
                        return opResult;
                    case LIST_ARTISTS:
                        if (create_playlist_name != null)
                        {
                            IWMPPlaylist artists_playlist = collection.getPlaylistByQuery(query, "Audio", "Author", true);
                            add_to_playlist(opResult, has_query, artists_playlist, create_playlist_name);
                            opResult.StatusCode = OpStatusCode.Ok;
                        }
                        else
                        {
                            IWMPStringCollection artists;
                            if (has_query)
                            {
                                artists = collection.getStringCollectionByQuery("Author", query, "Audio", "Author", true);
                            }
                            else
                            {
                                artists = collection.getAttributeStringCollection("Author", "Audio");
                            }
                            if (artists != null && artists.count > 0)
                            {
                                result_count = 0;
                                for (int k = 0; k < artists.count; k++)
                                {
                                    string item = artists.Item(k);
                                    if (item != null && !item.Equals(""))
                                    {
                                        if (!m_stats_only) metadata.addArtist(item);
                                        else result_count++;
                                    }
                                }
                                opResult.ResultCount = result_count;
                                metadata.trimToSize();
                                opResult = serializeObject(opResult, metadata, cache_fn, cache_ver);
                            }
                            else
                            {
                                opResult.StatusCode = OpStatusCode.BadRequest;
                                opResult.StatusText = "No artists found!";
                            }
                        }
                        return opResult;
                    case LIST_ALBUM_ARTISTS:
                        if (create_playlist_name != null)
                        {
                            IWMPPlaylist album_artists_playlist = collection.getPlaylistByQuery(query, "Audio", "WM/AlbumArtist", true);
                            add_to_playlist(opResult, has_query, album_artists_playlist, create_playlist_name);
                            opResult.StatusCode = OpStatusCode.Ok;
                        }
                        else
                        {
                            IWMPStringCollection album_artists;
                            if (has_query)
                            {
                                album_artists = collection.getStringCollectionByQuery("WM/AlbumArtist", query, "Audio", "WM/AlbumArtist", true);
                            }
                            else
                            {
                                album_artists = collection.getAttributeStringCollection("WM/AlbumArtist", "Audio");
                            }
                            if (album_artists != null && album_artists.count > 0)
                            {
                                result_count = 0;
                                for (int k = 0; k < album_artists.count; k++)
                                {
                                    string item = album_artists.Item(k);
                                    if (item != null && !item.Equals("") && !metadata.containsAlbumArtist(item))
                                    {
                                        if (!m_stats_only) metadata.addAlbumArtist(item);
                                        else result_count++;
                                    }
                                }
                                opResult.ResultCount = result_count;
                                metadata.trimToSize();
                                opResult = serializeObject(opResult, metadata, cache_fn, cache_ver);
                            }
                            else
                            {
                                opResult.StatusCode = OpStatusCode.BadRequest;
                                opResult.StatusText = "No album artists found!";
                            }
                        }
                        return opResult;
                    case LIST_ALBUMS:
                        if (create_playlist_name != null)
                        {
                            IWMPPlaylist albums_playlist = collection.getPlaylistByQuery(query, "Audio", "WM/AlbumTitle", true);
                            add_to_playlist(opResult, has_query, albums_playlist, create_playlist_name);
                            opResult.StatusCode = OpStatusCode.Ok;
                        }
                        else
                        {
                            IWMPStringCollection albums;
                            if (has_query)
                            {
                                albums = collection.getStringCollectionByQuery("WM/AlbumTitle", query, "Audio", "WM/AlbumTitle", true);
                            }
                            else
                            {
                                albums = collection.getAttributeStringCollection("WM/AlbumTitle", "Audio");
                            }
                            if (albums != null && albums.count > 0)
                            {
                                result_count = 0;
                                for (int k = 0; k < albums.count; k++)
                                {
                                    string item = albums.Item(k);
                                    if (item != null && !item.Equals(""))
                                    {
                                        if (!m_stats_only) metadata.addAlbum(new Album(item, collection.getByAlbum(item), m_stats_only));
                                        else result_count++;
                                    }
                                }
                                opResult.ResultCount = result_count;
                                metadata.trimToSize();
                                opResult = serializeObject(opResult, metadata, cache_fn, cache_ver);
                            }
                            else
                            {
                                opResult.StatusCode = OpStatusCode.BadRequest;
                                opResult.StatusText = "No albums found!";
                            }
                        }
                        return opResult;
                    case LIST_SONGS:
                        IWMPStringCollection songs;
                        if (has_query)
                        {
                            songs = collection.getStringCollectionByQuery("Title", query, "Audio", "Title", true);
                        }
                        else
                        {
                            songs = collection.getAttributeStringCollection("Title", "Audio");
                        }
                        if (songs != null && songs.count > 0)
                        {
                            for (int k = 0; k < songs.count; k++)
                            {
                                IWMPPlaylist playlist = collection.getByName(songs.Item(k));
                                if (playlist != null && playlist.count > 0)
                                {
                                    if (create_playlist_name != null)
                                    {
                                        add_to_playlist(opResult, has_query, playlist, create_playlist_name);
                                        opResult.StatusCode = OpStatusCode.Ok;
                                    }
                                    else
                                    {
                                        metadata.addSongs(playlist);
                                    }
                                }
                            }
                            if (create_playlist_name == null)
                            {
                                metadata.trimToSize();
                                opResult = serializeObject(opResult, metadata, cache_fn, cache_ver);
                            }
                        }
                        else
                        {
                            opResult.StatusCode = OpStatusCode.BadRequest;
                            opResult.StatusText = "No songs found!";
                        }
                        return opResult;
                    case LIST_PLAYLISTS:
                        result_count = 0;
                        playlists = getAllUserPlaylists(playlistCollection);
                        result_count = metadata.addPlaylists(playlistCollection, playlists);
                        metadata.trimToSize();
                        opResult.ResultCount = result_count;
                        opResult.ContentText = JsonConvert.SerializeObject(metadata, Formatting.Indented);
                        return opResult;
                    case LIST_RECENT:
                        if (param.Contains("count:"))
                        {
                            string scount = param.Substring(param.IndexOf("count:") + "count:".Length);
                            if (scount.IndexOf(" ") >= 0) scount = scount.Substring(0, scount.IndexOf(" "));
                            int count = Convert.ToInt32(scount);
                            list_recent(opResult, template, count);
                        }
                        else list_recent(opResult, template);
                        opResult.StatusCode = OpStatusCode.Ok;
                        return opResult;
                    case LIST_NOWPLAYING:
                        if (nowPlaying != null)
                        {
                            opResult.ContentText = JsonConvert.SerializeObject(nowPlaying, Formatting.Indented);
                        }
                        else
                        {
                            opResult.StatusCode = OpStatusCode.BadRequest;
                            opResult.StatusText = "Now playing is null!";
                        }
                        return opResult;
                    case DELETE_PLAYLIST:
                        if (playlist_query != null)
                        {
                            playlists = getUserPlaylistsByName(playlist_query, playlistCollection);
                            if (playlists.count > 0)
                            {
                                IWMPPlaylist mod_playlist = playlists.Item(0);
                                if (query_indexes.Count > 0)
                                {
                                    // Delete items indicated by indexes instead of deleting playlist
                                    for (int j = 0; j < query_indexes.Count; j++)
                                    {
                                        mod_playlist.removeItem(mod_playlist.get_Item((Int16)query_indexes[j]));
                                    }
                                    opResult.ContentText = "Items removed from playlist " + mod_playlist + ".";
                                }
                                else
                                {
                                    ((IWMPPlaylistCollection)Player.playlistCollection).remove(mod_playlist);
                                    opResult.ContentText = "Playlist " + mod_playlist + " deleted.";
                                }
                                opResult.StatusCode = OpStatusCode.Success;
                            }
                            else
                            {
                                opResult.StatusCode = OpStatusCode.BadRequest;
                                opResult.StatusText = "Playlist does not exist!";
                            }
                        }
                        else
                        {
                            opResult.StatusCode = OpStatusCode.BadRequest;
                            opResult.StatusText = "Must specify the exact playlist!";
                        }
                        return opResult;
                    case LIST_DETAILS:
                        // Get  query as a playlist
                        if (playlist_query != null)
                        {
                            //Return a specific playlist when music-list-details with exact-playlist is queried
                            playlists = getUserPlaylistsByName(playlist_query, playlistCollection);
                            if (playlists.count > 0)
                            {
                                Playlist aPlaylist = new Playlist(playlist_query);
                                mediaPlaylist = playlists.Item(0);
                                //Or return a playlist query
                                if (mediaPlaylist != null)
                                {
                                    aPlaylist.addItems(mediaPlaylist);
                                }
                                metadata.playlists.Add(aPlaylist);
                            }
                        }
                        else if (has_exact_query)
                        {
                            mediaPlaylist = getPlaylistFromExactQuery(query_text, query_type, collection);
                        }
                        else if (has_query)
                        {
                            string type = getSortAttributeFromQueryType(query_type);
                            mediaPlaylist = collection.getPlaylistByQuery(query, "Audio", type, true);
                        }

                        if (mediaPlaylist != null)
                        {
                            //Create playlist from query if supplied with playlist name
                            if (create_playlist_name != null)
                            {
                                add_to_playlist(opResult, has_query, mediaPlaylist, create_playlist_name);
                                return opResult;
                            }
                            else if (query_indexes.Count > 0)
                            {
                                for (int j = 0; j < query_indexes.Count; j++)
                                {
                                    media_item = mediaPlaylist.get_Item((Int16)query_indexes[j]);
                                    if (media_item != null)
                                    {
                                        metadata.addSong(media_item);
                                    }
                                }
                            }
                            else
                            {
                                if (query_type.Equals("Album"))
                                {
                                    Album album = new Album(query_text, m_stats_only);
                                    album.addTracks(mediaPlaylist);
                                    metadata.addAlbum(album);
                                }
                                else
                                {
                                    metadata.addSongs(mediaPlaylist);
                                }
                            }
                        }
                        else
                        {
                            if (logger != null)
                            {
                                logger.Write("Creating library metadata object");
                            }
                            //No query supplied so entire detailed library requested
                            //Parse all albums and return, no value album will be added as songs
                            IWMPStringCollection album_collection = collection.getAttributeStringCollection("WM/AlbumTitle", "Audio");
                            if (album_collection.count > 0)
                            {
                                result_count = 0;
                                for (int j = 0; j < album_collection.count; j++)
                                {
                                    if (album_collection.Item(j) != null)
                                    {
                                        //The collection seems to represent the abcense of an album as an "" string value
                                        IWMPPlaylist album_playlist = collection.getByAlbum(album_collection.Item(j));
                                        if (album_playlist != null)
                                        {
                                            if (!album_collection.Item(j).Equals(""))
                                            {
                                                Album album = new Album(album_collection.Item(j), m_stats_only);
                                                result_count += album.addTracks(album_playlist);
                                                metadata.addAlbum(album);
                                            }
                                            else
                                            {
                                                result_count += metadata.addSongs(album_playlist);
                                            }
                                        }
                                    }
                                }
                                metadata.trimToSize();
                            }
                        }
                        if (logger != null)
                        {
                            logger.Write("Starting serialization of metadata object.");
                        }
                        opResult.ResultCount = result_count;
                        opResult = serializeObject(opResult, metadata, cache_fn, cache_ver);
                        return opResult;
                    case PLAY:
                    case QUEUE:
                        if (has_exact_query)
                        {
                            mediaPlaylist = getPlaylistFromExactQuery(query_text, query_type, collection);
                        }
                        else if (has_query)
                        {
                            string type = getSortAttributeFromQueryType(query_type);
                            mediaPlaylist = collection.getPlaylistByQuery(query, "Audio", type, true);
                        }
                        else
                        {
                            mediaPlaylist = collection.getByAttribute("MediaType", "Audio");
                        }
                        //Play or enqueue
                        PlayMediaCmd pmc;
                        if (query_indexes.Count > 0)
                        {
                            result_count = query_indexes.Count;
                            for (int j = 0; j < query_indexes.Count; j++)
                            {
                                media_item = mediaPlaylist.get_Item(j);
                                if (media_item != null)
                                {
                                    query_text += ((j == 0) ? "" : ", ") + (Int16)query_indexes[j] + ". " + media_item.getItemInfo("Title");
                                }
                            }
                            pmc = new PlayMediaCmd(remotePlayer, mediaPlaylist, query_indexes, should_enqueue);
                        }
                        else
                        {
                            result_count = mediaPlaylist.count;
                            pmc = new PlayMediaCmd(remotePlayer, mediaPlaylist, should_enqueue);
                        }
                        opResult = pmc.Execute(null);

                        // Type, Artist, Album, Track, param, count
                        add_to_mrp(query_type, query_text, param, result_count); //Add to recent played list
                        return opResult;
                    case SERV_COVER:
                        if (has_exact_query)
                        {
                            mediaPlaylist = getPlaylistFromExactQuery(query_text, query_type, collection);
                        }
                        else if (has_query)
                        {
                            string type = getSortAttributeFromQueryType(query_type);
                            mediaPlaylist = collection.getPlaylistByQuery(query, "Audio", type, true);
                        }
                        else
                        {
                            mediaPlaylist = collection.getByAttribute("MediaType", "Audio");
                        }

                        try
                        {
                            if (query_indexes.Count > 0)
                            {
                                for (int j = 0; j < query_indexes.Count; j++)
                                {
                                    media_item = mediaPlaylist.get_Item((Int16)query_indexes[j]);
                                    if (media_item != null)
                                    {
                                        string album_path = findAlbumPath(media_item.sourceURL);
                                        photoCmd pc = new photoCmd(photoCmd.SERV_PHOTO);
                                        if (album_path.Length == 0) return pc.getPhoto(DEFAULT_IMAGE, "jpeg", size_x, size_y);
                                        else return pc.getPhoto(album_path, "jpeg", size_x, size_y);
                                    }
                                }
                            }
                            else
                            {
                                for (int j = 0; j < mediaPlaylist.count; j++)
                                {
                                    media_item = mediaPlaylist.get_Item(j);
                                    if (media_item != null)
                                    {
                                        string album_path = findAlbumPath(media_item.sourceURL);
                                        photoCmd pc = new photoCmd(photoCmd.SERV_PHOTO);
                                        if (album_path.Length == 0) return pc.getPhoto(DEFAULT_IMAGE, "jpeg", size_x, size_y);
                                        else return pc.getPhoto(album_path, "jpeg", size_x, size_y);
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            opResult.StatusCode = OpStatusCode.Exception;
                            opResult.StatusText = ex.Message;
                        }
                        return opResult;
                }
            }
            catch (Exception ex)
            {
                opResult = new OpResult();
                opResult.StatusCode = OpStatusCode.Exception;
                opResult.StatusText = ex.Message;
                opResult.AppendFormat("{0}", debug_last_action);
                opResult.AppendFormat("{0}", ex.Message);
            }

            debug_last_action = "Execute: End";

            return opResult;
        }