Achmad
214 lines
5.8 KiB
Go
Executable File
214 lines
5.8 KiB
Go
Executable File
// Package gravureblogger implements the GravureBlogger base.
|
|
// Uses Google Blogger JSON feed API: GET {base}/feeds/posts/default?alt=json&...
|
|
package gravureblogger
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/PuerkitoBio/goquery"
|
|
|
|
"goyomi/internal/httpclient"
|
|
"goyomi/internal/source"
|
|
"goyomi/sources/base/util"
|
|
)
|
|
|
|
const maxResults = 30
|
|
|
|
type Config struct {
|
|
Name string
|
|
BaseURL string
|
|
Lang string
|
|
}
|
|
|
|
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 false }
|
|
|
|
func (s *Source) base() string { return strings.TrimRight(s.cfg.BaseURL, "/") }
|
|
|
|
// Blogger JSON DTOs
|
|
type bloggerDTO struct {
|
|
Feed bloggerFeedDTO `json:"feed"`
|
|
}
|
|
type bloggerFeedDTO struct {
|
|
Category []bloggerCategoryDTO `json:"category"`
|
|
Entry []bloggerEntryDTO `json:"entry"`
|
|
}
|
|
type bloggerCategoryDTO struct {
|
|
Term string `json:"term"`
|
|
}
|
|
type bloggerEntryDTO struct {
|
|
Title bloggerTextDTO `json:"title"`
|
|
Published bloggerTextDTO `json:"published"`
|
|
Content bloggerTextDTO `json:"content"`
|
|
Link []bloggerLinkDTO `json:"link"`
|
|
Category []bloggerCategoryDTO `json:"category"`
|
|
}
|
|
type bloggerLinkDTO struct {
|
|
Rel string `json:"rel"`
|
|
Href string `json:"href"`
|
|
}
|
|
type bloggerTextDTO struct {
|
|
T string `json:"$t"`
|
|
}
|
|
|
|
func (s *Source) fetchFeed(ctx context.Context, page int, query string) (source.MangasPage, error) {
|
|
startIndex := maxResults*(page-1) + 1
|
|
u := fmt.Sprintf("%s/feeds/posts/default?alt=json&max-results=%d&start-index=%d",
|
|
s.base(), maxResults, startIndex)
|
|
if query != "" {
|
|
u += "&q=" + query
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
|
|
if err != nil {
|
|
return source.MangasPage{}, err
|
|
}
|
|
req.Header.Set("Referer", s.cfg.BaseURL+"/")
|
|
resp, err := s.client.Do(req)
|
|
if err != nil {
|
|
return source.MangasPage{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
return source.MangasPage{}, fmt.Errorf("gravureblogger: HTTP %d", resp.StatusCode)
|
|
}
|
|
body, _ := io.ReadAll(resp.Body)
|
|
var data bloggerDTO
|
|
if err := json.Unmarshal(body, &data); err != nil {
|
|
return source.MangasPage{}, err
|
|
}
|
|
|
|
var mangas []source.SManga
|
|
for _, entry := range data.Feed.Entry {
|
|
altLink := ""
|
|
for _, l := range entry.Link {
|
|
if l.Rel == "alternate" {
|
|
altLink = l.Href
|
|
break
|
|
}
|
|
}
|
|
if altLink == "" {
|
|
continue
|
|
}
|
|
// Store relative path + "#published" for date retrieval
|
|
relURL := util.AbsURL(s.cfg.BaseURL, altLink)
|
|
mangaURL := relURL + "#" + entry.Published.T
|
|
|
|
// Extract thumbnail from HTML content
|
|
thumbnail := ""
|
|
if doc, err := goquery.NewDocumentFromReader(strings.NewReader("<body>" + entry.Content.T + "</body>")); err == nil {
|
|
doc.Find("img").First().Each(func(_ int, img *goquery.Selection) {
|
|
thumbnail, _ = img.Attr("src")
|
|
})
|
|
}
|
|
|
|
var genres []string
|
|
for _, cat := range entry.Category {
|
|
if cat.Term != "" {
|
|
genres = append(genres, cat.Term)
|
|
}
|
|
}
|
|
|
|
mangas = append(mangas, source.SManga{
|
|
URL: mangaURL,
|
|
Title: entry.Title.T,
|
|
ThumbnailURL: thumbnail,
|
|
Genre: strings.Join(genres, ", "),
|
|
Status: source.StatusCompleted,
|
|
})
|
|
}
|
|
return source.MangasPage{Mangas: mangas, HasNextPage: len(data.Feed.Entry) == maxResults}, nil
|
|
}
|
|
|
|
func (s *Source) GetPopularManga(page int) (source.MangasPage, error) {
|
|
return s.fetchFeed(context.Background(), page, "")
|
|
}
|
|
|
|
func (s *Source) GetLatestUpdates(page int) (source.MangasPage, error) {
|
|
return s.GetPopularManga(page)
|
|
}
|
|
|
|
func (s *Source) GetSearchManga(page int, query string, filters []source.Filter) (source.MangasPage, error) {
|
|
return s.fetchFeed(context.Background(), page, query)
|
|
}
|
|
|
|
func (s *Source) GetMangaDetails(manga source.SManga) (source.SManga, error) {
|
|
// All data already in manga from list; just return as-is.
|
|
return manga, nil
|
|
}
|
|
|
|
func (s *Source) GetChapterList(manga source.SManga) ([]source.SChapter, error) {
|
|
// URL is "...path#published_date"
|
|
hash := ""
|
|
chURL := manga.URL
|
|
if idx := strings.LastIndex(manga.URL, "#"); idx >= 0 {
|
|
hash = manga.URL[idx+1:]
|
|
chURL = manga.URL[:idx]
|
|
}
|
|
|
|
var dateMs int64
|
|
if hash != "" {
|
|
// Parse RFC3339 / ISO8601 date
|
|
if t, err := time.Parse(time.RFC3339Nano, hash); err == nil {
|
|
dateMs = t.UnixMilli()
|
|
} else if t, err := time.Parse("2006-01-02", hash[:10]); err == nil {
|
|
dateMs = t.UnixMilli()
|
|
}
|
|
}
|
|
|
|
return []source.SChapter{{
|
|
URL: chURL,
|
|
Name: "Gallery",
|
|
DateUpload: dateMs,
|
|
}}, nil
|
|
}
|
|
|
|
func (s *Source) GetPageList(chapter source.SChapter) ([]source.Page, error) {
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet,
|
|
util.AbsURL(s.cfg.BaseURL, chapter.URL), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Referer", s.cfg.BaseURL+"/")
|
|
resp, err := s.client.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("gravureblogger: HTTP %d", resp.StatusCode)
|
|
}
|
|
doc, err := goquery.NewDocumentFromReader(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pages []source.Page
|
|
doc.Find("div.post-body a:has(> img)").Each(func(i int, a *goquery.Selection) {
|
|
if u, ok := a.Attr("href"); ok && u != "" {
|
|
pages = append(pages, source.Page{Index: i, ImageURL: util.AbsURL(s.cfg.BaseURL, u)})
|
|
}
|
|
})
|
|
return pages, nil
|
|
}
|
|
|
|
func (s *Source) GetImageURL(page source.Page) (string, error) { return page.ImageURL, nil }
|
|
func (s *Source) GetFilterList() []source.Filter { return nil }
|