huso/schaffer.go

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"strings"
	"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,
		Weekday:         jik.Broadcast.Day,
		TrailerURL:      jik.Trailer.URL,
		TrailerEmbedURL: jik.Trailer.EmbedURL,
	}
	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,
		})
	}
	res.URL = fmt.Sprintf("https://myanimelist.net/anime/%d", res.Anime)
	// disable autoplay hack
	res.TrailerEmbedURL = strings.Replace(res.TrailerEmbedURL, "autoplay=1", "autoplay=0", -1)
	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,
		Weekday:        mal.Broadcast.DayOfTheWeek,
		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)
	res.URL = fmt.Sprintf("https://myanimelist.net/anime/%d", res.Anime)
	return res
}

func UserConvert(user *UserJikan) User {
	return User{
		MalID:      user.Data.MalID,
		Username:   user.Data.Username,
		URL:        user.Data.URL,
		ImageURL:   user.Data.Images.Jpg.ImageURL,
		LastOnline: user.Data.LastOnline,
		Gender:     user.Data.Gender,
		Birthday:   user.Data.Birthday,
		Location:   user.Data.Location,
		Joined:     user.Data.Joined,
	}
}

func GetSeasonCache(key string) ([]Anime, error) {
	data, err := seasoncache.Get(key)
	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(seasonApiJikan)
	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
		}
	}
	season, err = GetSeasonCache(GetNextSeasonString())
	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")
}

func SearchAnime(animeId int64) (*Anime, error) {
	// search season first
	anime, err := SearchSeason(animeId)
	if err != nil {
		// get from MAL
		anime, _, err = GetAnimeDetailData(animeId)
		if err != nil {
			return nil, err
		}
	}
	return anime, err
}

func FetchProgress(animeId, userId int64, username string, progress int) (int, time.Time, string, error) {
	// check watching first
	newProgress, updated, err := fetchProgressOnState(animeId, userId, progress, username, malApiStatusW)
	if err != nil {
		return newProgress, updated, "", err
	}
	if newProgress != -1 {
		return newProgress, updated, malApiStatusW, err
	}
	// check on hold
	newProgress, updated, err = fetchProgressOnState(animeId, userId, progress, username, malApiStatusH)
	if err != nil {
		return newProgress, updated, "", err
	}
	if newProgress != -1 {
		return newProgress, updated, malApiStatusH, err
	}
	// check completed
	newProgress, updated, err = fetchProgressOnState(animeId, userId, progress, username, malApiStatusC)
	if err != nil {
		return newProgress, updated, "", err
	}
	if newProgress != -1 {
		return newProgress, updated, malApiStatusC, err
	}
	// check dropped
	newProgress, updated, err = fetchProgressOnState(animeId, userId, progress, username, malApiStatusD)
	if err != nil {
		return newProgress, updated, "", err
	}
	if newProgress != -1 {
		return newProgress, updated, malApiStatusD, err
	}
	// has no progress or PTW
	return 0, updated, "", nil
}

func fetchProgressOnState(animeId, userId int64, progress int, username, malStatus string) (int, time.Time, error) {
	list, _, err := GetUserAnimeListData(username, malStatus)
	if err != nil {
		return 0, time.Time{}, err
	}
	for _, a := range list.Data {
		// check if found
		if a.Node.ID == animeId {
			// check if progress changed
			return a.ListStatus.NumEpisodesWatched, a.ListStatus.UpdatedAt, nil
		}
	}
	// no progess found
	return -1, time.Now(), nil
}

func AddToChat(old, new, user string) string {
	buf := NewRingBuf(chatLength)
	buf.Write([]byte(old))
	buf.Write([]byte(fmt.Sprintf("[%s][%s]: %s\n", time.Now().Format("02.01.|15:04:05"), user, new)))
	return buf.String()
}

func CheckAnimeExistInDb(animeId int64) (bool, error) {
	dbAnime, err := ReadAnimeUsers()
	if err != nil {
		return false, err
	}
	for _, a := range dbAnime {
		if a.Anime == animeId {
			return true, err
		}
	}
	return false, err
}

func CheckAnimeExistInDbAndUserWatches(animeId, userId int64) (bool, error) {
	dbAnime, err := ReadAnimeUsers()
	if err != nil {
		return false, err
	}
	for _, a := range dbAnime {
		if a.Anime == animeId {
			for _, u := range a.Users {
				if u.MalID == userId {
					return true, err
				}
			}
			return false, err
		}
	}
	return false, err
}