open-source-mirrors
/
Readarr
mirror of https://github.com/Readarr/Readarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removing the MusicBrainz API in favor of iTunes

Browse Source
pull/6/head
Matthew Despain 8 years ago
parent d0728bbe22
commit a61cdeed0d
41 changed files with 0 additions and 2277 deletions
Show Stats Download Patch File Download Diff File

36
src/Hqub.MusicBrainz.API/Configuration.cs
Unescape View File

@ -1,36 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
namespace Hqub.MusicBrainz.API
{
public static class Configuration
{
static Configuration()
{
GenerateCommunicationThrow = true;
Proxy = null;
UserAgent = "Hqub.MusicBrainz/2.0";
}
/// <summary>
/// If true, then all exceptions for http-requests to MusicBrainz (from class WebRequestHelper) will
/// throw up. Otherwise they will be suppressed.
/// </summary>
public static bool GenerateCommunicationThrow { get; set; }
/// <summary>
/// Gets or sets a <see cref="System.Net.IWebProxy"/> used to query the webservice.
/// </summary>
public static IWebProxy Proxy { get; set; }
/// <summary>
/// Allow set cutstom user agent string.
/// </summary>
public static string UserAgent { get; set; }
}
}

204
src/Hqub.MusicBrainz.API/Entities/Artist.cs
Unescape View File

@ -1,204 +0,0 @@
using System;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
using Hqub.MusicBrainz.API.Entities.Metadata;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("artist", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Artist : Entity
{
public const string EntityName = "artist";
#region Properties
/// <summary>
/// Gets or sets the score (only available in search results).
/// </summary>
[XmlAttribute("score", Namespace = "http://musicbrainz.org/ns/ext#-2.0")]
public int Score { get; set; }
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the type.
/// </summary>
[XmlAttribute("type")]
public string Type { get; set; }
/// <summary>
/// Gets or sets the name.
/// </summary>
[XmlElement("name")]
public string Name { get; set; }
/// <summary>
/// Gets or sets the sort name.
/// </summary>
[XmlElement("sort-name")]
public string SortName { get; set; }
/// <summary>
/// Gets or sets the gender.
/// </summary>
[XmlElement("gender")]
public string Gender { get; set; }
/// <summary>
/// Gets or sets the life-span.
/// </summary>
[XmlElement("life-span")]
public LifeSpanNode LifeSpan { get; set; }
/// <summary>
/// Gets or sets the country.
/// </summary>
[XmlElement("country")]
public string Country { get; set; }
/// <summary>
/// Gets or sets the disambiguation.
/// </summary>
[XmlElement("disambiguation")]
public string Disambiguation { get; set; }
/// <summary>
/// Gets or sets the rating.
/// </summary>
[XmlElement("rating")]
public Rating Rating { get; set; }
#endregion
#region Subqueries
[XmlElement("recording-list")]
public RecordingList Recordings { get; set; }
[XmlElement("release-group-list")]
public ReleaseGroupList ReleaseGroups { get; set; }
[XmlElement("release-list")]
public ReleaseList ReleaseLists { get; set; }
[XmlElement("relation-list")]
public RelationList RelationLists { get; set; }
[XmlElement("work-list")]
public WorkList Works { get; set; }
[XmlElement("tag-list")]
public TagList Tags { get; set; }
#endregion
#region Static Methods
[Obsolete("Use GetAsync() method.")]
public static Artist Get(string id, params string[] inc)
{
return GetAsync<Artist>(EntityName, id, inc).Result;
}
[Obsolete("Use SearchAsync() method.")]
public static ArtistList Search(string query, int limit = 25, int offset = 0)
{
return SearchAsync<ArtistMetadata>(EntityName,
query, limit, offset).Result.Collection;
}
[Obsolete("Use BrowseAsync() method.")]
public static ArtistList Browse(string relatedEntity, string value, int limit = 25, int offset = 0, params string[] inc)
{
return BrowseAsync<ArtistMetadata>(EntityName,
relatedEntity, value, limit, offset, inc).Result.Collection;
}
/// <summary>
/// Lookup an artist in the MusicBrainz database.
/// </summary>
/// <param name="id">The artist MusicBrainz id.</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<Artist> GetAsync(string id, params string[] inc)
{
return await GetAsync<Artist>(EntityName, id, inc);
}
/// <summary>
/// Search for an artist in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query string.</param>
/// <param name="limit">The maximum number of artists to return (default = 25).</param>
/// <param name="offset">The offset to the artists list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<ArtistList> SearchAsync(string query, int limit = 25, int offset = 0)
{
return (await SearchAsync<ArtistMetadata>(EntityName,
query, limit, offset)).Collection;
}
/// <summary>
/// Search for an artist in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query parameters.</param>
/// <param name="limit">The maximum number of artists to return (default = 25).</param>
/// <param name="offset">The offset to the artists list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<ArtistList> SearchAsync(QueryParameters<Artist> query, int limit = 25, int offset = 0)
{
return (await SearchAsync<ArtistMetadata>(EntityName,
query.ToString(), limit, offset)).Collection;
}
/// <summary>
/// Browse all the artists in the MusicBrainz database, which are directly linked to the
/// entity with given id.
/// </summary>
/// <param name="entity">The name of the related entity.</param>
/// <param name="id">The id of the related entity.</param>
/// <param name="limit">The maximum number of artists to return (default = 25).</param>
/// <param name="offset">The offset to the artists list (enables paging, default = 0).</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<ArtistList> BrowseAsync(string entity, string id, int limit = 25, int offset = 0, params string[] inc)
{
return (await BrowseAsync<ArtistMetadata>(EntityName, entity, id,
limit, offset, inc)).Collection;
}
#endregion
}
#region Include entities
[XmlRoot("life-span", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class LifeSpanNode
{
/// <summary>
/// Gets or sets the begin date.
/// </summary>
[XmlElement("begin")]
public string Begin { get; set; }
/// <summary>
/// Gets or sets the end date.
/// </summary>
[XmlElement("end")]
public string End { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the life-span ended or not.
/// </summary>
[XmlElement("ended")]
public bool Ended { get; set; }
}
#endregion
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/ArtistList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("artist-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ArtistList : BaseList
{
/// <summary>
/// Gets or sets the list of artists.
/// </summary>
[XmlElement("artist")]
public List<Artist> Items { get; set; }
}
}

25
src/Hqub.MusicBrainz.API/Entities/Collections/BaseList.cs
Unescape View File

@ -1,25 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
public class BaseList
{
/// <summary>
/// Gets or sets the total list items count.
/// </summary>
/// <remarks>
/// This might be different form the actual list items count. If the list was
/// generated from a search request, this property will return the total number
/// of available items (on the server), while the number of returned items is
/// limited by the requests 'limit' parameter (default = 25).
/// </remarks>
[XmlAttribute("count")]
public int QueryCount { get; set; }
/// <summary>
/// Gets or sets the list offset (only available in search requests).
/// </summary>
[XmlAttribute("offset")]
public int QueryOffset { get; set; }
}
}

24
src/Hqub.MusicBrainz.API/Entities/Collections/MediumList.cs
Unescape View File

@ -1,24 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("medium-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class MediumList : BaseList
{
/// <summary>
/// Gets or sets the medium track count.
/// </summary>
/// <remarks>
/// Only available in the result of a release search (???).
/// </remarks>
[XmlElement(ElementName = "track-count")]
public int TrackCount { get; set; }
/// <summary>
/// Gets or sets the list of mediums.
/// </summary>
[XmlElement("medium")]
public List<Medium> Items { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/RecordingList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("recording-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class RecordingList : BaseList
{
/// <summary>
/// Gets or sets the list of recordings.
/// </summary>
[XmlElement("recording")]
public List<Recording> Items { get; set; }
}
}

21
src/Hqub.MusicBrainz.API/Entities/Collections/RelationList.cs
Unescape View File

@ -1,21 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("relation-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class RelationList : BaseList
{
/// <summary>
/// Gets or sets the relation target type.
/// </summary>
[XmlAttribute("target-type")]
public string TargetType { get; set; }
/// <summary>
/// Gets or sets the list of relations.
/// </summary>
[XmlElement("relation")]
public List<Relation> Items { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/ReleaseGroupList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("recording-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ReleaseGroupList : BaseList
{
/// <summary>
/// Gets or sets the list of release-groups.
/// </summary>
[XmlElement("release-group")]
public List<ReleaseGroup> Items { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/ReleaseList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("release-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ReleaseList : BaseList
{
/// <summary>
/// Gets or sets the list of releases.
/// </summary>
[XmlElement("release")]
public List<Release> Items { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/TagList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("tag-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class TagList : BaseList
{
/// <summary>
/// Gets or sets the list of tags.
/// </summary>
[XmlElement("tag")]
public List<Tag> Items { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/TrackList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("track-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class TrackList : BaseList
{
/// <summary>
/// Gets or sets the list of tracks.
/// </summary>
[XmlElement("track")]
public List<Track> Items { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Collections/WorkList.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities.Collections
{
[XmlRoot("work-list", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class WorkList : BaseList
{
/// <summary>
/// Gets or sets the list of works.
/// </summary>
[XmlElement("work")]
public List<Work> Items { get; set; }
}
}

39
src/Hqub.MusicBrainz.API/Entities/CoverArtArchive.cs
Unescape View File

@ -1,39 +0,0 @@
using System;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("cover-art-archive", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class CoverArtArchive
{
/// <summary>
/// Gets or sets a value indicating whether artwork is available or not.
/// </summary>
[XmlElement("artwork")]
public bool Artwork { get; set; }
/// <summary>
/// Gets or sets the count.
/// </summary>
[XmlElement("count")]
public int Count { get; set; }
/// <summary>
/// Gets or sets a value indicating whether a front crover is available or not.
/// </summary>
[XmlElement("front")]
public bool Front { get; set; }
/// <summary>
/// Gets or sets a value indicating whether a back crover is available or not.
/// </summary>
[XmlElement("back")]
public bool Back { get; set; }
public static Uri GetCoverArtUri(string releaseId)
{
string url = "http://coverartarchive.org/release/" + releaseId + "/front-250.jpg";
return new Uri(url, UriKind.RelativeOrAbsolute);
}
}
}

87
src/Hqub.MusicBrainz.API/Entities/Entity.cs
Unescape View File

@ -1,87 +0,0 @@
using System;
using System.Threading.Tasks;
using Hqub.MusicBrainz.API.Entities.Metadata;
namespace Hqub.MusicBrainz.API.Entities
{
/// <summary>
/// Base class for any entity returned by the MusicBrainz XML webservice.
/// </summary>
public abstract class Entity
{
private static string CreateIncludeQuery(string[] inc)
{
return string.Join("+", inc);
}
/// <summary>
/// Sends a lookup request to the webservice.
/// </summary>
/// <typeparam name="T">Any type derived from <see cref="Entity"/>.</typeparam>
/// <param name="entity">The name of the XML entity to lookup.</param>
/// <param name="id">The MusicBrainz id of the entity.</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
protected async static Task<T> GetAsync<T>(string entity, string id, params string[] inc) where T : Entity
{
if (string.IsNullOrEmpty(entity))
{
throw new ArgumentException(string.Format(Resources.Messages.MissingParameter, "entity"));
}
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(string.Format(Resources.Messages.MissingParameter, "id"));
}
return await WebRequestHelper.GetAsync<T>(WebRequestHelper.CreateLookupUrl(entity, id, CreateIncludeQuery(inc)));
}
/// <summary>
/// Sends a search request to the webservice.
/// </summary>
/// <typeparam name="T">Any type derived from <see cref="Entity"/>.</typeparam>
/// <param name="entity">The name of the XML entity to search for.</param>
/// <param name="query">The query string.</param>
/// <param name="limit">The number of items to return (default = 25).</param>
/// <param name="offset">The offset to the items list (enables paging, default = 0).</param>
/// <returns></returns>
protected async static Task<T> SearchAsync<T>(string entity, string query, int limit = 25, int offset = 0) where T : MetadataWrapper
{
if (string.IsNullOrEmpty(entity))
{
throw new ArgumentException(string.Format(Resources.Messages.MissingParameter, "entity"));
}
if (string.IsNullOrEmpty(query))
{
throw new ArgumentException(string.Format(Resources.Messages.MissingParameter, "query"));
}
return await WebRequestHelper.GetAsync<T>(WebRequestHelper.CreateSearchTemplate(entity,
query, limit, offset), withoutMetadata: false);
}
/// <summary>
/// Sends a browse request to the webservice.
/// </summary>
/// <typeparam name="T">Any type derived from <see cref="Entity"/>.</typeparam>
/// <param name="entity">The name of the XML entity to browse.</param>
/// <param name="relatedEntity"></param>
/// <param name="relatedEntityId"></param>
/// <param name="limit">The number of items to return (default = 25).</param>
/// <param name="offset">The offset to the items list (enables paging, default = 0).</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
protected async static Task<T> BrowseAsync<T>(string entity, string relatedEntity, string relatedEntityId, int limit, int offset, params string[] inc) where T : Entity
{
if (string.IsNullOrEmpty(entity))
{
throw new ArgumentException(string.Format(Resources.Messages.MissingParameter, "entity"));
}
return await WebRequestHelper.GetAsync<T>(WebRequestHelper.CreateBrowseTemplate(entity,
relatedEntity, relatedEntityId, limit, offset, CreateIncludeQuery(inc)), withoutMetadata: false);
}
}
}

44
src/Hqub.MusicBrainz.API/Entities/Include/ArtistIncludeEntityHelper.cs
Unescape View File

@ -1,44 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Hqub.MusicBrainz.API.Entities.Include
{
public static class ArtistIncludeEntityHelper
{
public const string Recordings = "recordings";
public const string Releases = "releases";
public const string ReleaseGroups = "release-groups";
public const string Works = "works";
public const string Tags = "tags";
public const string Ratings = "ratings";
// Relations
// public const string ArtistRelation = "artist-rels";
// public const string LabelRelation = "label-rels";
// public const string RecordingRelation = "recording-rels";
// public const string ReleaseRelation = "release-rels";
// public const string ReleaseGroupRelation = "release-group-rels";
public const string UrlRelation = "url-rels";
// public const string WorkRelation = "work-rels";
public static bool Check(string incEntity)
{
switch (incEntity)
{
case Recordings:
case Releases:
case ReleaseGroups:
case Works:
case Tags:
case Ratings:
return true;
default:
return false;
}
}
}
}

20
src/Hqub.MusicBrainz.API/Entities/Label.cs
Unescape View File

@ -1,20 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("label")]
public class Label
{
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the name.
/// </summary>
[XmlElement("name")]
public string Name { get; set; }
}
}

20
src/Hqub.MusicBrainz.API/Entities/LabelInfo.cs
Unescape View File

@ -1,20 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("label-info")]
public class LabelInfo
{
/// <summary>
/// Gets or sets the catalog-number.
/// </summary>
[XmlElement("catalog-number")]
public string CatalogNumber { get; set; }
/// <summary>
/// Gets or sets the label.
/// </summary>
[XmlElement("label")]
public Label Label { get; set; }
}
}

36
src/Hqub.MusicBrainz.API/Entities/Medium.cs
Unescape View File

@ -1,36 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("medium")]
public class Medium
{
/// <summary>
/// Gets or sets the format.
/// </summary>
[XmlElement("format")]
public string Format { get; set; }
/// <summary>
/// Gets or sets the disc-list.
/// </summary>
[XmlElement("disc-list")]
public DiskList Disks { get; set; }
/// <summary>
/// Gets or sets the track-list.
/// </summary>
[XmlElement("track-list")]
public Collections.TrackList Tracks { get; set; }
}
[XmlRoot("disk-list")]
public class DiskList
{
/// <summary>
/// Gets or sets the count.
/// </summary>
[XmlAttribute("count")]
public int Count { get; set; }
}
}

13
src/Hqub.MusicBrainz.API/Entities/Metadata.cs
Unescape View File

@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Hqub.MusicBrainz.API.Entities
{
public abstract class MetadataWrapper : Entity
{
}
}

15
src/Hqub.MusicBrainz.API/Entities/Metadata/ArtistMetadata.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
namespace Hqub.MusicBrainz.API.Entities.Metadata
{
[XmlRoot("metadata", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ArtistMetadata : MetadataWrapper
{
/// <summary>
/// Gets or sets the artist-list collection.
/// </summary>
[XmlElement("artist-list")]
public ArtistList Collection { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Metadata/RecordingMetadata.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
namespace Hqub.MusicBrainz.API.Entities.Metadata
{
[XmlRoot("metadata", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class RecordingMetadata : MetadataWrapper
{
/// <summary>
/// Gets or sets the recording-list collection.
/// </summary>
[XmlElement("recording-list")]
public RecordingList Collection { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Metadata/ReleaseGroupMetadata.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
namespace Hqub.MusicBrainz.API.Entities.Metadata
{
[XmlRoot("metadata", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ReleaseGroupMetadata : MetadataWrapper
{
/// <summary>
/// Gets or sets the release-group collection.
/// </summary>
[XmlElement("release-group-list")]
public ReleaseGroupList Collection { get; set; }
}
}

15
src/Hqub.MusicBrainz.API/Entities/Metadata/ReleaseMetadata.cs
Unescape View File

@ -1,15 +0,0 @@
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
namespace Hqub.MusicBrainz.API.Entities.Metadata
{
[XmlRoot("metadata", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ReleaseMetadata : MetadataWrapper
{
/// <summary>
/// Gets or sets the release-list collection.
/// </summary>
[XmlElement("release-list")]
public ReleaseList Collection { get; set; }
}
}

20
src/Hqub.MusicBrainz.API/Entities/NameCredit.cs
Unescape View File

@ -1,20 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("name-credit")]
public class NameCredit
{
/// <summary>
/// Gets or sets the joinphrase.
/// </summary>
[XmlAttribute("joinphrase")]
public string JoinPhrase { get; set; }
/// <summary>
/// Gets or sets the artist.
/// </summary>
[XmlElement("artist")]
public Artist Artist { get; set; }
}
}

20
src/Hqub.MusicBrainz.API/Entities/Rating.cs
Unescape View File

@ -1,20 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("rating", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Rating
{
/// <summary>
/// Gets or sets the votes-count.
/// </summary>
[XmlAttribute("votes-count")]
public int VotesCount { get; set; }
/// <summary>
/// Gets or sets the rating value.
/// </summary>
[XmlText]
public double Value { get; set; }
}
}

140
src/Hqub.MusicBrainz.API/Entities/Recording.cs
Unescape View File

@ -1,140 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
using Hqub.MusicBrainz.API.Entities.Metadata;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("recording", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Recording : Entity
{
public const string EntityName = "recording";
#region Properties
/// <summary>
/// Gets or sets the score (only available in search results).
/// </summary>
[XmlAttribute("score", Namespace = "http://musicbrainz.org/ns/ext#-2.0")]
public int Score { get; set; }
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the title.
/// </summary>
[XmlElement("title")]
public string Title { get; set; }
/// <summary>
/// Gets or sets the length.
/// </summary>
[XmlElement("length")]
public int Length { get; set; }
/// <summary>
/// Gets or sets the disambiguation.
/// </summary>
[XmlElement("disambiguation")]
public string Disambiguation { get; set; }
#endregion
#region Include
[XmlElement("tag-list")]
public TagList Tags { get; set; }
[XmlArray("artist-credit")]
[XmlArrayItem("name-credit")]
public List<NameCredit> Credits { get; set; }
[XmlElement("release-list")]
public ReleaseList Releases { get; set; }
#endregion
#region Static methods
[Obsolete("Use GetAsync() method.")]
public static Recording Get(string id, params string[] inc)
{
return GetAsync<Recording>(EntityName, id, inc).Result;
}
[Obsolete("Use SearchAsync() method.")]
public static RecordingList Search(string query, int limit = 25, int offset = 0)
{
return SearchAsync<RecordingMetadata>(EntityName,
query, limit, offset).Result.Collection;
}
[Obsolete("Use BrowseAsync() method.")]
public static RecordingList Browse(string relatedEntity, string value, int limit = 25, int offset = 0, params string[] inc)
{
return BrowseAsync<RecordingMetadata>(EntityName,
relatedEntity, value, limit, offset, inc).Result.Collection;
}
/// <summary>
/// Lookup an recording in the MusicBrainz database.
/// </summary>
/// <param name="id">The recording MusicBrainz id.</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<Recording> GetAsync(string id, params string[] inc)
{
return await GetAsync<Recording>(EntityName, id, inc);
}
/// <summary>
/// Search for an recording in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query string.</param>
/// <param name="limit">The maximum number of recordings to return (default = 25).</param>
/// <param name="offset">The offset to the recordings list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<RecordingList> SearchAsync(string query, int limit = 25, int offset = 0)
{
return (await SearchAsync<RecordingMetadata>(EntityName,
query, limit, offset)).Collection;
}
/// <summary>
/// Search for an recording in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query parameters.</param>
/// <param name="limit">The maximum number of recordings to return (default = 25).</param>
/// <param name="offset">The offset to the recordings list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<RecordingList> SearchAsync(QueryParameters<Recording> query, int limit = 25, int offset = 0)
{
return (await SearchAsync<RecordingMetadata>(EntityName,
query.ToString(), limit, offset)).Collection;
}
/// <summary>
/// Browse all the recordings in the MusicBrainz database, which are directly linked to the
/// entity with given id.
/// </summary>
/// <param name="entity">The name of the related entity.</param>
/// <param name="id">The id of the related entity.</param>
/// <param name="limit">The maximum number of recordings to return (default = 25).</param>
/// <param name="offset">The offset to the recordings list (enables paging, default = 0).</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<RecordingList> BrowseAsync(string entity, string id, int limit = 25, int offset = 0, params string[] inc)
{
return (await BrowseAsync<RecordingMetadata>(EntityName,
entity, id, limit, offset, inc)).Collection;
}
#endregion
}
}

33
src/Hqub.MusicBrainz.API/Entities/Relation.cs
Unescape View File

@ -1,33 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
using Hqub.MusicBrainz.API.Entities.Metadata;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("relation", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Relation : Entity
{
public const string EntityName = "relation";
/// <summary>
/// Gets or sets the relation type.
/// </summary>
[XmlAttribute("type")]
public string Type { get; set; }
/// <summary>
/// Gets or sets the relation type ID.
/// </summary>
[XmlAttribute("type-id")]
public string TypeId { get; set; }
/// <summary>
/// Gets or sets the relation target.
/// </summary>
[XmlElement("target")]
public string Target { get; set; }
}
}

188
src/Hqub.MusicBrainz.API/Entities/Release.cs
Unescape View File

@ -1,188 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
using Hqub.MusicBrainz.API.Entities.Metadata;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("release", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Release : Entity
{
public const string EntityName = "release";
#region Properties
/// <summary>
/// Gets or sets the score (only available in search results).
/// </summary>
[XmlAttribute("score", Namespace = "http://musicbrainz.org/ns/ext#-2.0")]
public int Score { get; set; }
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the title.
/// </summary>
[XmlElement("title")]
public string Title { get; set; }
/// <summary>
/// Gets or sets the status.
/// </summary>
[XmlElement("status")]
public string Status { get; set; }
/// <summary>
/// Gets or sets the quality.
/// </summary>
[XmlElement("quality")]
public string Quality { get; set; }
/// <summary>
/// Gets or sets the text-representation.
/// </summary>
[XmlElement("text-representation")]
public TextRepresentation TextRepresentation { get; set; }
/// <summary>
/// Gets or sets the date.
/// </summary>
[XmlElement("date")]
public string Date { get; set; }
/// <summary>
/// Gets or sets the country.
/// </summary>
[XmlElement("country")]
public string Country { get; set; }
/// <summary>
/// Gets or sets the barcode.
/// </summary>
[XmlElement("barcode")]
public string Barcode { get; set; }
/// <summary>
/// Gets or sets the release-group.
/// </summary>
[XmlElement("release-group")]
public ReleaseGroup ReleaseGroup { get; set; }
/// <summary>
/// Gets or sets the cover-art-archive.
/// </summary>
[XmlElement("cover-art-archive")]
public CoverArtArchive CoverArtArchive { get; set; }
#endregion
#region Subqueries
[XmlArray("artist-credit")]
[XmlArrayItem("name-credit")]
public List<NameCredit> Credits { get; set; }
[XmlArray("label-info-list")]
[XmlArrayItem("label-info")]
public List<LabelInfo> Labels { get; set; }
[XmlElement("medium-list")]
public Collections.MediumList MediumList { get; set; }
#endregion
#region Static Methods
[Obsolete("Use GetAsync() method.")]
public static Release Get(string id, params string[] inc)
{
return GetAsync<Release>(EntityName, id, inc).Result;
}
[Obsolete("Use SearchAsync() method.")]
public static ReleaseList Search(string query, int limit = 25, int offset = 0)
{
return SearchAsync<ReleaseMetadata>(EntityName,
query, limit, offset).Result.Collection;
}
/// <summary>
/// Lookup a release in the MusicBrainz database.
/// </summary>
/// <param name="id">The release MusicBrainz id.</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<Release> GetAsync(string id, params string[] inc)
{
return await GetAsync<Release>(EntityName, id, inc);
}
/// <summary>
/// Search for a release in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query string.</param>
/// <param name="limit">The maximum number of releases to return (default = 25).</param>
/// <param name="offset">The offset to the releases list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<ReleaseList> SearchAsync(string query, int limit = 25, int offset = 0)
{
return (await SearchAsync<ReleaseMetadata>(EntityName,
query, limit, offset)).Collection;
}
/// <summary>
/// Search for a release in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query parameters.</param>
/// <param name="limit">The maximum number of releases to return (default = 25).</param>
/// <param name="offset">The offset to the releases list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<ReleaseList> SearchAsync(QueryParameters<Release> query, int limit = 25, int offset = 0)
{
return (await SearchAsync<ReleaseMetadata>(EntityName,
query.ToString(), limit, offset)).Collection;
}
/// <summary>
/// Browse all the releases in the MusicBrainz database, which are directly linked to the
/// entity with given id.
/// </summary>
/// <param name="entity">The name of the related entity.</param>
/// <param name="id">The id of the related entity.</param>
/// <param name="limit">The maximum number of releases to return (default = 25).</param>
/// <param name="offset">The offset to the releases list (enables paging, default = 0).</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public static async Task<ReleaseList> BrowseAsync(string entity, string id, int limit = 25,
int offset = 0, params string[] inc)
{
return (await BrowseAsync<ReleaseMetadata>(EntityName,
entity, id, limit, offset, inc)).Collection;
}
#endregion
}
[XmlType(Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
[XmlRoot("text-representation", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class TextRepresentation
{
/// <summary>
/// Gets or sets the language.
/// </summary>
[XmlElement("language")]
public string Language { get; set; }
/// <summary>
/// Gets or sets the script.
/// </summary>
[XmlElement("script")]
public string Script { get; set; }
}
}

159
src/Hqub.MusicBrainz.API/Entities/ReleaseGroup.cs
Unescape View File

@ -1,159 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Hqub.MusicBrainz.API.Entities.Collections;
using Hqub.MusicBrainz.API.Entities.Metadata;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("release-group", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class ReleaseGroup : Entity
{
public const string EntityName = "release-group";
#region Properties
/// <summary>
/// Gets or sets the score (only available in search results).
/// </summary>
[XmlAttribute("score", Namespace = "http://musicbrainz.org/ns/ext#-2.0")]
public int Score { get; set; }
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the type (like album, single or ep).
/// </summary>
[XmlAttribute("type")]
public string Type { get; set; }
/// <summary>
/// Gets or sets the title.
/// </summary>
[XmlElement("title")]
public string Title { get; set; }
/// <summary>
/// Gets or sets the first release date.
/// </summary>
[XmlElement("first-release-date")]
public string FirstReleaseDate { get; set; }
/// <summary>
/// Gets or sets the primary type.
/// </summary>
[XmlElement("primary-type")]
public string PrimaryType { get; set; }
/// <summary>
/// Gets or sets the rating".
/// </summary>
[XmlElement("rating")]
public Rating Rating { get; set; }
/// <summary>
/// Gets or sets the tag-list.
/// </summary>
[XmlElement("tag-list")]
public TagList Tags { get; set; }
#endregion
#region Subqueries
[XmlArray("artist-credit")]
[XmlArrayItem("name-credit")]
public List<NameCredit> Credits { get; set; }
[XmlArray("release-list")]
[XmlArrayItem("release")]
public List<Release> Releases { get; set; }
#endregion
#region Static Methods
[Obsolete("Use GetAsync() method.")]
public static ReleaseGroup Get(string id, params string[] inc)
{
return GetAsync<ReleaseGroup>(EntityName, id, inc).Result;
}
[Obsolete("Use SearchAsync() method.")]
public static ReleaseGroupList Search(string query, int limit = 25, int offset = 0)
{
return SearchAsync<ReleaseGroupMetadata>(EntityName,
query, limit, offset).Result.Collection;
}
[Obsolete("Use BrowseAsync() method.")]
public static ReleaseGroupList Browse(string relatedEntity, string value, int limit = 25, int offset = 0, params string[] inc)
{
return BrowseAsync<ReleaseGroupMetadata>(EntityName,
relatedEntity, value, limit, offset, inc).Result.Collection;
}
/// <summary>
/// Lookup a release-group in the MusicBrainz database.
/// </summary>
/// <param name="id">The release-group MusicBrainz id.</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<ReleaseGroup> GetAsync(string id, params string[] inc)
{
return await GetAsync<ReleaseGroup>(EntityName, id, inc);
}
/// <summary>
/// Search for a release-group in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query string.</param>
/// <param name="limit">The maximum number of release-groups to return (default = 25).</param>
/// <param name="offset">The offset to the release-groups list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<ReleaseGroupList> SearchAsync(string query, int limit = 25, int offset = 0)
{
return (await SearchAsync<ReleaseGroupMetadata>(EntityName,
query, limit, offset)).Collection;
}
/// <summary>
/// Search for a release-group in the MusicBrainz database, matching the given query.
/// </summary>
/// <param name="query">The query parameters.</param>
/// <param name="limit">The maximum number of release-groups to return (default = 25).</param>
/// <param name="offset">The offset to the release-groups list (enables paging, default = 0).</param>
/// <returns></returns>
public async static Task<ReleaseGroupList> SearchAsync(QueryParameters<ReleaseGroup> query, int limit = 25, int offset = 0)
{
return (await SearchAsync<ReleaseGroupMetadata>(EntityName,
query.ToString(), limit, offset)).Collection;
}
/// <summary>
/// Browse all the release-groups in the MusicBrainz database, which are directly linked to the
/// entity with given id.
/// </summary>
/// <param name="entity">The name of the related entity.</param>
/// <param name="id">The id of the related entity.</param>
/// <param name="limit">The maximum number of release-groups to return (default = 25).</param>
/// <param name="offset">The offset to the release-groups list (enables paging, default = 0).</param>
/// <param name="inc">A list of entities to include (subqueries).</param>
/// <returns></returns>
public async static Task<ReleaseGroupList> BrowseAsync(string entity, string id, int limit = 25, int offset = 0, params string[] inc)
{
return (await BrowseAsync<ReleaseGroupMetadata>(EntityName, entity, id,
limit, offset, inc)).Collection;
}
// TODO: add string parameter 'type' and 'status' to browse methods
// see http://musicbrainz.org/doc/Development/XML_Web_Service/Version_2#Release_Type_and_Status
#endregion
}
}

20
src/Hqub.MusicBrainz.API/Entities/Tag.cs
Unescape View File

@ -1,20 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("tag", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Tag
{
/// <summary>
/// Gets or sets the count.
/// </summary>
[XmlAttribute("count")]
public int Count { get; set; }
/// <summary>
/// Gets or sets the name.
/// </summary>
[XmlElement("name")]
public string Name { get; set; }
}
}

35
src/Hqub.MusicBrainz.API/Entities/Track.cs
Unescape View File

@ -1,35 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("track", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Track
{
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the position.
/// </summary>
[XmlElement("position")]
public int Position { get; set; }
// <number> is almost always same as <position>, so leaving it
/// <summary>
/// Gets or sets the length.
/// </summary>
[XmlElement("length")]
public int Length { get; set; }
/// <summary>
/// Gets or sets the recording.
/// </summary>
[XmlElement("recording")]
public Recording Recording { get; set; }
}
}

26
src/Hqub.MusicBrainz.API/Entities/Work.cs
Unescape View File

@ -1,26 +0,0 @@
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API.Entities
{
[XmlRoot("work", Namespace = "http://musicbrainz.org/ns/mmd-2.0#")]
public class Work
{
/// <summary>
/// Gets or sets the MusicBrainz id.
/// </summary>
[XmlAttribute("id")]
public string Id { get; set; }
/// <summary>
/// Gets or sets the title.
/// </summary>
[XmlElement("title")]
public string Title { get; set; }
/// <summary>
/// Gets or sets the ISW code.
/// </summary>
[XmlElement("iswc")]
public string ISWC { get; set; }
}
}

120
src/Hqub.MusicBrainz.API/Hqub.MusicBrainz.API.csproj
Unescape View File

@ -1,120 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Hqub.MusicBrainz.API</RootNamespace>
<AssemblyName>Hqub.MusicBrainz.API</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
<RestorePackages>true</RestorePackages>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\_output\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Travis|AnyCPU'">
<OutputPath>bin\Travis\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>AnyCPU</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Net.Http" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Configuration.cs" />
<Compile Include="Entities\Artist.cs" />
<Compile Include="Entities\Collections\ArtistList.cs" />
<Compile Include="Entities\Collections\BaseList.cs" />
<Compile Include="Entities\Collections\MediumList.cs" />
<Compile Include="Entities\Collections\RecordingList.cs" />
<Compile Include="Entities\Collections\ReleaseGroupList.cs" />
<Compile Include="Entities\Collections\RelationList.cs" />
<Compile Include="Entities\Collections\ReleaseList.cs" />
<Compile Include="Entities\Collections\TagList.cs" />
<Compile Include="Entities\Collections\TrackList.cs" />
<Compile Include="Entities\Collections\WorkList.cs" />
<Compile Include="Entities\CoverArtArchive.cs" />
<Compile Include="Entities\Entity.cs" />
<Compile Include="Entities\Include\ArtistIncludeEntityHelper.cs" />
<Compile Include="Entities\Label.cs" />
<Compile Include="Entities\LabelInfo.cs" />
<Compile Include="Entities\Medium.cs" />
<Compile Include="Entities\Metadata.cs" />
<Compile Include="Entities\Metadata\ArtistMetadata.cs" />
<Compile Include="Entities\Metadata\RecordingMetadata.cs" />
<Compile Include="Entities\Metadata\ReleaseGroupMetadata.cs" />
<Compile Include="Entities\Metadata\ReleaseMetadata.cs" />
<Compile Include="Entities\NameCredit.cs" />
<Compile Include="Entities\Rating.cs" />
<Compile Include="Entities\Recording.cs" />
<Compile Include="Entities\Relation.cs" />
<Compile Include="Entities\Release.cs" />
<Compile Include="Entities\ReleaseGroup.cs" />
<Compile Include="Entities\Tag.cs" />
<Compile Include="Entities\Track.cs" />
<Compile Include="Entities\Work.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="QueryParameters.cs" />
<Compile Include="Resources\Constants.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>Constants.resx</DependentUpon>
</Compile>
<Compile Include="Resources\Messages.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>Messages.resx</DependentUpon>
</Compile>
<Compile Include="WebRequestHelper.cs" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="Resources\Constants.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Constants.Designer.cs</LastGenOutput>
</EmbeddedResource>
<EmbeddedResource Include="Resources\Messages.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Messages.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

38
src/Hqub.MusicBrainz.API/Properties/AssemblyInfo.cs
Unescape View File

@ -1,38 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("MusicBrainze.API")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Hqub.MusicBrainze.API")]
[assembly: AssemblyCopyright("Copyright h-qub © 2014-2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("0b145d11-b090-4fe6-9294-5a73d67571a5")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.1")]
[assembly: AssemblyFileVersion("1.0.1")]
[assembly: InternalsVisibleTo("Hqub.MusicBrainz.API.Test")]

148
src/Hqub.MusicBrainz.API/QueryParameters.cs
Unescape View File

@ -1,148 +0,0 @@
using Hqub.MusicBrainz.API.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Hqub.MusicBrainz.API
{
/// <summary>
/// Helper for building MusicBrainz query strings.
/// </summary>
/// <typeparam name="T">The entity type to search for.</typeparam>
/// <remarks>
/// See https://musicbrainz.org/doc/Development/XML_Web_Service/Version_2/Search
/// </remarks>
public class QueryParameters<T>
where T : Entity
{
List<QueryNode> values;
public QueryParameters()
{
values = new List<QueryNode>();
}
/// <summary>
/// Add a field to the query paramaters.
/// </summary>
/// <param name="key">The field key.</param>
/// <param name="value">The field value.</param>
/// <param name="negate">Negate the field (will result in 'AND NOT key:value')</param>
public void Add(string key, string value, bool negate = false)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException(string.Format(Resources.Messages.MissingParameter, "key"));
}
if (!Validate(key))
{
throw new Exception(string.Format(Resources.Messages.InvalidQueryParameter, key));
}
values.Add(new QueryNode(key, value, negate));
}
public override string ToString()
{
return BuildQueryString();
}
private string BuildQueryString()
{
var sb = new StringBuilder();
string value;
foreach (var item in values)
{
// Append operator.
if (sb.Length > 0)
{
sb.Append(" AND ");
}
// Negate operator.
if (item.Negate)
{
sb.Append("NOT ");
}
// Append key.
sb.Append(item.Key);
sb.Append(':');
// Append value.
value = item.Value;
if (value.Contains("AND") || value.Contains("OR"))
{
if (!value.StartsWith("("))
{
// The search value appears to be an expression, so enclose it in brackets.
sb.Append("(" + value + ")");
}
else
{
sb.Append(value);
}
}
else if (value.Contains(" ") && !value.StartsWith("\""))
{
// The search value contains whitespace but isn't quoted.
sb.Append("\"" + value + "\"");
}
else
{
// The search value is already quoted or doesn't need quoting, so just append it.
sb.AppendFormat(value);
}
}
return sb.ToString();
}
private bool Validate(string key)
{
key = "-" + key + "-";
if (typeof(T) == typeof(Artist))
{
return Resources.Constants.ArtistQueryParams.IndexOf(key) >= 0;
}
if (typeof(T) == typeof(Recording))
{
return Resources.Constants.RecordingQueryParams.IndexOf(key) >= 0;
}
if (typeof(T) == typeof(Release))
{
return Resources.Constants.ReleaseQueryParams.IndexOf(key) >= 0;
}
if (typeof(T) == typeof(ReleaseGroup))
{
return Resources.Constants.ReleaseGroupQueryParams.IndexOf(key) >= 0;
}
return false;
}
class QueryNode
{
public string Key { get; private set; }
public string Value { get; private set; }
public bool Negate { get; private set; }
public QueryNode(string key, string value, bool negate)
{
this.Key = key;
this.Value = value;
this.Negate = negate;
}
}
}
}

99
src/Hqub.MusicBrainz.API/Resources/Constants.Designer.cs generated
Unescape View File

@ -1,99 +0,0 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.34209
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Hqub.MusicBrainz.API.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Constants {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Constants() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Hqub.MusicBrainz.API.Resources.Constants", typeof(Constants).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to -area-beginarea-endarea-arid-artist-artistaccent-alias-begin-comment-country-end-ended-gender-ipi-sortname-tag-type-.
/// </summary>
internal static string ArtistQueryParams {
get {
return ResourceManager.GetString("ArtistQueryParams", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to -arid-artist-artistname-creditname-comment-country-date-dur-format-isrc-number-position-primarytype-puid-qdur-recording-recordingaccent-reid-release-rgid--rid-secondarytype-status-tid-tnum-tracks-tracksrelease-tag-type-video-.
/// </summary>
internal static string RecordingQueryParams {
get {
return ResourceManager.GetString("RecordingQueryParams", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to -arid-artist-artistname-comment-creditname-primarytype-rgid-releasegroup-releasegroupaccent-releases-release-reid-secondarytype-status-tag-type-.
/// </summary>
internal static string ReleaseGroupQueryParams {
get {
return ResourceManager.GetString("ReleaseGroupQueryParams", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to -arid-artist-artistname-asin-barcode-catno-comment-country-creditname-date-discids-discidsmedium-format-laid-label-lang-mediums-primarytype-puid-quality-reid-release-releaseaccent-rgid-script-secondarytype-status-tag-tracks-tracksmedium-type-.
/// </summary>
internal static string ReleaseQueryParams {
get {
return ResourceManager.GetString("ReleaseQueryParams", resourceCulture);
}
}
}
}

132
src/Hqub.MusicBrainz.API/Resources/Constants.resx
Unescape View File

@ -1,132 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="ArtistQueryParams" xml:space="preserve">
<value>-area-beginarea-endarea-arid-artist-artistaccent-alias-begin-comment-country-end-ended-gender-ipi-sortname-tag-type-</value>
</data>
<data name="RecordingQueryParams" xml:space="preserve">
<value>-arid-artist-artistname-creditname-comment-country-date-dur-format-isrc-number-position-primarytype-puid-qdur-recording-recordingaccent-reid-release-rgid--rid-secondarytype-status-tid-tnum-tracks-tracksrelease-tag-type-video-</value>
</data>
<data name="ReleaseGroupQueryParams" xml:space="preserve">
<value>-arid-artist-artistname-comment-creditname-primarytype-rgid-releasegroup-releasegroupaccent-releases-release-reid-secondarytype-status-tag-type-</value>
</data>
<data name="ReleaseQueryParams" xml:space="preserve">
<value>-arid-artist-artistname-asin-barcode-catno-comment-country-creditname-date-discids-discidsmedium-format-laid-label-lang-mediums-primarytype-puid-quality-reid-release-releaseaccent-rgid-script-secondarytype-status-tag-tracks-tracksmedium-type-</value>
</data>
</root>

99
src/Hqub.MusicBrainz.API/Resources/Messages.Designer.cs generated
Unescape View File

@ -1,99 +0,0 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.34209
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Hqub.MusicBrainz.API.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Messages {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Messages() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Hqub.MusicBrainz.API.Resources.Messages", typeof(Messages).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to Query returned an empty result..
/// </summary>
internal static string EmptyStream {
get {
return ResourceManager.GetString("EmptyStream", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Key not supported ({0})..
/// </summary>
internal static string InvalidQueryParameter {
get {
return ResourceManager.GetString("InvalidQueryParameter", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Attribute &apos;{0}&apos; must be specified..
/// </summary>
internal static string MissingParameter {
get {
return ResourceManager.GetString("MissingParameter", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Webservice returned invalid response format..
/// </summary>
internal static string WrongResponseFormat {
get {
return ResourceManager.GetString("WrongResponseFormat", resourceCulture);
}
}
}
}

132
src/Hqub.MusicBrainz.API/Resources/Messages.resx
Unescape View File

@ -1,132 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="EmptyStream" xml:space="preserve">
<value>Query returned an empty result.</value>
</data>
<data name="InvalidQueryParameter" xml:space="preserve">
<value>Key not supported ({0}).</value>
</data>
<data name="MissingParameter" xml:space="preserve">
<value>Attribute '{0}' must be specified.</value>
</data>
<data name="WrongResponseFormat" xml:space="preserve">
<value>Webservice returned invalid response format.</value>
</data>
</root>

116
src/Hqub.MusicBrainz.API/WebRequestHelper.cs
Unescape View File

@ -1,116 +0,0 @@
using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Xml.Linq;
using System.Xml.Serialization;
namespace Hqub.MusicBrainz.API
{
internal static class WebRequestHelper
{
private const string WebServiceUrl = "http://musicbrainz.org/ws/2/";
private const string LookupTemplate = "{0}/{1}/?inc={2}";
private const string BrowseTemplate = "{0}?{1}={2}&limit={3}&offset={4}&inc={5}";
private const string SearchTemplate = "{0}?query={1}&limit={2}&offset={3}";
internal async static Task<T> GetAsync<T>(string url, bool withoutMetadata = true) where T : Entities.Entity
{
try
{
var client = CreateHttpClient(true, Configuration.Proxy);
return DeserializeStream<T>(await client.GetStreamAsync(url), withoutMetadata);
}
catch (Exception e)
{
if (Configuration.GenerateCommunicationThrow)
{
throw e;
}
}
return default(T);
}
/// <summary>
/// Creates a webservice lookup template.
/// </summary>
internal static string CreateLookupUrl(string entity, string mbid, string inc)
{
return string.Format("{0}{1}", WebServiceUrl, string.Format(LookupTemplate, entity, mbid, inc));
}
/// <summary>
/// Creates a webservice browse template.
/// </summary>
internal static string CreateBrowseTemplate(string entity, string relatedEntity, string mbid, int limit, int offset, string inc)
{
return string.Format("{0}{1}", WebServiceUrl, string.Format(BrowseTemplate, entity, relatedEntity, mbid, limit, offset, inc));
}
/// <summary>
/// Creates a webservice search template.
/// </summary>
internal static string CreateSearchTemplate(string entity, string query, int limit, int offset)
{
query = Uri.EscapeUriString(query);
return string.Format("{0}{1}", WebServiceUrl, string.Format(SearchTemplate, entity, query, limit, offset));
}
internal static T DeserializeStream<T>(Stream stream, bool withoutMetadata) where T : Entities.Entity
{
if (stream == null)
{
throw new NullReferenceException(Resources.Messages.EmptyStream);
}
var xml = XDocument.Load(stream);
var serialize = new XmlSerializer(typeof(T));
//Add extension namespace:
var ns = new XmlSerializerNamespaces();
ns.Add("ext", "http://musicbrainz.org/ns/ext#-2.0");
//check valid xml schema:
if (xml.Root == null || xml.Root.Name.LocalName != "metadata")
{
throw new NullReferenceException(Resources.Messages.WrongResponseFormat);
}
var node = withoutMetadata ? xml.Root.Elements().FirstOrDefault() : xml.Root;
if (node == null)
{
return default(T);
}
return (T)serialize.Deserialize(node.CreateReader());
}
private static HttpClient CreateHttpClient(bool automaticDecompression = true, IWebProxy proxy = null)
{
var handler = new HttpClientHandler();
if (proxy != null)
{
handler.Proxy = proxy;
handler.UseProxy = true;
}
if (automaticDecompression)
{
handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
var client = new HttpClient(handler);
client.DefaultRequestHeaders.Add("User-Agent", Configuration.UserAgent);
return client;
}
}
}

18
src/NzbDrone.sln
Unescape View File

@ -90,8 +90,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LogentriesNLog", "Logentrie
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CurlSharp", "ExternalModules\CurlSharp\CurlSharp\CurlSharp.csproj", "{74420A79-CC16-442C-8B1E-7C1B913844F0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hqub.MusicBrainz.API", "Hqub.MusicBrainz.API\Hqub.MusicBrainz.API.csproj", "{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -545,22 +543,6 @@ Global
{74420A79-CC16-442C-8B1E-7C1B913844F0}.Travis|Any CPU.Build.0 = Release|Any CPU
{74420A79-CC16-442C-8B1E-7C1B913844F0}.Travis|x86.ActiveCfg = Release|Any CPU
{74420A79-CC16-442C-8B1E-7C1B913844F0}.Travis|x86.Build.0 = Release|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Debug|Any CPU.Build.0 = Debug|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Debug|x86.ActiveCfg = Debug|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Debug|x86.Build.0 = Debug|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Mono|Any CPU.ActiveCfg = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Mono|Any CPU.Build.0 = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Mono|x86.ActiveCfg = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Mono|x86.Build.0 = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Release|Any CPU.ActiveCfg = Release|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Release|Any CPU.Build.0 = Release|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Release|x86.ActiveCfg = Release|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Release|x86.Build.0 = Release|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Travis|Any CPU.ActiveCfg = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Travis|Any CPU.Build.0 = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Travis|x86.ActiveCfg = Travis|Any CPU
{77832DED-EEFE-4DB9-94AF-B0BE02CEC356}.Travis|x86.Build.0 = Travis|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

Write Preview
Loading…
Cancel
Save