feat: use new monstercat api (#2)

Author: Florian Freikowski

README.md

@@ -65,11 +65,11 @@ import (
 
 func main() {
 	client := monstercat.NewClient()
-	releases, err := client.Releases("mix contest", "podcast", 5, 0)
+	catalog, err := client.GetCatalog("mix contest", "podcast", 5, 0)
 	if err != nil {
 		fmt.Printf("error: %s", err)
 		os.Exit(1)
 	}
-	fmt.Printf("releases: %+v", releases)
+	fmt.Printf("catalog: %+v", catalog)
 }
 ```

cmd/releases.go

@@ -29,7 +29,7 @@ var releasesCmd = &cobra.Command{
 	Use:   "releases",
 	Short: "releases returns a set of the most recent Monstercat releases",
 	Run: func(cmd *cobra.Command, args []string) {
-		releases, err := monstercat.NewClient().Releases(releasesSearch, releasesType, releasesLimit, releasesOffset)
+		releases, err := monstercat.NewClient().GetCatalog(releasesSearch, releasesType, releasesLimit, releasesOffset)
 		if err != nil {
 			fmt.Printf("error fetching releases: %s", err)
 			os.Exit(1)
@@ -38,10 +38,10 @@ var releasesCmd = &cobra.Command{
 		table := tablewriter.NewWriter(os.Stdout)
 		table.SetAutoWrapText(false)
 		table.SetHeader([]string{"Catalog ID", "Title", "Artist", "Type", "Release Date"})
-		table.SetCaption(true, fmt.Sprintf("%d of %d results", len(releases.Results), releases.Total))
+		table.SetCaption(true, fmt.Sprintf("%d of %d results", len(releases.Data), releases.Total))
 
-		for _, release := range releases.Results {
-			table.Append([]string{release.CatalogID, release.Title, release.Artist, string(release.Type), release.ReleaseDate.Format("2006-01-02")})
+		for _, release := range releases.Data {
+			table.Append([]string{release.Release.CatalogID, release.Title, release.ArtistsTitle, string(release.Release.Type), release.DebutDate.Format("2006-01-02")})
 		}
 		table.Render()
 	},

monstercat/catalog.go

@@ -0,0 +1,64 @@
+package monstercat
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// Catalog represents a list of releases from Monstercat API
+type Catalog struct {
+	Data   []CatalogItem `json:"Data"`
+	Total  int           `json:"Total"`
+	Limit  int           `json:"Limit"`
+	Offset int           `json:"Offset"`
+}
+
+// GetCatalog returns a set of releases containing the given search query, matching the given release type and being within the given range.
+// While limit and offset are required, you may leave search and releaseType empty to ignore those filters.
+func (client Client) GetCatalog(search string, releaseType string, limit int, offset int) (Catalog, error) {
+	catalog := Catalog{}
+
+	urlParameters := url.Values{}
+	urlParameters.Add("search", search)
+	urlParameters.Add("types[]", releaseType)
+	urlParameters.Add("limit", fmt.Sprintf("%d", limit))
+	urlParameters.Add("offset", fmt.Sprintf("%d", offset))
+
+	request, err := http.NewRequest("GET", fmt.Sprintf("%s?%s", endpointCatalog, urlParameters.Encode()), http.NoBody)
+	if err != nil {
+		return catalog, err
+	}
+	if client.IsLoggedIn() {
+		request.Header.Set("Cookie", fmt.Sprintf("%s=%s", authenticationCookieName, client.authenticationCookie))
+	}
+
+	httpClient := &http.Client{}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return catalog, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		message, err := io.ReadAll(response.Body)
+		if err != nil {
+			return catalog, fmt.Errorf("http error %d", response.StatusCode)
+		}
+		return catalog, fmt.Errorf("http error %d: %s", response.StatusCode, message)
+	}
+
+	err = json.NewDecoder(response.Body).Decode(&catalog)
+	if err != nil {
+		return catalog, err
+	}
+
+	return catalog, nil
+}
+
+// HasNextPage returns true if the release list contains more pages, false otherwise.
+func (catalog Catalog) HasNextPage() bool {
+	return (catalog.Offset + catalog.Limit) < catalog.Total
+}

monstercat/catalog_test.go

@@ -0,0 +1,79 @@
+package monstercat
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCatalog(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("", "", 10, 0)
+	assert.NoError(t, err)
+	assert.NotEmpty(t, catalog.Data)
+	assert.NotEqual(t, 0, catalog.Total)
+	assert.True(t, catalog.HasNextPage())
+}
+
+func TestCatalog_Search(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("mix", "", 10, 0)
+	assert.NoError(t, err)
+	assert.NotEmpty(t, catalog.Data)
+	assert.NotEqual(t, 0, catalog.Total)
+	assert.True(t, catalog.HasNextPage())
+}
+
+func TestCatalog_Search_NoResults(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("xxx not found xxx", "", 10, 0)
+	assert.NoError(t, err)
+	assert.Empty(t, catalog.Data)
+	assert.Equal(t, 0, catalog.Total)
+	assert.False(t, catalog.HasNextPage())
+}
+
+func TestCatalog_Type(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("", string(ReleaseTypeSingle), 10, 0)
+	assert.NoError(t, err)
+	assert.NotEmpty(t, catalog.Data)
+	assert.NotEqual(t, 0, catalog.Total)
+	assert.True(t, catalog.HasNextPage())
+}
+
+func TestCatalog_Type_NoResults(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("", "xxx not found", 10, 0)
+	assert.NoError(t, err)
+	assert.Empty(t, catalog.Data)
+	assert.Equal(t, 0, catalog.Total)
+	assert.False(t, catalog.HasNextPage())
+}
+
+func TestCatalog_Search_Type(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("mix", string(ReleaseTypeCompilation), 5, 0)
+	assert.NoError(t, err)
+	assert.NotEmpty(t, catalog.Data)
+	assert.NotEqual(t, 0, catalog.Total)
+	assert.True(t, catalog.HasNextPage())
+}
+
+func TestCatalogUntilEnd(t *testing.T) {
+	client := NewClient()
+
+	catalog, err := client.GetCatalog("", "", 100, 0)
+	assert.NoError(t, err)
+
+	for catalog.HasNextPage() {
+		catalog, err = client.GetCatalog("", "", catalog.Limit, catalog.Offset+catalog.Limit)
+		assert.NoError(t, err)
+	}
+}

monstercat/login.go

@@ -10,8 +10,8 @@ import (
 // Login performs a login request into your Monstercat account and stores the created authentication cookie on success for further requests
 func (client *Client) Login(email string, password string) error {
 	payload, err := json.Marshal(map[string]string{
-		"email":    email,
-		"password": password,
+		"Email":    email,
+		"Password": password,
 	})
 	if err != nil {
 		return err

monstercat/monstercat.go

@@ -3,9 +3,9 @@ package monstercat
 import "fmt"
 
 const (
-	endpointLogin           = "https://connect.monstercat.com/v2/signin"
-	endpointReleaseList     = "https://connect.monstercat.com/v2/releases"
-	endpointReleaseDownload = "https://connect.monstercat.com/v2/release/%s/download?format=%s"
+	endpointLogin           = "https://www.monstercat.com/api/sign-in"
+	endpointCatalog         = "https://www.monstercat.com/api/catalog/browse"
+	endpointReleaseDownload = "https://www.monstercat.com/api/release/%s/download?format=%s"
 
 	authenticationCookieName = "cid"
 )

monstercat/release.go

@@ -21,21 +21,26 @@ const (
 	ReleaseTypeSingle      ReleaseType = "Single"
 )
 
-// Release represents a single release from Monstercat API
-type Release struct {
-	ID          string      `json:"id"`
-	Title       string      `json:"title"`
-	Artist      string      `json:"artistsTitle"`
-	CatalogID   string      `json:"catalogId"`
-	ReleaseDate time.Time   `json:"releaseDate"`
-	Type        ReleaseType `json:"type"`
+// CatalogItem represents a single release from Monstercat API
+type CatalogItem struct {
+	ID           string    `json:"Id"`
+	Title        string    `json:"Title"`
+	ArtistsTitle string    `json:"ArtistsTitle"`
+	DebutDate    time.Time `json:"DebutDate"`
+	Release      Release   `json:"Release"`
+
+	GenrePrimary   string `json:"GenrePrimary"`
+	GenreSecondary string `json:"GenreSecondary"`
 
-	GenrePrimary   string `json:"genrePrimary"`
-	GenreSecondary string `json:"genreSecondary"`
+	Downloadable  bool `json:"Downloadable"`
+	InEarlyAccess bool `json:"InEarlyAccess"`
+	Streamable    bool `json:"Streamable"`
+}
 
-	Downloadable  bool `json:"downloadable"`
-	InEarlyAccess bool `json:"inEarlyAccess"`
-	Streamable    bool `json:"streamable"`
+type Release struct {
+	CatalogID   string      `json:"CatalogId"`
+	ReleaseDate time.Time   `json:"ReleaseDate"`
+	Type        ReleaseType `json:"Type"`
 }
 
 // DownloadFormat describes in what kind of formats we can download a release
@@ -49,12 +54,12 @@ const (
 )
 
 // DownloadRelease downloads the given release as ZIP file in the requested format and stores it at the given path
-func (client Client) DownloadRelease(release Release, downloadFormat DownloadFormat, downloadPath string) error {
+func (client Client) DownloadRelease(catalogItem CatalogItem, downloadFormat DownloadFormat, downloadPath string) error {
 	if !client.IsLoggedIn() {
 		return ErrorClientNotLoggedIn
 	}
 
-	request, err := http.NewRequest("GET", fmt.Sprintf(endpointReleaseDownload, release.ID, downloadFormat), http.NoBody)
+	request, err := http.NewRequest("GET", fmt.Sprintf(endpointReleaseDownload, catalogItem.ID, downloadFormat), http.NoBody)
 	if err != nil {
 		return err
 	}