huso/schaffer.go

package main

import (
	"encoding/json"
	"errors"
	"time"
)

func JikanConvert(jik *SeasonAnimeJikan) Anime {
	res := Anime{
		Anime:          jik.MalID,
		Title:          jik.Title,
		TitleEn:        jik.TitleEnglish,
		TitleJp:        jik.TitleJapanese,
		ImageMediumURL: jik.Images.Jpg.ImageURL,
		ImageLargeURL:  jik.Images.Jpg.LargeImageURL,
		ImageThumbURL:  jik.Images.Jpg.SmallImageURL,
		Type:           jik.Type,
		Status:         jik.Status,
		Episodes:       jik.Episodes,
		Synopsis:       jik.Synopsis,
		StartDate:      jik.Aired.From,
		EndDate:        jik.Aired.To,
		Year:           jik.Year,
		Season:         jik.Season,
		Score:          jik.Score,
		ScoredBy:       jik.ScoredBy,
		Rank:           jik.Rank,
		Popularity:     jik.Popularity,
		Members:        jik.Members,
		Source:         jik.Source,
		DayOfTheWeek:   jik.Broadcast.Day,
		StartTime:      jik.Broadcast.Time,
		TrailerURL:     jik.Trailer.URL,
	}
	for _, g := range jik.Genres {
		res.Genres = append(res.Genres, AnimeGenre{
			ID:   g.MalID,
			Name: g.Name,
		})
	}
	for _, s := range jik.Studios {
		res.Studios = append(res.Studios, AnimeStudio{
			ID:   s.MalID,
			Name: s.Name,
		})
	}
	return res
}

func MalConvert(mal *AnimeDetailMal) Anime {
	res := Anime{
		Anime:          mal.ID,
		Title:          mal.Title,
		TitleEn:        mal.AlternativeTitles.En,
		TitleJp:        mal.AlternativeTitles.Ja,
		ImageMediumURL: mal.MainPicture.Medium,
		ImageLargeURL:  mal.MainPicture.Large,
		ImageThumbURL:  "",
		Type:           mal.MediaType,
		Status:         mal.Status,
		Episodes:       mal.NumEpisodes,
		Synopsis:       mal.Synopsis,
		Year:           mal.StartSeason.Year,
		Season:         mal.StartSeason.Season,
		Score:          mal.Mean,
		ScoredBy:       mal.NumScoringUsers,
		Rank:           mal.Rank,
		Popularity:     mal.Popularity,
		Members:        mal.NumListUsers,
		Source:         mal.Source,
		DayOfTheWeek:   mal.Broadcast.DayOfTheWeek,
		StartTime:      mal.Broadcast.StartTime,
		TrailerURL:     "",
	}
	for _, g := range mal.Genres {
		res.Genres = append(res.Genres, AnimeGenre{
			ID:   g.ID,
			Name: g.Name,
		})
	}
	for _, s := range mal.Studios {
		res.Studios = append(res.Studios, AnimeStudio{
			ID:   s.ID,
			Name: s.Name,
		})
	}
	res.StartDate, _ = time.Parse("2006-01-02", mal.StartDate)
	res.EndDate, _ = time.Parse("2006-01-02", mal.EndDate)
	return res
}

func GetSeasonCache() ([]Anime, error) {
	data, err := cache.Get(seasonApiJikan)
	if err != nil {
		return nil, err
	}
	var seasonData []Anime
	err = json.Unmarshal(data, &seasonData)
	return seasonData, err
}

func SearchSeason(animeId int64) (*Anime, error) {
	season, err := GetSeasonCache()
	if err != nil {
		return nil, err
	}
	if len(season) == 0 {
		return nil, errors.New("no seasonal anime")
	}
	for _, a := range season {
		if a.Anime == animeId {
			return &a, err
		}
	}
	return nil, errors.New("anime not found")
}