/// <summary>
        ///   Get the MusicBrainz Track information for the PUID
        /// </summary>
        /// <param name = "puid"></param>
        /// <returns></returns>
        private List<MusicBrainzTrack> RetrieveMusicBrainzTrack(string puid)
        {
            log.Debug("Identify: Get track information for puid: {0}", puid);
              List<MusicBrainzTrack> tracks = new List<MusicBrainzTrack>();

              string requestString = musicBrainzUrl + puid;
              string responseXml = Util.GetWebPage(requestString);
              if (responseXml == null)
            return tracks;

              XmlDocument xml = new XmlDocument();
              xml.LoadXml(responseXml);
              XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);
              nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-1.0#");

              XmlNodeList nodes = xml.SelectNodes("/m:metadata/m:track-list/m:track", nsMgr);
              if (nodes.Count > 0)
              {
            foreach (XmlNode trackListNode in nodes)
            {
              MusicBrainzTrack track = new MusicBrainzTrack();
              track.Id = new Guid(trackListNode.Attributes["id"].InnerXml);
              foreach (XmlNode childNode in trackListNode)
              {
            if (childNode.Name == "title")
              track.Title = childNode.InnerText;

            if (childNode.Name == "duration")
              track.Duration = Convert.ToInt32(childNode.InnerText);

            if (childNode.Name == "artist")
            {
              foreach (XmlNode artistNode in childNode)
              {
                if (artistNode.Name == "name")
                {
                  track.Artist = artistNode.InnerText;
                  break;
                }
              }
            }

            if (childNode.Name == "release-list")
            {
              track.AlbumID = new Guid(childNode.ChildNodes[0].Attributes["id"].InnerXml);
              foreach (XmlNode releaseNode in childNode.ChildNodes[0].ChildNodes)
              {
                if (releaseNode.Name == "title")
                  track.Album = releaseNode.InnerText;

                if (releaseNode.Name == "track-list")
                  track.Number = Convert.ToInt32(releaseNode.Attributes["offset"].InnerXml) + 1;
              }
            }
              }
              tracks.Add(track);
            }
              }
              return tracks;
        }
        public MusicBrainzAlbum GetMusicBrainzAlbumById(string albumID)
        {
            MusicBrainzAlbum album = new MusicBrainzAlbum();

              string requestString = musicBrainzUrl + string.Format(requestByID, albumID);
              string responseXml = Util.GetWebPage(requestString);
              if (responseXml == null)
            return null;

              XmlDocument xml = new XmlDocument();
              xml.LoadXml(responseXml);
              XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);
              nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-1.0#");

              XmlNodeList nodes = xml.SelectNodes("/m:metadata/m:release", nsMgr);
              if (nodes.Count > 0)
              {
            album.Id = new Guid(nodes[0].Attributes["id"].InnerXml);
            foreach (XmlNode childNode in nodes[0])
            {
              if (childNode.Name == "title")
            album.Title = childNode.InnerText;

              if (childNode.Name == "asin")
            album.Asin = childNode.InnerText;

              if (childNode.Name == "artist")
              {
            foreach (XmlNode artistNode in childNode)
            {
              if (artistNode.Name == "name")
              {
                album.Artist = artistNode.InnerText;
                break;
              }
            }
              }

              if (childNode.Name == "release-event-list")
              {
            foreach (XmlNode releaseNode in childNode)
            {
              if (releaseNode.Name == "event")
                album.Year = releaseNode.Attributes["date"].InnerXml;
            }
              }

              if (childNode.Name == "track-list")
              {
            foreach (XmlNode trackNode in childNode.ChildNodes)
            {
              MusicBrainzTrack track = new MusicBrainzTrack();
              track.Id = new Guid(trackNode.Attributes["id"].InnerXml);
              track.AlbumID = album.Id;
              track.Album = album.Title;
              track.Artist = album.Artist;
              foreach (XmlNode trackDetail in trackNode.ChildNodes)
              {
                if (trackDetail.Name == "title")
                  track.Title = trackDetail.InnerText;

                if (trackDetail.Name == "duration")
                  track.Duration = Convert.ToInt32(trackDetail.InnerText);
              }
              album.Tracks.Add(track);
            }
              }
            }

            if (album.Asin != null)
            {
              // Now do a lookup on Amazon for the Image Url
              using (AmazonAlbumInfo amazonInfo = new AmazonAlbumInfo())
              {
            AmazonAlbum amazonAlbum = amazonInfo.AmazonAlbumLookup(album.Asin);
            album.Amazon = amazonAlbum;
              }
            }
              }

              return album;
        }
        public MusicBrainzAlbum GetMusicBrainzAlbumById(string albumID)
        {
            MusicBrainzAlbum album = new MusicBrainzAlbum();

            string requestString = musicBrainzUrl + string.Format(requestByID, albumID);
            string responseXml   = Util.GetWebPage(requestString);

            if (responseXml == null)
            {
                return(null);
            }

            XmlDocument xml = new XmlDocument();

            xml.LoadXml(responseXml);
            XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);

            nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-1.0#");

            XmlNodeList nodes = xml.SelectNodes("/m:metadata/m:release", nsMgr);

            if (nodes.Count > 0)
            {
                album.Id = new Guid(nodes[0].Attributes["id"].InnerXml);
                foreach (XmlNode childNode in nodes[0])
                {
                    if (childNode.Name == "title")
                    {
                        album.Title = childNode.InnerText;
                    }

                    if (childNode.Name == "asin")
                    {
                        album.Asin = childNode.InnerText;
                    }

                    if (childNode.Name == "artist")
                    {
                        foreach (XmlNode artistNode in childNode)
                        {
                            if (artistNode.Name == "name")
                            {
                                album.Artist = artistNode.InnerText;
                                break;
                            }
                        }
                    }

                    if (childNode.Name == "release-event-list")
                    {
                        foreach (XmlNode releaseNode in childNode)
                        {
                            if (releaseNode.Name == "event")
                            {
                                album.Year = releaseNode.Attributes["date"].InnerXml;
                            }
                        }
                    }

                    if (childNode.Name == "track-list")
                    {
                        foreach (XmlNode trackNode in childNode.ChildNodes)
                        {
                            MusicBrainzTrack track = new MusicBrainzTrack();
                            track.Id      = new Guid(trackNode.Attributes["id"].InnerXml);
                            track.AlbumID = album.Id;
                            track.Album   = album.Title;
                            track.Artist  = album.Artist;
                            foreach (XmlNode trackDetail in trackNode.ChildNodes)
                            {
                                if (trackDetail.Name == "title")
                                {
                                    track.Title = trackDetail.InnerText;
                                }

                                if (trackDetail.Name == "duration")
                                {
                                    track.Duration = Convert.ToInt32(trackDetail.InnerText);
                                }
                            }
                            album.Tracks.Add(track);
                        }
                    }
                }

                if (album.Asin != null)
                {
                    // Now do a lookup on Amazon for the Image Url
                    using (AmazonAlbumInfo amazonInfo = new AmazonAlbumInfo())
                    {
                        AmazonAlbum amazonAlbum = amazonInfo.AmazonAlbumLookup(album.Asin);
                        album.Amazon = amazonAlbum;
                    }
                }
            }

            return(album);
        }
Exemple #4
0
        /// <summary>
        ///   Get the MusicBrainz Track information for the PUID
        /// </summary>
        /// <param name = "puid"></param>
        /// <returns></returns>
        private List <MusicBrainzTrack> RetrieveMusicBrainzTrack(string puid)
        {
            log.Debug("Identify: Get track information for puid: {0}", puid);
            List <MusicBrainzTrack> tracks = new List <MusicBrainzTrack>();

            string requestString = musicBrainzUrl + puid;
            string responseXml   = Util.GetWebPage(requestString);

            if (responseXml == null)
            {
                return(tracks);
            }

            XmlDocument xml = new XmlDocument();

            xml.LoadXml(responseXml);
            XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);

            nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-1.0#");

            XmlNodeList nodes = xml.SelectNodes("/m:metadata/m:track-list/m:track", nsMgr);

            if (nodes.Count > 0)
            {
                foreach (XmlNode trackListNode in nodes)
                {
                    MusicBrainzTrack track = new MusicBrainzTrack();
                    track.Id = new Guid(trackListNode.Attributes["id"].InnerXml);
                    foreach (XmlNode childNode in trackListNode)
                    {
                        if (childNode.Name == "title")
                        {
                            track.Title = childNode.InnerText;
                        }

                        if (childNode.Name == "duration")
                        {
                            track.Duration = Convert.ToInt32(childNode.InnerText);
                        }

                        if (childNode.Name == "artist")
                        {
                            foreach (XmlNode artistNode in childNode)
                            {
                                if (artistNode.Name == "name")
                                {
                                    track.Artist = artistNode.InnerText;
                                    break;
                                }
                            }
                        }

                        if (childNode.Name == "release-list")
                        {
                            track.AlbumID = new Guid(childNode.ChildNodes[0].Attributes["id"].InnerXml);
                            foreach (XmlNode releaseNode in childNode.ChildNodes[0].ChildNodes)
                            {
                                if (releaseNode.Name == "title")
                                {
                                    track.Album = releaseNode.InnerText;
                                }

                                if (releaseNode.Name == "track-list")
                                {
                                    track.Number = Convert.ToInt32(releaseNode.Attributes["offset"].InnerXml) + 1;
                                }
                            }
                        }
                    }
                    tracks.Add(track);
                }
            }
            return(tracks);
        }
        public MusicBrainzAlbum GetMusicBrainzAlbumById(string albumID)
        {
            var album = new MusicBrainzAlbum();
              album.Id = albumID;

              var requestString = musicBrainzUrl + string.Format(requestByID, albumID);
              var responseXml = Util.GetWebPage(requestString);
              if (responseXml == null)
            return null;

              var xml = new XmlDocument();
              xml.LoadXml(responseXml);
              var nsMgr = new XmlNamespaceManager(xml.NameTable);
              nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-2.0#");

              // Selecting the Title
              var nodes = xml.SelectNodes("/m:metadata/m:release/m:title", nsMgr);
              if (nodes == null)
              {
            return null;
              }
              album.Title = nodes[0].InnerText;

              // Get the Album Artist(s)
              nodes = xml.SelectNodes("/m:metadata/m:release/m:artist-credit/m:name-credit/m:artist/m:name", nsMgr);
              if (nodes != null && nodes.Count > 0)
              {
            var artists = new List<string>();
            foreach (XmlNode node in nodes)
            {
              artists.Add(node.InnerText);
            }
            album.Artist = string.Join(";", artists);
              }

              // Selecting the Date
              nodes = xml.SelectNodes("/m:metadata/m:release/m:date", nsMgr);
              if (nodes != null && nodes.Count > 0)
              {
            string year = nodes[0].InnerText;
            if (year.Length > 4)
            {
              year = year.Substring(0, 4);
            }
            album.Year = year;
              }
              else
              {
            album.Year = string.Empty;
              }

              // Selecting the Asin
              nodes = xml.SelectNodes("/m:metadata/m:release/m:asin", nsMgr);
              if (nodes != null && nodes.Count > 0)
              {
            album.Asin = nodes[0].InnerText;
              }

              // Selecting the Media
              nodes = xml.SelectNodes("/m:metadata/m:release/m:medium-list/m:medium", nsMgr);
              if (nodes != null && nodes.Count > 0)
              {
            int pos = 1;
            album.DiscCount = nodes.Count;
            foreach (XmlNode node in nodes)
            {
              foreach (XmlNode childNode in node)
              {
            if (childNode.Name == "position")
              pos = Convert.ToInt32(childNode.InnerText);

            if (childNode.Name == "track-list")
            {
              int trackCount = Convert.ToInt32(childNode.Attributes["count"].Value);
              foreach (XmlNode trackNode in childNode.ChildNodes)
              {
                var track = new MusicBrainzTrack();
                track.DiscId = pos;
                track.TrackCount = trackCount;
                foreach (XmlNode trackDetail in trackNode.ChildNodes)
                {
                  if (trackDetail.Name == "recording")
                    track.Id = trackDetail.Attributes["id"].InnerXml;

                  if (trackDetail.Name == "position")
                    track.Number = Convert.ToInt32(trackDetail.InnerText);
                }
                album.Tracks.Add(track);
              }
            }

              }
            }
              }

              if (album.Asin != null)
              {
            var amazonAlbum = new AlbumInfo.AlbumSites.Amazon("", "", null, 0);
            album.Amazon = amazonAlbum.AmazonAlbumLookup(album.Asin);
              }

              return album;
        }
        MusicBrainzTrack ParseMusicBrainzQueryResult(string responseXml)
        {
            var track = new MusicBrainzTrack();
              var xml = new XmlDocument();
              xml.LoadXml(responseXml);
              var nsMgr = new XmlNamespaceManager(xml.NameTable);
              nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-2.0#");

              // Getting the Id
              var idNode = xml.SelectSingleNode("/m:metadata/m:recording", nsMgr);
              if (idNode == null)
              {
            return null;
              }
              track.Id = idNode.Attributes["id"].Value;

              // Selecting the Title
              var nodes = xml.SelectNodes("/m:metadata/m:recording/m:title", nsMgr);
              if (nodes == null)
              {
            return null;
              }
              track.Title = nodes[0].InnerText;

              // Get the Duration
              nodes = xml.SelectNodes("/m:metadata/m:recording/m:length", nsMgr);
              if (nodes != null && nodes.Count > 0)
              {
            track.Duration = Convert.ToInt32(nodes[0].InnerText) / 1000;
              }

              // Get the Artist(s)
              nodes = xml.SelectNodes("/m:metadata/m:recording/m:artist-credit/m:name-credit/m:artist/m:name", nsMgr);
              if (nodes != null)
              {
            var artists = new List<string>();
            foreach (XmlNode node in nodes)
            {
              artists.Add(node.InnerText);
            }
            track.Artist = string.Join(";", artists);
              }

              // Get the Release(s)
              nodes = xml.SelectNodes("/m:metadata/m:recording/m:release-list/m:release", nsMgr);
              if (nodes != null)
              {
            foreach (XmlNode node in nodes)
            {
              var release = new MusicBrainzRelease();
              release.AlbumId = node.Attributes["id"].Value;
              foreach (XmlNode childNode in node)
              {
            if (childNode.Name == "title")
              release.Album = childNode.InnerText;

            if (childNode.Name == "country")
              release.Country = childNode.InnerText;

            if (childNode.Name == "date")
            {
              string year = childNode.InnerText;
              if (year.Length > 4)
              {
                year = year.Substring(0, 4);
              }
              release.Year = Convert.ToInt32(year);
            }
              }
              track.Releases.Add(release);
            }
              }
              return track;
        }