goyomi/sources/base/mmrcms/mmrcms.go

// Package mmrcms implements the MMRCMS (MangaReaderCMS) base.
// GET {base}/filterList?page={n}&sortBy=views; POST search.
package mmrcms

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"

	"goyomi/internal/httpclient"
	"goyomi/internal/source"
	"goyomi/sources/base/util"
)

type Config struct {
	Name    string
	BaseURL string
	Lang    string
}

type mangaDTO struct {
	ID        string `json:"id"`
	Slug      string `json:"slug"`
	Title     string `json:"title"`
	Image     string `json:"image"`
}

type Source struct {
	cfg    Config
	client *httpclient.Client
	id     int64
}

func New(cfg Config) *Source {
	c := httpclient.NewClient(httpclient.WithRateLimit(1, 2))
	return &Source{cfg: cfg, client: c, id: source.GenerateSourceID(cfg.Name, cfg.Lang)}
}

func (s *Source) ID() int64           { return s.id }
func (s *Source) Name() string        { return s.cfg.Name }
func (s *Source) Lang() string        { return s.cfg.Lang }
func (s *Source) SupportsLatest() bool { return true }

func (s *Source) base() string { return strings.TrimRight(s.cfg.BaseURL, "/") }

func (s *Source) getJSON(ctx context.Context, rawURL string, out any) error {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
	if err != nil {
		return err
	}
	resp, err := s.client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("mmrcms: HTTP %d", resp.StatusCode)
	}
	body, _ := io.ReadAll(resp.Body)
	return json.Unmarshal(body, out)
}

func (s *Source) toSManga(m mangaDTO) source.SManga {
	slug := m.Slug
	if slug == "" {
		slug = m.ID
	}
	return source.SManga{
		URL:          fmt.Sprintf("/manga/%s", slug),
		Title:        m.Title,
		ThumbnailURL: util.AbsURL(s.cfg.BaseURL, m.Image),
	}
}

func (s *Source) fetchList(ctx context.Context, page int, sortBy string) (source.MangasPage, error) {
	u := fmt.Sprintf("%s/filterList?page=%d&sortBy=%s&asc=false", s.base(), page, sortBy)
	var result []mangaDTO
	if err := s.getJSON(ctx, u, &result); err != nil {
		return source.MangasPage{}, err
	}
	mangas := make([]source.SManga, len(result))
	for i, m := range result {
		mangas[i] = s.toSManga(m)
	}
	return source.MangasPage{Mangas: mangas, HasNextPage: len(result) >= 20}, nil
}

func (s *Source) GetPopularManga(page int) (source.MangasPage, error) {
	return s.fetchList(context.Background(), page, "views")
}
func (s *Source) GetLatestUpdates(page int) (source.MangasPage, error) {
	return s.fetchList(context.Background(), page, "last_chapter_date")
}

func (s *Source) GetSearchManga(page int, query string, filters []source.Filter) (source.MangasPage, error) {
	u := fmt.Sprintf("%s/search?query=%s", s.base(), query)
	var result struct {
		Suggestions []struct {
			Value string `json:"value"`
			Data  string `json:"data"`
		} `json:"suggestions"`
	}
	if err := s.getJSON(context.Background(), u, &result); err != nil {
		return source.MangasPage{}, err
	}
	var mangas []source.SManga
	for _, s2 := range result.Suggestions {
		mangas = append(mangas, source.SManga{
			URL:   fmt.Sprintf("/manga/%s", s2.Data),
			Title: s2.Value,
		})
	}
	return source.MangasPage{Mangas: mangas, HasNextPage: false}, nil
}

func (s *Source) GetMangaDetails(manga source.SManga) (source.SManga, error) {
	slug := util.SlugFromURL(manga.URL)
	var result struct {
		Title       string `json:"title"`
		Image       string `json:"image"`
		Description string `json:"description"`
		Author      string `json:"author"`
		Status      string `json:"status"`
		Categories  []struct{ Name string `json:"name"` } `json:"categories"`
	}
	if err := s.getJSON(context.Background(), fmt.Sprintf("%s/manga/%s", s.base(), slug), &result); err != nil {
		return manga, err
	}
	genres := make([]string, len(result.Categories))
	for i, c := range result.Categories {
		genres[i] = c.Name
	}
	return source.SManga{
		URL:          manga.URL,
		Title:        result.Title,
		Author:       result.Author,
		Description:  result.Description,
		Genre:        strings.Join(genres, ", "),
		Status:       util.StatusFromString(result.Status),
		ThumbnailURL: util.AbsURL(s.cfg.BaseURL, result.Image),
	}, nil
}

func (s *Source) GetChapterList(manga source.SManga) ([]source.SChapter, error) {
	slug := util.SlugFromURL(manga.URL)
	var result []struct {
		Slug string  `json:"slug"`
		Name string  `json:"title"`
		Date string  `json:"date"`
	}
	if err := s.getJSON(context.Background(), fmt.Sprintf("%s/manga/%s/chapters", s.base(), slug), &result); err != nil {
		return nil, err
	}
	chapters := make([]source.SChapter, len(result))
	for i, ch := range result {
		chapters[i] = source.SChapter{
			URL:        fmt.Sprintf("/manga/%s/%s", slug, ch.Slug),
			Name:       ch.Name,
			DateUpload: util.ParseAbsoluteDate(ch.Date, "2006-01-02"),
		}
	}
	return chapters, nil
}

func (s *Source) GetPageList(chapter source.SChapter) ([]source.Page, error) {
	var result struct {
		Images []string `json:"images"`
	}
	if err := s.getJSON(context.Background(), util.AbsURL(s.cfg.BaseURL, chapter.URL), &result); err != nil {
		return nil, err
	}
	pages := make([]source.Page, len(result.Images))
	for i, img := range result.Images {
		pages[i] = source.Page{Index: i, ImageURL: util.AbsURL(s.cfg.BaseURL, img)}
	}
	return pages, nil
}

func (s *Source) GetImageURL(page source.Page) (string, error) { return page.ImageURL, nil }
func (s *Source) GetFilterList() []source.Filter               { return nil }