feat: add missing fields for catalog item

Author: menzerath

README.md

@@ -27,7 +27,7 @@ Run a simple cli based on this project by downloading a [release](https://github
 Afterwards usage is as simple as this:
 
 ```bash
-$ ./monstercat releases --search="mix contest"
+$ ./monstercat catalog --search="mix contest"
 +------------+-------------------------------------------------+------------+---------+--------------+
 | CATALOG ID |                      TITLE                      |   ARTIST   |  TYPE   | RELEASE DATE |
 +------------+-------------------------------------------------+------------+---------+--------------+
@@ -65,7 +65,7 @@ import (
 
 func main() {
 	client := monstercat.NewClient()
-	catalog, err := client.GetCatalog("mix contest", "podcast", 5, 0)
+	catalog, err := client.Catalog("mix contest", "podcast", 5, 0)
 	if err != nil {
 		fmt.Printf("error: %s", err)
 		os.Exit(1)

cmd/catalog.go

@@ -0,0 +1,53 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/menzerath/monstercat-api/monstercat"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+)
+
+var (
+	catalogSearch string
+	catalogType   string
+	catalogLimit  int
+	catalogOffset int
+)
+
+func init() {
+	catalogCmd.Flags().StringVarP(&catalogSearch, "search", "s", "", "search query")
+	catalogCmd.Flags().StringVarP(&catalogType, "type", "t", "", "type of release")
+	catalogCmd.Flags().IntVar(&catalogLimit, "limit", 10, "limit number of catalog")
+	catalogCmd.Flags().IntVar(&catalogOffset, "offset", 0, "offset number of catalog")
+
+	rootCmd.AddCommand(catalogCmd)
+}
+
+var catalogCmd = &cobra.Command{
+	Use:   "catalog",
+	Short: "catalog returns a set of the most recent Monstercat catalog items",
+	Run: func(cmd *cobra.Command, args []string) {
+		catalog, err := monstercat.NewClient().Catalog(catalogSearch, catalogType, catalogLimit, catalogOffset)
+		if err != nil {
+			fmt.Printf("error fetching catalog: %s", err)
+			os.Exit(1)
+		}
+
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(false)
+		table.SetHeader([]string{"Title", "Artist", "Album", "Catalog ID", "Type", "Release Date"})
+		table.SetCaption(true, fmt.Sprintf("%d of %d results", len(catalog.Data), catalog.Total))
+
+		for _, item := range catalog.Data {
+			title := item.Title
+			if item.Version != "" {
+				title = fmt.Sprintf("%s (%s)", item.Title, item.Version)
+			}
+
+			table.Append([]string{title, item.ArtistsTitle, item.Release.Title, item.Release.CatalogID, string(item.Release.Type), item.DebutDate.Format("2006-01-02")})
+		}
+		table.Render()
+	},
+}

cmd/releases.go

@@ -8,22 +8,26 @@ import (
 	"net/url"
 )
 
-// Catalog represents a list of releases from Monstercat API
+// Catalog represents a list of catalog items 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.
+// Catalog returns a set of catalog items 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) {
+// TODO: add brands[], tags[] and genres[]
+func (client Client) Catalog(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("sort", "-date")         // TODO: make configurable + add values
+	urlParameters.Add("nogold", "false")       // TODO: make configurable
+	urlParameters.Add("onlyReleased", "false") // TODO: make configurable
 	urlParameters.Add("limit", fmt.Sprintf("%d", limit))
 	urlParameters.Add("offset", fmt.Sprintf("%d", offset))
 
@@ -58,7 +62,7 @@ func (client Client) GetCatalog(search string, releaseType string, limit int, of
 	return catalog, nil
 }
 
-// HasNextPage returns true if the release list contains more pages, false otherwise.
+// HasNextPage returns true if the catalog list contains more pages, false otherwise.
 func (catalog Catalog) HasNextPage() bool {
 	return (catalog.Offset + catalog.Limit) < catalog.Total
 }

monstercat/catalog.go

@@ -0,0 +1,66 @@
+package monstercat
+
+import (
+	"time"
+)
+
+// CatalogItem represents a single release from Monstercat API
+type CatalogItem struct {
+	ID           string    `json:"Id"`
+	ISRC         string    `json:"ISRC"`
+	Title        string    `json:"Title"`
+	Artists      []Artist  `json:"Artists"`
+	ArtistsTitle string    `json:"ArtistsTitle"`
+	DebutDate    time.Time `json:"DebutDate"`
+	Release      Release   `json:"Release"`
+	Tags         []string  `json:"Tags"`
+	Version      string    `json:"Version"`
+
+	Brand   string `json:"Brand"`
+	BrandID int    `json:"BrandId"`
+
+	BPM            float32 `json:"BPM"`
+	Duration       int     `json:"Duration"`
+	Explicit       bool    `json:"Explicit"`
+	GenrePrimary   string  `json:"GenrePrimary"`
+	GenreSecondary string  `json:"GenreSecondary"`
+
+	CreatorFriendly bool `json:"CreatorFriendly"`
+	Downloadable    bool `json:"Downloadable"`
+	InEarlyAccess   bool `json:"InEarlyAccess"`
+	Streamable      bool `json:"Streamable"`
+}
+
+// Artist describes a single artist of a CatalogItem
+type Artist struct {
+	ID   string `json:"Id"`
+	Name string `json:"Name"`
+	Role string `json:"Role"`
+	URI  string `json:"URI"`
+}
+
+// Release describes which release a CatalogItem belongs to
+type Release struct {
+	ArtistsTitle string      `json:"ArtistsTitle"`
+	CatalogID    string      `json:"CatalogId"`
+	Description  string      `json:"Description"`
+	ID           string      `json:"Id"`
+	ReleaseDate  time.Time   `json:"ReleaseDate"`
+	Title        string      `json:"Title"`
+	Type         ReleaseType `json:"Type"`
+	UPC          string      `json:"UPC"`
+	Version      string      `json:"Version"`
+}
+
+// ReleaseType describes what kind of release we are looking at
+type ReleaseType string
+
+// define all known release types
+const (
+	ReleaseTypeAlbum       ReleaseType = "Album"
+	ReleaseTypeCompilation ReleaseType = "Compilation"
+	ReleaseTypeEP          ReleaseType = "EP"
+	ReleaseTypeMixes       ReleaseType = "Mixes"
+	ReleaseTypePodcast     ReleaseType = "Podcast"
+	ReleaseTypeSingle      ReleaseType = "Single"
+)

monstercat/catalog_item.go

@@ -9,7 +9,7 @@ import (
 func TestCatalog(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("", "", 10, 0)
+	catalog, err := client.Catalog("", "", 10, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, catalog.Data)
 	assert.NotEqual(t, 0, catalog.Total)
@@ -19,7 +19,7 @@ func TestCatalog(t *testing.T) {
 func TestCatalog_Search(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("mix", "", 10, 0)
+	catalog, err := client.Catalog("mix", "", 10, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, catalog.Data)
 	assert.NotEqual(t, 0, catalog.Total)
@@ -29,7 +29,7 @@ func TestCatalog_Search(t *testing.T) {
 func TestCatalog_Search_NoResults(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("xxx not found xxx", "", 10, 0)
+	catalog, err := client.Catalog("xxx not found xxx", "", 10, 0)
 	assert.NoError(t, err)
 	assert.Empty(t, catalog.Data)
 	assert.Equal(t, 0, catalog.Total)
@@ -39,7 +39,7 @@ func TestCatalog_Search_NoResults(t *testing.T) {
 func TestCatalog_Type(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("", string(ReleaseTypeSingle), 10, 0)
+	catalog, err := client.Catalog("", string(ReleaseTypeSingle), 10, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, catalog.Data)
 	assert.NotEqual(t, 0, catalog.Total)
@@ -49,7 +49,7 @@ func TestCatalog_Type(t *testing.T) {
 func TestCatalog_Type_NoResults(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("", "xxx not found", 10, 0)
+	catalog, err := client.Catalog("", "xxx not found", 10, 0)
 	assert.NoError(t, err)
 	assert.Empty(t, catalog.Data)
 	assert.Equal(t, 0, catalog.Total)
@@ -59,7 +59,7 @@ func TestCatalog_Type_NoResults(t *testing.T) {
 func TestCatalog_Search_Type(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("mix", string(ReleaseTypeCompilation), 5, 0)
+	catalog, err := client.Catalog("mix", string(ReleaseTypeCompilation), 5, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, catalog.Data)
 	assert.NotEqual(t, 0, catalog.Total)
@@ -69,11 +69,11 @@ func TestCatalog_Search_Type(t *testing.T) {
 func TestCatalogUntilEnd(t *testing.T) {
 	client := NewClient()
 
-	catalog, err := client.GetCatalog("", "", 100, 0)
+	catalog, err := client.Catalog("", "", 100, 0)
 	assert.NoError(t, err)
 
 	for catalog.HasNextPage() {
-		catalog, err = client.GetCatalog("", "", catalog.Limit, catalog.Offset+catalog.Limit)
+		catalog, err = client.Catalog("", "", catalog.Limit, catalog.Offset+catalog.Limit)
 		assert.NoError(t, err)
 	}
 }

monstercat/catalog_test.go

@@ -0,0 +1,62 @@
+package monstercat
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+)
+
+// DownloadFormat describes in what kind of formats we can download a release
+type DownloadFormat string
+
+// define all known download formats
+const (
+	DownloadReleaseFormatFlac = "flac"
+	DownloadReleaseFormatMP3  = "mp3_320"
+	DownloadReleaseFormatWAV  = "wav"
+)
+
+// 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 {
+	if !client.IsLoggedIn() {
+		return ErrorClientNotLoggedIn
+	}
+
+	request, err := http.NewRequest("GET", fmt.Sprintf(endpointDownloadRelease, release.ID, downloadFormat), http.NoBody)
+	if err != nil {
+		return 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 err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		message, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("http error %d", response.StatusCode)
+		}
+		return fmt.Errorf("http error %d: %s", response.StatusCode, message)
+	}
+
+	// create and save file
+	targetFile, err := os.Create(downloadPath)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(targetFile, response.Body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// TODO: add download function for a single catalog item

monstercat/download.go

@@ -9,7 +9,7 @@ import (
 func Test_DownloadRelease(t *testing.T) {
 	client := NewClient()
 
-	err := client.DownloadRelease(CatalogItem{}, ReleaseDownloadFormatMP3, "./file.mp3")
+	err := client.DownloadRelease(Release{}, DownloadReleaseFormatMP3, "./file.zip")
 	assert.Error(t, err)
 	assert.Equal(t, ErrorClientNotLoggedIn, err)
 }

monstercat/release_test.go monstercat/download_test.gomonstercat/release_test.go renamed to monstercat/download_test.go

@@ -3,9 +3,10 @@ package monstercat
 import "fmt"
 
 const (
-	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"
+	endpointLogin   = "https://www.monstercat.com/api/sign-in"
+	endpointCatalog = "https://www.monstercat.com/api/catalog/browse"
+
+	endpointDownloadRelease = "https://www.monstercat.com/api/release/%s/download?format=%s"
 
 	authenticationCookieName = "cid"
 )