Move functions into their own, separate files & add docs

crunchyroll.go

@@ -8,8 +8,6 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"regexp"
-	"strconv"
 	"strings"
 )
 
@@ -38,30 +36,6 @@ const (
 	MediaTypeMovie            = "movie_listing"
 )
 
-// BrowseSortType represents a sort type to sort Crunchyroll.Browse items after.
-type BrowseSortType string
-
-const (
-	BrowseSortPopularity   BrowseSortType = "popularity"
-	BrowseSortNewlyAdded                  = "newly_added"
-	BrowseSortAlphabetical                = "alphabetical"
-)
-
-// WatchlistLanguageType represents a filter type to filter Crunchyroll.WatchList entries after.
-type WatchlistLanguageType int
-
-const (
-	WatchlistLanguageSubbed WatchlistLanguageType = iota + 1
-	WatchlistLanguageDubbed
-)
-
-type WatchlistContentType string
-
-const (
-	WatchlistContentSeries WatchlistContentType = "series"
-	WatchlistContentMovies                      = "movie_listing"
-)
-
 type Crunchyroll struct {
 	// Client is the http.Client to perform all requests over.
 	Client *http.Client
@@ -95,30 +69,6 @@ type Crunchyroll struct {
 	cache bool
 }
 
-// BrowseOptions represents options for browsing the crunchyroll catalog.
-type BrowseOptions struct {
-	// Categories specifies the categories of the entries.
-	Categories []string `param:"categories"`
-
-	// IsDubbed specifies whether the entries should be dubbed.
-	IsDubbed bool `param:"is_dubbed"`
-
-	// IsSubbed specifies whether the entries should be subbed.
-	IsSubbed bool `param:"is_subbed"`
-
-	// Simulcast specifies a particular simulcast season by id in which the entries have been aired.
-	Simulcast string `param:"season_tag"`
-
-	// Sort specifies how the entries should be sorted.
-	Sort BrowseSortType `param:"sort_by"`
-
-	// Start specifies the index from which the entries should be returned.
-	Start uint `param:"start"`
-
-	// Type specifies the media type of the entries.
-	Type MediaType `param:"type"`
-}
-
 type loginResponse struct {
 	AccessToken string `json:"access_token"`
 	ExpiresIn   int    `json:"expires_in"`
@@ -377,577 +327,3 @@ func (c *Crunchyroll) IsCaching() bool {
 func (c *Crunchyroll) SetCaching(caching bool) {
 	c.cache = caching
 }
-
-// Search searches a query and returns all found series and movies within the given limit.
-func (c *Crunchyroll) Search(query string, limit uint) (s []*Series, m []*Movie, err error) {
-	searchEndpoint := fmt.Sprintf("https://beta-api.crunchyroll.com/content/v1/search?q=%s&n=%d&type=&locale=%s",
-		query, limit, c.Locale)
-	resp, err := c.request(searchEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse 'search' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		item := item.(map[string]interface{})
-		if item["total"].(float64) > 0 {
-			switch item["type"] {
-			case "series":
-				for _, series := range item["items"].([]interface{}) {
-					series2 := &Series{
-						crunchy: c,
-					}
-					if err := decodeMapToStruct(series, series2); err != nil {
-						return nil, nil, err
-					}
-					if err := decodeMapToStruct(series.(map[string]interface{})["series_metadata"].(map[string]interface{}), series2); err != nil {
-						return nil, nil, err
-					}
-
-					s = append(s, series2)
-				}
-			case "movie_listing":
-				for _, movie := range item["items"].([]interface{}) {
-					movie2 := &Movie{
-						crunchy: c,
-					}
-					if err := decodeMapToStruct(movie, movie2); err != nil {
-						return nil, nil, err
-					}
-
-					m = append(m, movie2)
-				}
-			}
-		}
-	}
-
-	return s, m, nil
-}
-
-// FindVideoByName finds a Video (Season or Movie) by its name.
-// Use this in combination with ParseVideoURL and hand over the corresponding results
-// to this function.
-//
-// Deprecated: Use Search instead. The first result sometimes isn't the correct one
-// so this function is inaccurate in some cases.
-// See https://github.com/ByteDream/crunchyroll-go/issues/22 for more information.
-func (c *Crunchyroll) FindVideoByName(seriesName string) (Video, error) {
-	s, m, err := c.Search(seriesName, 1)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(s) > 0 {
-		return s[0], nil
-	} else if len(m) > 0 {
-		return m[0], nil
-	}
-	return nil, fmt.Errorf("no series or movie could be found")
-}
-
-// FindEpisodeByName finds an episode by its crunchyroll series name and episode title.
-// Use this in combination with ParseEpisodeURL and hand over the corresponding results
-// to this function.
-func (c *Crunchyroll) FindEpisodeByName(seriesName, episodeTitle string) ([]*Episode, error) {
-	series, _, err := c.Search(seriesName, 5)
-	if err != nil {
-		return nil, err
-	}
-
-	var matchingEpisodes []*Episode
-	for _, s := range series {
-		seasons, err := s.Seasons()
-		if err != nil {
-			return nil, err
-		}
-
-		for _, season := range seasons {
-			episodes, err := season.Episodes()
-			if err != nil {
-				return nil, err
-			}
-			for _, episode := range episodes {
-				if episode.SlugTitle == episodeTitle {
-					matchingEpisodes = append(matchingEpisodes, episode)
-				}
-			}
-		}
-	}
-
-	return matchingEpisodes, nil
-}
-
-// ParseVideoURL tries to extract the crunchyroll series / movie name out of the given url.
-//
-// Deprecated: Crunchyroll classic urls are sometimes not safe to use, use ParseBetaSeriesURL
-// if possible since beta url are always safe to use.
-// The method will stay in the library until only beta urls are supported by crunchyroll itself.
-func ParseVideoURL(url string) (seriesName string, ok bool) {
-	pattern := regexp.MustCompile(`(?m)^https?://(www\.)?crunchyroll\.com(/\w{2}(-\w{2})?)?/(?P<series>[^/]+)(/videos)?/?$`)
-	if urlMatch := pattern.FindAllStringSubmatch(url, -1); len(urlMatch) != 0 {
-		groups := regexGroups(urlMatch, pattern.SubexpNames()...)
-		seriesName = groups["series"]
-
-		if seriesName != "" {
-			ok = true
-		}
-	}
-	return
-}
-
-// ParseEpisodeURL tries to extract the crunchyroll series name, title, episode number and web id out of the given crunchyroll url
-// Note that the episode number can be misleading. For example if an episode has the episode number 23.5 (slime isekai)
-// the episode number will be 235.
-//
-// Deprecated: Crunchyroll classic urls are sometimes not safe to use, use ParseBetaEpisodeURL
-// if possible since beta url are always safe to use.
-// The method will stay in the library until only beta urls are supported by crunchyroll itself.
-func ParseEpisodeURL(url string) (seriesName, title string, episodeNumber int, webId int, ok bool) {
-	pattern := regexp.MustCompile(`(?m)^https?://(www\.)?crunchyroll\.com(/\w{2}(-\w{2})?)?/(?P<series>[^/]+)/episode-(?P<number>\d+)-(?P<title>.+)-(?P<webId>\d+).*`)
-	if urlMatch := pattern.FindAllStringSubmatch(url, -1); len(urlMatch) != 0 {
-		groups := regexGroups(urlMatch, pattern.SubexpNames()...)
-		seriesName = groups["series"]
-		episodeNumber, _ = strconv.Atoi(groups["number"])
-		title = groups["title"]
-		webId, _ = strconv.Atoi(groups["webId"])
-
-		if seriesName != "" && title != "" && webId != 0 {
-			ok = true
-		}
-	}
-	return
-}
-
-// ParseBetaSeriesURL tries to extract the season id of the given crunchyroll beta url, pointing to a season.
-func ParseBetaSeriesURL(url string) (seasonId string, ok bool) {
-	pattern := regexp.MustCompile(`(?m)^https?://(www\.)?beta\.crunchyroll\.com/(\w{2}/)?series/(?P<seasonId>\w+).*`)
-	if urlMatch := pattern.FindAllStringSubmatch(url, -1); len(urlMatch) != 0 {
-		groups := regexGroups(urlMatch, pattern.SubexpNames()...)
-		seasonId = groups["seasonId"]
-		ok = true
-	}
-	return
-}
-
-// ParseBetaEpisodeURL tries to extract the episode id of the given crunchyroll beta url, pointing to an episode.
-func ParseBetaEpisodeURL(url string) (episodeId string, ok bool) {
-	pattern := regexp.MustCompile(`(?m)^https?://(www\.)?beta\.crunchyroll\.com/(\w{2}/)?watch/(?P<episodeId>\w+).*`)
-	if urlMatch := pattern.FindAllStringSubmatch(url, -1); len(urlMatch) != 0 {
-		groups := regexGroups(urlMatch, pattern.SubexpNames()...)
-		episodeId = groups["episodeId"]
-		ok = true
-	}
-	return
-}
-
-// Browse browses the crunchyroll catalog filtered by the specified options and returns all found series and movies within the given limit.
-func (c *Crunchyroll) Browse(options BrowseOptions, limit uint) (s []*Series, m []*Movie, err error) {
-	query, err := encodeStructToQueryValues(options)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	browseEndpoint := fmt.Sprintf("https://beta-api.crunchyroll.com/content/v1/browse?%s&n=%d&locale=%s",
-		query, limit, c.Locale)
-	resp, err := c.request(browseEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse 'browse' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		switch item.(map[string]interface{})["type"] {
-		case "series":
-			series := &Series{
-				crunchy: c,
-			}
-			if err := decodeMapToStruct(item, series); err != nil {
-				return nil, nil, err
-			}
-			if err := decodeMapToStruct(item.(map[string]interface{})["series_metadata"].(map[string]interface{}), series); err != nil {
-				return nil, nil, err
-			}
-
-			s = append(s, series)
-		case "movie_listing":
-			movie := &Movie{
-				crunchy: c,
-			}
-			if err := decodeMapToStruct(item, movie); err != nil {
-				return nil, nil, err
-			}
-
-			m = append(m, movie)
-		}
-	}
-
-	return s, m, nil
-}
-
-// Categories returns all available categories and possible subcategories.
-func (c *Crunchyroll) Categories(includeSubcategories bool) (ca []*Category, err error) {
-	tenantCategoriesEndpoint := fmt.Sprintf("https://beta.crunchyroll.com/content/v1/tenant_categories?include_subcategories=%t&locale=%s",
-		includeSubcategories, c.Locale)
-	resp, err := c.request(tenantCategoriesEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, fmt.Errorf("failed to parse 'tenant_categories' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		category := &Category{}
-		if err := decodeMapToStruct(item, category); err != nil {
-			return nil, err
-		}
-
-		ca = append(ca, category)
-	}
-
-	return ca, nil
-}
-
-// Simulcasts returns all available simulcast seasons for the current locale.
-func (c *Crunchyroll) Simulcasts() (s []*Simulcast, err error) {
-	seasonListEndpoint := fmt.Sprintf("https://beta.crunchyroll.com/content/v1/season_list?locale=%s", c.Locale)
-	resp, err := c.request(seasonListEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, fmt.Errorf("failed to parse 'season_list' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		simulcast := &Simulcast{}
-		if err := decodeMapToStruct(item, simulcast); err != nil {
-			return nil, err
-		}
-
-		s = append(s, simulcast)
-	}
-
-	return s, nil
-}
-
-// News returns the top and latest news from crunchyroll for the current locale within the given limits.
-func (c *Crunchyroll) News(topLimit uint, latestLimit uint) (t []*News, l []*News, err error) {
-	newsFeedEndpoint := fmt.Sprintf("https://beta.crunchyroll.com/content/v1/news_feed?top_news_n=%d&latest_news_n=%d&locale=%s",
-		topLimit, latestLimit, c.Locale)
-	resp, err := c.request(newsFeedEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse 'news_feed' response: %w", err)
-	}
-
-	topNews := jsonBody["top_news"].(map[string]interface{})
-	for _, item := range topNews["items"].([]interface{}) {
-		topNews := &News{}
-		if err := decodeMapToStruct(item, topNews); err != nil {
-			return nil, nil, err
-		}
-
-		t = append(t, topNews)
-	}
-
-	latestNews := jsonBody["latest_news"].(map[string]interface{})
-	for _, item := range latestNews["items"].([]interface{}) {
-		latestNews := &News{}
-		if err := decodeMapToStruct(item, latestNews); err != nil {
-			return nil, nil, err
-		}
-
-		l = append(l, latestNews)
-	}
-
-	return t, l, nil
-}
-
-// Recommendations returns series and movie recommendations from crunchyroll based on the currently logged in account within the given limit.
-func (c *Crunchyroll) Recommendations(limit uint) (s []*Series, m []*Movie, err error) {
-	recommendationsEndpoint := fmt.Sprintf("https://beta-api.crunchyroll.com/content/v1/%s/recommendations?n=%d&locale=%s",
-		c.Config.AccountID, limit, c.Locale)
-	resp, err := c.request(recommendationsEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse 'recommendations' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		switch item.(map[string]interface{})["type"] {
-		case "series":
-			series := &Series{
-				crunchy: c,
-			}
-			if err := decodeMapToStruct(item, series); err != nil {
-				return nil, nil, err
-			}
-			if err := decodeMapToStruct(item.(map[string]interface{})["series_metadata"].(map[string]interface{}), series); err != nil {
-				return nil, nil, err
-			}
-
-			s = append(s, series)
-		case "movie_listing":
-			movie := &Movie{
-				crunchy: c,
-			}
-			if err := decodeMapToStruct(item, movie); err != nil {
-				return nil, nil, err
-			}
-
-			m = append(m, movie)
-		}
-	}
-
-	return s, m, nil
-}
-
-// UpNext returns the episodes that are up next based on the currently logged in account within the given limit.
-func (c *Crunchyroll) UpNext(limit uint) (e []*Episode, err error) {
-	upNextAccountEndpoint := fmt.Sprintf("https://beta-api.crunchyroll.com/content/v1/%s/up_next_account?n=%d&locale=%s",
-		c.Config.AccountID, limit, c.Locale)
-	resp, err := c.request(upNextAccountEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, fmt.Errorf("failed to parse 'up_next_account' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		panel := item.(map[string]interface{})["panel"]
-
-		episode := &Episode{
-			crunchy: c,
-		}
-		if err := decodeMapToStruct(panel, episode); err != nil {
-			return nil, err
-		}
-
-		e = append(e, episode)
-	}
-
-	return e, nil
-}
-
-// SimilarTo returns similar series and movies according to crunchyroll to the one specified by id within the given limit.
-func (c *Crunchyroll) SimilarTo(id string, limit uint) (s []*Series, m []*Movie, err error) {
-	similarToEndpoint := fmt.Sprintf("https://beta-api.crunchyroll.com/content/v1/%s/similar_to?guid=%s&n=%d&locale=%s",
-		c.Config.AccountID, id, limit, c.Locale)
-	resp, err := c.request(similarToEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse 'similar_to' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		switch item.(map[string]interface{})["type"] {
-		case "series":
-			series := &Series{
-				crunchy: c,
-			}
-			if err := decodeMapToStruct(item, series); err != nil {
-				return nil, nil, err
-			}
-			if err := decodeMapToStruct(item.(map[string]interface{})["series_metadata"].(map[string]interface{}), series); err != nil {
-				return nil, nil, err
-			}
-
-			s = append(s, series)
-		case "movie_listing":
-			movie := &Movie{
-				crunchy: c,
-			}
-			if err := decodeMapToStruct(item, movie); err != nil {
-				return nil, nil, err
-			}
-
-			m = append(m, movie)
-		}
-	}
-
-	return s, m, nil
-}
-
-// WatchHistory returns the history of watched episodes based on the currently logged in account from the given page with the given size.
-func (c *Crunchyroll) WatchHistory(page uint, size uint) (e []*HistoryEpisode, err error) {
-	watchHistoryEndpoint := fmt.Sprintf("https://beta-api.crunchyroll.com/content/v1/watch-history/%s?page=%d&page_size=%d&locale=%s",
-		c.Config.AccountID, page, size, c.Locale)
-	resp, err := c.request(watchHistoryEndpoint, http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	if err = json.NewDecoder(resp.Body).Decode(&jsonBody); err != nil {
-		return nil, fmt.Errorf("failed to parse 'watch-history' response: %w", err)
-	}
-
-	for _, item := range jsonBody["items"].([]interface{}) {
-		panel := item.(map[string]interface{})["panel"]
-
-		episode := &Episode{
-			crunchy: c,
-		}
-		if err := decodeMapToStruct(panel, episode); err != nil {
-			return nil, err
-		}
-
-		historyEpisode := &HistoryEpisode{
-			Episode: episode,
-		}
-		if err := decodeMapToStruct(item, historyEpisode); err != nil {
-			return nil, err
-		}
-
-		e = append(e, historyEpisode)
-	}
-
-	return e, nil
-}
-
-type WatchlistOptions struct {
-	// OrderAsc specified whether the results should be order ascending or descending.
-	OrderAsc bool
-
-	// OnlyFavorites specifies whether only episodes which are marked as favorite should be returned.
-	OnlyFavorites bool
-
-	// LanguageType specifies whether returning episodes should be only subbed or dubbed.
-	LanguageType WatchlistLanguageType
-
-	// ContentType specified whether returning videos should only be series episodes or movies.
-	// But tbh all movies I've searched on crunchy were flagged as series too, so this
-	// parameter is kinda useless.
-	ContentType WatchlistContentType
-}
-
-func (c *Crunchyroll) Watchlist(options WatchlistOptions, limit uint) ([]*WatchlistEntry, error) {
-	values := url.Values{}
-	if options.OrderAsc {
-		values.Set("order", "asc")
-	} else {
-		values.Set("order", "desc")
-	}
-	if options.OnlyFavorites {
-		values.Set("only_favorites", "true")
-	}
-	switch options.LanguageType {
-	case WatchlistLanguageSubbed:
-		values.Set("is_subbed", "true")
-	case WatchlistLanguageDubbed:
-		values.Set("is_dubbed", "true")
-	}
-	values.Set("n", strconv.Itoa(int(limit)))
-	values.Set("locale", string(c.Locale))
-
-	endpoint := fmt.Sprintf("https://beta.crunchyroll.com/content/v1/%s/watchlist?%s", c.Config.AccountID, values.Encode())
-	resp, err := c.request(endpoint, http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var jsonBody map[string]interface{}
-	json.NewDecoder(resp.Body).Decode(&jsonBody)
-
-	var watchlistEntries []*WatchlistEntry
-	if err := decodeMapToStruct(jsonBody["items"], &watchlistEntries); err != nil {
-		return nil, err
-	}
-
-	for _, entry := range watchlistEntries {
-		switch entry.Panel.Type {
-		case WatchlistEntryEpisode:
-			entry.Panel.EpisodeMetadata.crunchy = c
-		case WatchlistEntrySeries:
-			entry.Panel.SeriesMetadata.crunchy = c
-		}
-	}
-
-	return watchlistEntries, nil
-}
-
-func (c *Crunchyroll) CrunchyLists() (*CrunchyLists, error) {
-	endpoint := fmt.Sprintf("https://beta.crunchyroll.com/content/v1/custom-lists/%s?locale=%s", c.Config.AccountID, c.Locale)
-	resp, err := c.request(endpoint, http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	crunchyLists := &CrunchyLists{
-		crunchy: c,
-	}
-	json.NewDecoder(resp.Body).Decode(crunchyLists)
-	for _, item := range crunchyLists.Items {
-		item.crunchy = c
-	}
-
-	return crunchyLists, nil
-}
-
-// Account returns information about the currently logged in crunchyroll account.
-func (c *Crunchyroll) Account() (*Account, error) {
-	resp, err := c.request("https://beta.crunchyroll.com/accounts/v1/me", http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	account := &Account{
-		crunchy: c,
-	}
-
-	if err = json.NewDecoder(resp.Body).Decode(&account); err != nil {
-		return nil, fmt.Errorf("failed to parse 'me' response: %w", err)
-	}
-
-	resp, err = c.request("https://beta.crunchyroll.com/accounts/v1/me/profile", http.MethodGet)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if err = json.NewDecoder(resp.Body).Decode(&account); err != nil {
-		return nil, fmt.Errorf("failed to parse 'profile' response: %w", err)
-	}
-
-	return account, nil
-}