aboutsummaryrefslogtreecommitdiff
path: root/database/anime_cache.go
diff options
context:
space:
mode:
Diffstat (limited to 'database/anime_cache.go')
-rw-r--r--database/anime_cache.go1182
1 files changed, 426 insertions, 756 deletions
diff --git a/database/anime_cache.go b/database/anime_cache.go
index f26dc8b..6981b7a 100644
--- a/database/anime_cache.go
+++ b/database/anime_cache.go
@@ -2,10 +2,8 @@ package database
import (
"fmt"
- "metachan/config"
"metachan/entities"
"metachan/types"
- "metachan/utils/logger"
"strings"
"time"
@@ -13,15 +11,11 @@ import (
)
const (
- // CacheExpirationTime represents the duration after which the cache is considered stale
CacheExpirationTime = 24 * time.Hour
)
-// GetCachedAnimeByMALID retrieves an anime from the cache by MAL ID
func GetCachedAnimeByMALID(malID int) (*entities.CachedAnime, error) {
var anime entities.CachedAnime
-
- // Query the anime with all its relationships
err := DB.
Preload("Images").
Preload("Logos").
@@ -42,362 +36,508 @@ func GetCachedAnimeByMALID(malID int) (*entities.CachedAnime, error) {
Preload("Characters.VoiceActors").
Preload("AiringSchedule").
Preload("Seasons").
- Preload("Seasons.Images").
- Preload("Seasons.Scores").
- Preload("Seasons.AiringStatus").
- Preload("Seasons.AiringStatus.From").
- Preload("Seasons.AiringStatus.To").
Where("mal_id = ?", malID).
First(&anime).Error
if err != nil {
return nil, err
}
-
return &anime, nil
}
-// IsCacheValid checks if the cache is still valid based on the last update time
func IsCacheValid(anime *entities.CachedAnime) bool {
if anime == nil {
return false
}
-
- // Check if the cache has expired
return time.Since(anime.LastUpdated) < CacheExpirationTime
}
-// SaveAnimeToCache saves or updates an anime in the cache
func SaveAnimeToCache(animeData *types.Anime) error {
- // For SQLite, add retry logic to handle database locks
- var maxRetries = 5
- var retryDelay = 500 * time.Millisecond
-
- for attempt := 1; attempt <= maxRetries; attempt++ {
- err := saveAnimeToCacheWithRetry(animeData)
- if err == nil {
- logger.Log(fmt.Sprintf("Successfully saved anime (MAL ID: %d) to cache", animeData.MALID), logger.LogOptions{
- Level: logger.Success,
- Prefix: "AnimeCache",
- })
- return nil
- }
-
- // Check if it's a database lock error
- if strings.Contains(err.Error(), "database is locked") {
- logger.Log(fmt.Sprintf("Database locked (attempt %d/%d) for MAL ID %d: %v. Retrying in %v...",
- attempt, maxRetries, animeData.MALID, err, retryDelay), logger.LogOptions{
- Level: logger.Warn,
- Prefix: "AnimeCache",
- })
-
- time.Sleep(retryDelay)
- retryDelay *= 2 // Exponential backoff
- continue
- }
-
- // Non-lock error, just return it
- return err
+ if animeData == nil {
+ return fmt.Errorf("anime data is nil")
}
- return fmt.Errorf("failed to save anime (MAL ID: %d) after %d retries: database is locked",
- animeData.MALID, maxRetries)
-}
+ var tx *gorm.DB = DB.Begin()
+ if tx.Error != nil {
+ return tx.Error
+ }
-// saveAnimeToCacheWithRetry is the internal implementation of SaveAnimeToCache
-func saveAnimeToCacheWithRetry(animeData *types.Anime) error {
- // Start a transaction
- tx := DB.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
- if err := tx.Error; err != nil {
+ if err := tx.Exec("DELETE FROM cached_animes WHERE mal_id = ?", animeData.MALID).Error; err != nil {
+ tx.Rollback()
return err
}
- // Check if anime already exists in cache
- var existingAnime entities.CachedAnime
- result := tx.Where("mal_id = ?", animeData.MALID).First(&existingAnime)
-
- // If exists, delete the existing record and all its relations to avoid duplicates
- if result.Error == nil {
- // First directly delete the record with raw SQL to bypass GORM's hooks
- // which might be causing issues with constraints
- if err := tx.Exec("DELETE FROM cached_animes WHERE mal_id = ?", animeData.MALID).Error; err != nil {
- logger.Log(fmt.Sprintf("Failed to delete existing anime with direct SQL: %v", err), logger.LogOptions{
- Level: logger.Error,
- Prefix: "AnimeCache",
- })
+ anime := &entities.CachedAnime{
+ MALID: animeData.MALID,
+ TitleRomaji: animeData.Titles.Romaji,
+ TitleEnglish: animeData.Titles.English,
+ TitleJapanese: animeData.Titles.Japanese,
+ TitleSynonyms: strings.Join(animeData.Titles.Synonyms, ","),
+ Synopsis: animeData.Synopsis,
+ Type: string(animeData.Type),
+ Source: animeData.Source,
+ Airing: animeData.Airing,
+ Status: animeData.Status,
+ Duration: animeData.Duration,
+ Color: animeData.Color,
+ Season: animeData.Season,
+ Year: animeData.Year,
+ SubbedCount: animeData.Episodes.Subbed,
+ DubbedCount: animeData.Episodes.Dubbed,
+ TotalEpisodes: animeData.Episodes.Total,
+ AiredEpisodes: animeData.Episodes.Aired,
+ LastUpdated: time.Now(),
+ }
+
+ if err := tx.Create(anime).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+
+ // Now create related records with proper foreign key references
+ if animeData.Images.Small != "" || animeData.Images.Large != "" || animeData.Images.Original != "" {
+ images := &entities.CachedAnimeImages{
+ AnimeID: anime.ID,
+ Small: animeData.Images.Small,
+ Large: animeData.Images.Large,
+ Original: animeData.Images.Original,
+ }
+ if err := tx.Create(images).Error; err != nil {
tx.Rollback()
return err
}
+ }
- // Then also try the standard deleteExistingAnimeCache to clean up related records
- if err := deleteExistingAnimeCache(tx, existingAnime.ID); err != nil {
- logger.Log(fmt.Sprintf("Warning: Issue with deleteExistingAnimeCache: %v", err), logger.LogOptions{
- Level: logger.Warn,
- Prefix: "AnimeCache",
- })
- // Don't rollback here, we already deleted the main record which should address the constraint
+ if animeData.Logos.Small != "" || animeData.Logos.Medium != "" || animeData.Logos.Large != "" || animeData.Logos.XLarge != "" || animeData.Logos.Original != "" {
+ logos := &entities.CachedAnimeLogos{
+ AnimeID: anime.ID,
+ Small: animeData.Logos.Small,
+ Medium: animeData.Logos.Medium,
+ Large: animeData.Logos.Large,
+ XLarge: animeData.Logos.XLarge,
+ Original: animeData.Logos.Original,
+ }
+ if err := tx.Create(logos).Error; err != nil {
+ tx.Rollback()
+ return err
}
}
- // Create new cached anime
- cachedAnime := convertToCachedAnime(animeData)
-
- // Clear the ID to ensure we're creating a new record
- cachedAnime.ID = 0
-
- // Check if we're using SQLite and need to handle large datasets
- if config.Config.DatabaseDriver == types.SQLite && hasLargeDataset(cachedAnime) {
- // For SQLite with large datasets, save with batching
- if err := saveCachedAnimeWithBatching(tx, cachedAnime); err != nil {
+ if animeData.Covers.Small != "" || animeData.Covers.Large != "" || animeData.Covers.Original != "" {
+ covers := &entities.CachedAnimeCovers{
+ AnimeID: anime.ID,
+ Small: animeData.Covers.Small,
+ Large: animeData.Covers.Large,
+ Original: animeData.Covers.Original,
+ }
+ if err := tx.Create(covers).Error; err != nil {
tx.Rollback()
return err
}
- } else {
- // For other databases or small datasets, use standard GORM create
- if err := tx.Create(&cachedAnime).Error; err != nil {
+ }
+
+ if animeData.Scores.Score > 0 || animeData.Scores.ScoredBy > 0 {
+ scores := &entities.CachedAnimeScores{
+ AnimeID: anime.ID,
+ Score: animeData.Scores.Score,
+ ScoredBy: animeData.Scores.ScoredBy,
+ Rank: animeData.Scores.Rank,
+ Popularity: animeData.Scores.Popularity,
+ Members: animeData.Scores.Members,
+ Favorites: animeData.Scores.Favorites,
+ }
+ if err := tx.Create(scores).Error; err != nil {
tx.Rollback()
return err
}
}
- // Commit the transaction
- if err := tx.Commit().Error; err != nil {
- return err
+ if animeData.AiringStatus.From.Year > 0 || animeData.AiringStatus.From.String != "" || animeData.AiringStatus.To.Year > 0 || animeData.AiringStatus.To.String != "" || animeData.AiringStatus.String != "" {
+ var fromDateID, toDateID *uint
+
+ if animeData.AiringStatus.From.Year > 0 || animeData.AiringStatus.From.String != "" {
+ fromDate := &entities.CachedAiringStatusDates{
+ Day: animeData.AiringStatus.From.Day,
+ Month: animeData.AiringStatus.From.Month,
+ Year: animeData.AiringStatus.From.Year,
+ String: animeData.AiringStatus.From.String,
+ }
+ if err := tx.Create(fromDate).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+ fromDateID = &fromDate.ID
+ }
+
+ if animeData.AiringStatus.To.Year > 0 || animeData.AiringStatus.To.String != "" {
+ toDate := &entities.CachedAiringStatusDates{
+ Day: animeData.AiringStatus.To.Day,
+ Month: animeData.AiringStatus.To.Month,
+ Year: animeData.AiringStatus.To.Year,
+ String: animeData.AiringStatus.To.String,
+ }
+ if err := tx.Create(toDate).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+ toDateID = &toDate.ID
+ }
+
+ airingStatus := &entities.CachedAiringStatus{
+ AnimeID: anime.ID,
+ FromID: fromDateID,
+ ToID: toDateID,
+ String: animeData.AiringStatus.String,
+ }
+
+ if err := tx.Create(airingStatus).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
- // Log at debug level to avoid duplicate success messages
- logger.Log(fmt.Sprintf("Successfully saved anime (MAL ID: %d) to cache", animeData.MALID), logger.LogOptions{
- Level: logger.Debug,
- Prefix: "AnimeCache",
- })
+ if animeData.Broadcast.Day != "" || animeData.Broadcast.Time != "" {
+ broadcast := &entities.CachedAnimeBroadcast{
+ AnimeID: anime.ID,
+ Day: animeData.Broadcast.Day,
+ Time: animeData.Broadcast.Time,
+ Timezone: animeData.Broadcast.Timezone,
+ String: animeData.Broadcast.String,
+ }
+ if err := tx.Create(broadcast).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+ }
- return nil
-}
+ if animeData.NextAiringEpisode.AiringAt > 0 && animeData.NextAiringEpisode.Episode > 0 {
+ nextEpisode := &entities.CachedNextEpisode{
+ AnimeID: anime.ID,
+ AiringAt: animeData.NextAiringEpisode.AiringAt,
+ Episode: animeData.NextAiringEpisode.Episode,
+ }
+ if err := tx.Create(nextEpisode).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+ }
-// deleteExistingAnimeCache deletes an anime and all its relations from the cache
-func deleteExistingAnimeCache(tx *gorm.DB, animeID uint) error {
- // Define table structures with their foreign keys
- tableRelations := map[string]struct {
- Table string
- ForeignKey string
- Special bool // If true, needs special handling
- }{
- "cached_anime_voice_actors": {"cached_anime_voice_actors", "character_id", true}, // Links to characters, not anime directly
- "cached_anime_characters": {"cached_anime_characters", "anime_id", false},
- "cached_episode_titles": {"cached_episode_titles", "episode_id", true}, // Links to episodes, not anime directly
- "cached_anime_single_episodes": {"cached_anime_single_episodes", "anime_id", false},
- "cached_next_episodes": {"cached_next_episodes", "anime_id", false},
- "cached_schedule_episodes": {"cached_schedule_episodes", "anime_id", false},
- "cached_anime_licensors": {"cached_anime_licensors", "anime_id", false},
- "cached_anime_studios": {"cached_anime_studios", "anime_id", false},
- "cached_anime_producers": {"cached_anime_producers", "anime_id", false},
- "cached_anime_genres": {"cached_anime_genres", "anime_id", false},
- "cached_anime_broadcasts": {"cached_anime_broadcasts", "anime_id", false},
- "cached_airing_status_dates": {"cached_airing_status_dates", "airing_status_id", true}, // Links to airing status, not anime directly
- "cached_airing_statuses": {"cached_airing_statuses", "anime_id", false},
- "cached_anime_scores": {"cached_anime_scores", "anime_id", false},
- "cached_anime_covers": {"cached_anime_covers", "anime_id", false},
- "cached_anime_logos": {"cached_anime_logos", "anime_id", false},
- "cached_anime_images": {"cached_anime_images", "anime_id", false},
- "cached_anime_seasons": {"cached_anime_seasons", "parent_anime_id", false}, // Uses parent_anime_id
- "cached_animes": {"cached_animes", "id", true}, // Uses id instead of anime_id
+ // Create array records
+ for _, genre := range animeData.Genres {
+ genreRecord := &entities.CachedAnimeGenre{
+ AnimeID: anime.ID,
+ Name: genre.Name,
+ GenreID: genre.GenreID,
+ URL: genre.URL,
+ }
+ if err := tx.Create(genreRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
- // First, find all the character IDs associated with this anime
- var characterIDs []uint
- if err := tx.Table("cached_anime_characters").Where("anime_id = ?", animeID).Pluck("id", &characterIDs).Error; err != nil {
- // If there's an error, it might be that the table doesn't exist yet
- logger.Log(fmt.Sprintf("Note: Could not find character IDs: %v", err), logger.LogOptions{
- Level: logger.Debug,
- Prefix: "AnimeCache",
- })
+ for _, producer := range animeData.Producers {
+ producerRecord := &entities.CachedAnimeProducer{
+ AnimeID: anime.ID,
+ Name: producer.Name,
+ ProducerID: producer.ProducerID,
+ URL: producer.URL,
+ }
+ if err := tx.Create(producerRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
- // Find all episode IDs associated with this anime
- var episodeIDs []uint
- if err := tx.Table("cached_anime_single_episodes").Where("anime_id = ?", animeID).Pluck("id", &episodeIDs).Error; err != nil {
- logger.Log(fmt.Sprintf("Note: Could not find episode IDs: %v", err), logger.LogOptions{
- Level: logger.Debug,
- Prefix: "AnimeCache",
- })
+ for _, studio := range animeData.Studios {
+ studioRecord := &entities.CachedAnimeStudio{
+ AnimeID: anime.ID,
+ Name: studio.Name,
+ StudioID: studio.StudioID,
+ URL: studio.URL,
+ }
+ if err := tx.Create(studioRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
- // Find all airing status IDs associated with this anime
- var airingStatusIDs []uint
- if err := tx.Table("cached_airing_statuses").Where("anime_id = ?", animeID).Pluck("id", &airingStatusIDs).Error; err != nil {
- logger.Log(fmt.Sprintf("Note: Could not find airing status IDs: %v", err), logger.LogOptions{
- Level: logger.Debug,
- Prefix: "AnimeCache",
- })
+ for _, licensor := range animeData.Licensors {
+ licensorRecord := &entities.CachedAnimeLicensor{
+ AnimeID: anime.ID,
+ Name: licensor.Name,
+ ProducerID: licensor.ProducerID,
+ URL: licensor.URL,
+ }
+ if err := tx.Create(licensorRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
- // Delete voice actors by character IDs
- if len(characterIDs) > 0 {
- if err := tx.Where("character_id IN ?", characterIDs).Delete(&entities.CachedAnimeVoiceActor{}).Error; err != nil {
- logger.Log(fmt.Sprintf("Failed to delete voice actors: %v", err), logger.LogOptions{
- Level: logger.Warn,
- Prefix: "AnimeCache",
- })
+ for _, episode := range animeData.AiringSchedule {
+ scheduleRecord := &entities.CachedScheduleEpisode{
+ AnimeID: anime.ID,
+ AiringAt: episode.AiringAt,
+ Episode: episode.Episode,
+ }
+ if err := tx.Create(scheduleRecord).Error; err != nil {
+ tx.Rollback()
+ return err
}
}
- // Delete episode titles by episode IDs
- if len(episodeIDs) > 0 {
- if err := tx.Where("episode_id IN ?", episodeIDs).Delete(&entities.CachedEpisodeTitles{}).Error; err != nil {
- logger.Log(fmt.Sprintf("Failed to delete episode titles: %v", err), logger.LogOptions{
- Level: logger.Warn,
- Prefix: "AnimeCache",
- })
+ for _, episode := range animeData.Episodes.Episodes {
+ titles := &entities.CachedEpisodeTitles{
+ English: episode.Titles.English,
+ Japanese: episode.Titles.Japanese,
+ Romaji: episode.Titles.Romaji,
+ }
+ if err := tx.Create(titles).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+
+ episodeRecord := &entities.CachedAnimeSingleEpisode{
+ AnimeID: anime.ID,
+ TitlesID: titles.ID,
+ Description: episode.Description,
+ Aired: episode.Aired,
+ Score: episode.Score,
+ Filler: episode.Filler,
+ Recap: episode.Recap,
+ ForumURL: episode.ForumURL,
+ URL: episode.URL,
+ ThumbnailURL: episode.ThumbnailURL,
+ }
+ if err := tx.Create(episodeRecord).Error; err != nil {
+ tx.Rollback()
+ return err
}
}
- // Delete airing status dates by airing status IDs
- if len(airingStatusIDs) > 0 {
- if err := tx.Where("airing_status_id IN ?", airingStatusIDs).Delete(&entities.CachedAiringStatusDates{}).Error; err != nil {
- logger.Log(fmt.Sprintf("Failed to delete airing status dates: %v", err), logger.LogOptions{
- Level: logger.Warn,
- Prefix: "AnimeCache",
- })
+ for _, character := range animeData.Characters {
+ charRecord := &entities.CachedAnimeCharacter{
+ AnimeID: anime.ID,
+ MALID: character.MALID,
+ URL: character.URL,
+ ImageURL: character.ImageURL,
+ Name: character.Name,
+ Role: character.Role,
+ }
+
+ if err := tx.Create(charRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+
+ for _, va := range character.VoiceActors {
+ vaRecord := &entities.CachedAnimeVoiceActor{
+ CharacterID: charRecord.ID,
+ MALID: va.MALID,
+ URL: va.URL,
+ Image: va.Image,
+ Name: va.Name,
+ Language: va.Language,
+ }
+ if err := tx.Create(vaRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
}
- // Now delete the remaining tables with direct anime_id or parent_anime_id references
- for name, relation := range tableRelations {
- if relation.Special {
- continue // Skip special cases we've already handled
+ for _, season := range animeData.Seasons {
+ seasonRecord := &entities.CachedAnimeSeason{
+ ParentAnimeID: anime.ID,
+ MALID: season.MALID,
+ TitleRomaji: season.Titles.Romaji,
+ TitleEnglish: season.Titles.English,
+ TitleJapanese: season.Titles.Japanese,
+ TitleSynonyms: strings.Join(season.Titles.Synonyms, ","),
+ Synopsis: season.Synopsis,
+ Type: string(season.Type),
+ Source: season.Source,
+ Airing: season.Airing,
+ Status: season.Status,
+ Duration: season.Duration,
+ Season: season.Season,
+ Year: season.Year,
+ Current: season.Current,
}
- query := fmt.Sprintf("DELETE FROM %s WHERE %s = ?", relation.Table, relation.ForeignKey)
- if err := tx.Exec(query, animeID).Error; err != nil {
- logger.Log(fmt.Sprintf("Failed to delete from %s: %v", name, err), logger.LogOptions{
- Level: logger.Warn,
- Prefix: "AnimeCache",
- })
- // Continue anyway - don't stop the entire delete operation
+ if err := tx.Create(seasonRecord).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+
+ if season.Images.Small != "" || season.Images.Large != "" || season.Images.Original != "" {
+ seasonImages := &entities.CachedAnimeImages{
+ AnimeID: seasonRecord.ID,
+ Small: season.Images.Small,
+ Large: season.Images.Large,
+ Original: season.Images.Original,
+ }
+ if err := tx.Create(seasonImages).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
+ }
+
+ if season.Scores.Score > 0 || season.Scores.ScoredBy > 0 {
+ seasonScores := &entities.CachedAnimeScores{
+ AnimeID: seasonRecord.ID,
+ Score: season.Scores.Score,
+ ScoredBy: season.Scores.ScoredBy,
+ Rank: season.Scores.Rank,
+ Popularity: season.Scores.Popularity,
+ Members: season.Scores.Members,
+ Favorites: season.Scores.Favorites,
+ }
+ if err := tx.Create(seasonScores).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
}
- // Finally delete the anime itself
- if err := tx.Where("id = ?", animeID).Delete(&entities.CachedAnime{}).Error; err != nil {
- return fmt.Errorf("failed to delete cached anime with ID %d: %w", animeID, err)
+ if animeData.Mappings.AniDB > 0 || animeData.Mappings.Anilist > 0 || animeData.Mappings.AnimeCountdown > 0 || animeData.Mappings.AnimePlanet != "" || animeData.Mappings.AniSearch > 0 || animeData.Mappings.IMDB != "" || animeData.Mappings.Kitsu > 0 || animeData.Mappings.LiveChart > 0 || animeData.Mappings.NotifyMoe != "" || animeData.Mappings.Simkl > 0 || animeData.Mappings.TMDB > 0 || animeData.Mappings.TVDB > 0 {
+ mapping := &entities.AnimeMapping{
+ AniDB: animeData.Mappings.AniDB,
+ Anilist: animeData.Mappings.Anilist,
+ AnimeCountdown: animeData.Mappings.AnimeCountdown,
+ AnimePlanet: animeData.Mappings.AnimePlanet,
+ AniSearch: animeData.Mappings.AniSearch,
+ IMDB: animeData.Mappings.IMDB,
+ Kitsu: animeData.Mappings.Kitsu,
+ LiveChart: animeData.Mappings.LiveChart,
+ MAL: animeData.MALID,
+ NotifyMoe: animeData.Mappings.NotifyMoe,
+ Simkl: animeData.Mappings.Simkl,
+ TMDB: animeData.Mappings.TMDB,
+ TVDB: animeData.Mappings.TVDB,
+ }
+
+ if err := tx.Create(mapping).Error; err != nil {
+ tx.Rollback()
+ return err
+ }
}
- return nil
+ return tx.Commit().Error
}
-// ConvertToTypesAnime converts a cached anime to the types.Anime format
-func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
- if cachedAnime == nil {
+func ConvertToTypesAnime(cached *entities.CachedAnime) *types.Anime {
+ if cached == nil {
return nil
}
anime := &types.Anime{
- MALID: cachedAnime.MALID,
+ MALID: cached.MALID,
Titles: types.AnimeTitles{
- Romaji: cachedAnime.TitleRomaji,
- English: cachedAnime.TitleEnglish,
- Japanese: cachedAnime.TitleJapanese,
- Synonyms: strings.Split(cachedAnime.TitleSynonyms, ","),
+ Romaji: cached.TitleRomaji,
+ English: cached.TitleEnglish,
+ Japanese: cached.TitleJapanese,
+ Synonyms: strings.Split(cached.TitleSynonyms, ","),
+ },
+ Synopsis: cached.Synopsis,
+ Type: types.AniSyncType(cached.Type),
+ Source: cached.Source,
+ Airing: cached.Airing,
+ Status: cached.Status,
+ Duration: cached.Duration,
+ Color: cached.Color,
+ Season: cached.Season,
+ Year: cached.Year,
+ Episodes: types.AnimeEpisodes{
+ Total: cached.TotalEpisodes,
+ Aired: cached.AiredEpisodes,
+ Subbed: cached.SubbedCount,
+ Dubbed: cached.DubbedCount,
},
- Synopsis: cachedAnime.Synopsis,
- Type: types.AniSyncType(cachedAnime.Type),
- Source: cachedAnime.Source,
- Airing: cachedAnime.Airing,
- Status: cachedAnime.Status,
- Duration: cachedAnime.Duration,
- Color: cachedAnime.Color,
- Season: cachedAnime.Season,
- Year: cachedAnime.Year,
}
- // Fill in Images
- if cachedAnime.Images != nil {
+ if cached.Images != nil {
anime.Images = types.AnimeImages{
- Small: cachedAnime.Images.Small,
- Large: cachedAnime.Images.Large,
- Original: cachedAnime.Images.Original,
+ Small: cached.Images.Small,
+ Large: cached.Images.Large,
+ Original: cached.Images.Original,
}
}
- // Fill in Logos
- if cachedAnime.Logos != nil {
+ if cached.Logos != nil {
anime.Logos = types.AnimeLogos{
- Small: cachedAnime.Logos.Small,
- Medium: cachedAnime.Logos.Medium,
- Large: cachedAnime.Logos.Large,
- XLarge: cachedAnime.Logos.XLarge,
- Original: cachedAnime.Logos.Original,
+ Small: cached.Logos.Small,
+ Medium: cached.Logos.Medium,
+ Large: cached.Logos.Large,
+ XLarge: cached.Logos.XLarge,
+ Original: cached.Logos.Original,
}
}
- // Fill in Covers
- if cachedAnime.Covers != nil {
+ if cached.Covers != nil {
anime.Covers = types.AnimeImages{
- Small: cachedAnime.Covers.Small,
- Large: cachedAnime.Covers.Large,
- Original: cachedAnime.Covers.Original,
+ Small: cached.Covers.Small,
+ Large: cached.Covers.Large,
+ Original: cached.Covers.Original,
}
}
- // Fill in Scores
- if cachedAnime.Scores != nil {
+ if cached.Scores != nil {
anime.Scores = types.AnimeScores{
- Score: cachedAnime.Scores.Score,
- ScoredBy: cachedAnime.Scores.ScoredBy,
- Rank: cachedAnime.Scores.Rank,
- Popularity: cachedAnime.Scores.Popularity,
- Members: cachedAnime.Scores.Members,
- Favorites: cachedAnime.Scores.Favorites,
+ Score: cached.Scores.Score,
+ ScoredBy: cached.Scores.ScoredBy,
+ Rank: cached.Scores.Rank,
+ Popularity: cached.Scores.Popularity,
+ Members: cached.Scores.Members,
+ Favorites: cached.Scores.Favorites,
}
}
- // Fill in AiringStatus
- if cachedAnime.AiringStatus != nil {
+ if cached.AiringStatus != nil {
airingStatus := types.AiringStatus{
- String: cachedAnime.AiringStatus.String,
+ String: cached.AiringStatus.String,
}
- if cachedAnime.AiringStatus.From != nil {
+ if cached.AiringStatus.From != nil {
airingStatus.From = types.AiringStatusDates{
- Day: cachedAnime.AiringStatus.From.Day,
- Month: cachedAnime.AiringStatus.From.Month,
- Year: cachedAnime.AiringStatus.From.Year,
- String: cachedAnime.AiringStatus.From.String,
+ Day: cached.AiringStatus.From.Day,
+ Month: cached.AiringStatus.From.Month,
+ Year: cached.AiringStatus.From.Year,
+ String: cached.AiringStatus.From.String,
}
}
- if cachedAnime.AiringStatus.To != nil {
+ if cached.AiringStatus.To != nil {
airingStatus.To = types.AiringStatusDates{
- Day: cachedAnime.AiringStatus.To.Day,
- Month: cachedAnime.AiringStatus.To.Month,
- Year: cachedAnime.AiringStatus.To.Year,
- String: cachedAnime.AiringStatus.To.String,
+ Day: cached.AiringStatus.To.Day,
+ Month: cached.AiringStatus.To.Month,
+ Year: cached.AiringStatus.To.Year,
+ String: cached.AiringStatus.To.String,
}
}
anime.AiringStatus = airingStatus
}
- // Fill in Broadcast
- if cachedAnime.Broadcast != nil {
+ if cached.Broadcast != nil {
anime.Broadcast = types.AnimeBroadcast{
- Day: cachedAnime.Broadcast.Day,
- Time: cachedAnime.Broadcast.Time,
- Timezone: cachedAnime.Broadcast.Timezone,
- String: cachedAnime.Broadcast.String,
+ Day: cached.Broadcast.Day,
+ Time: cached.Broadcast.Time,
+ Timezone: cached.Broadcast.Timezone,
+ String: cached.Broadcast.String,
}
}
- // Convert genres
- if len(cachedAnime.Genres) > 0 {
- anime.Genres = make([]types.AnimeGenres, len(cachedAnime.Genres))
- for i, genre := range cachedAnime.Genres {
+ if len(cached.Genres) > 0 {
+ anime.Genres = make([]types.AnimeGenres, len(cached.Genres))
+ for i, genre := range cached.Genres {
anime.Genres[i] = types.AnimeGenres{
Name: genre.Name,
GenreID: genre.GenreID,
@@ -406,10 +546,9 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- // Convert producers
- if len(cachedAnime.Producers) > 0 {
- anime.Producers = make([]types.AnimeProducer, len(cachedAnime.Producers))
- for i, producer := range cachedAnime.Producers {
+ if len(cached.Producers) > 0 {
+ anime.Producers = make([]types.AnimeProducer, len(cached.Producers))
+ for i, producer := range cached.Producers {
anime.Producers[i] = types.AnimeProducer{
Name: producer.Name,
ProducerID: producer.ProducerID,
@@ -418,10 +557,9 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- // Convert studios
- if len(cachedAnime.Studios) > 0 {
- anime.Studios = make([]types.AnimeStudio, len(cachedAnime.Studios))
- for i, studio := range cachedAnime.Studios {
+ if len(cached.Studios) > 0 {
+ anime.Studios = make([]types.AnimeStudio, len(cached.Studios))
+ for i, studio := range cached.Studios {
anime.Studios[i] = types.AnimeStudio{
Name: studio.Name,
StudioID: studio.StudioID,
@@ -430,10 +568,9 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- // Convert licensors
- if len(cachedAnime.Licensors) > 0 {
- anime.Licensors = make([]types.AnimeLicensor, len(cachedAnime.Licensors))
- for i, licensor := range cachedAnime.Licensors {
+ if len(cached.Licensors) > 0 {
+ anime.Licensors = make([]types.AnimeLicensor, len(cached.Licensors))
+ for i, licensor := range cached.Licensors {
anime.Licensors[i] = types.AnimeLicensor{
Name: licensor.Name,
ProducerID: licensor.ProducerID,
@@ -442,18 +579,16 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- // Fill in NextAiringEpisode
- if cachedAnime.NextAiringEpisode != nil && cachedAnime.NextAiringEpisode.AiringAt > 0 && cachedAnime.NextAiringEpisode.Episode > 0 {
+ if cached.NextAiringEpisode != nil {
anime.NextAiringEpisode = types.AnimeAiringEpisode{
- AiringAt: cachedAnime.NextAiringEpisode.AiringAt,
- Episode: cachedAnime.NextAiringEpisode.Episode,
+ AiringAt: cached.NextAiringEpisode.AiringAt,
+ Episode: cached.NextAiringEpisode.Episode,
}
}
- // Convert airing schedule
- if len(cachedAnime.AiringSchedule) > 0 {
- anime.AiringSchedule = make([]types.AnimeAiringEpisode, len(cachedAnime.AiringSchedule))
- for i, episode := range cachedAnime.AiringSchedule {
+ if len(cached.AiringSchedule) > 0 {
+ anime.AiringSchedule = make([]types.AnimeAiringEpisode, len(cached.AiringSchedule))
+ for i, episode := range cached.AiringSchedule {
anime.AiringSchedule[i] = types.AnimeAiringEpisode{
AiringAt: episode.AiringAt,
Episode: episode.Episode,
@@ -461,11 +596,9 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- // Convert episodes
- if len(cachedAnime.Episodes) > 0 {
- anime.Episodes.Episodes = make([]types.AnimeSingleEpisode, len(cachedAnime.Episodes))
-
- for i, episode := range cachedAnime.Episodes {
+ if len(cached.Episodes) > 0 {
+ anime.Episodes.Episodes = make([]types.AnimeSingleEpisode, len(cached.Episodes))
+ for i, episode := range cached.Episodes {
episodeData := types.AnimeSingleEpisode{
Description: episode.Description,
Aired: episode.Aired,
@@ -487,17 +620,11 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
anime.Episodes.Episodes[i] = episodeData
}
-
- anime.Episodes.Total = cachedAnime.TotalEpisodes
- anime.Episodes.Aired = cachedAnime.AiredEpisodes
- anime.Episodes.Subbed = cachedAnime.SubbedCount
- anime.Episodes.Dubbed = cachedAnime.DubbedCount
}
- // Convert characters
- if len(cachedAnime.Characters) > 0 {
- anime.Characters = make([]types.AnimeCharacter, len(cachedAnime.Characters))
- for i, character := range cachedAnime.Characters {
+ if len(cached.Characters) > 0 {
+ anime.Characters = make([]types.AnimeCharacter, len(cached.Characters))
+ for i, character := range cached.Characters {
animeCharacter := types.AnimeCharacter{
MALID: character.MALID,
URL: character.URL,
@@ -523,10 +650,9 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- // Convert seasons
- if len(cachedAnime.Seasons) > 0 {
- anime.Seasons = make([]types.AnimeSeason, len(cachedAnime.Seasons))
- for i, season := range cachedAnime.Seasons {
+ if len(cached.Seasons) > 0 {
+ anime.Seasons = make([]types.AnimeSeason, len(cached.Seasons))
+ for i, season := range cached.Seasons {
animeSeason := types.AnimeSeason{
MALID: season.MALID,
Synopsis: season.Synopsis,
@@ -595,479 +721,23 @@ func ConvertToTypesAnime(cachedAnime *entities.CachedAnime) *types.Anime {
}
}
- return anime
-}
-
-// convertToCachedAnime converts from types.Anime to entities.CachedAnime
-func convertToCachedAnime(animeData *types.Anime) *entities.CachedAnime {
- if animeData == nil {
- return nil
- }
-
- cachedAnime := &entities.CachedAnime{
- MALID: animeData.MALID,
- TitleRomaji: animeData.Titles.Romaji,
- TitleEnglish: animeData.Titles.English,
- TitleJapanese: animeData.Titles.Japanese,
- TitleSynonyms: strings.Join(animeData.Titles.Synonyms, ","),
- Synopsis: animeData.Synopsis,
- Type: string(animeData.Type),
- Source: animeData.Source,
- Airing: animeData.Airing,
- Status: animeData.Status,
- Duration: animeData.Duration,
- Color: animeData.Color,
- Season: animeData.Season,
- Year: animeData.Year,
- SubbedCount: animeData.Episodes.Subbed,
- DubbedCount: animeData.Episodes.Dubbed,
- TotalEpisodes: animeData.Episodes.Total,
- AiredEpisodes: animeData.Episodes.Aired,
- LastUpdated: time.Now(),
- }
-
- // Add Images
- cachedAnime.Images = &entities.CachedAnimeImages{
- Small: animeData.Images.Small,
- Large: animeData.Images.Large,
- Original: animeData.Images.Original,
- }
-
- // Add Logos
- cachedAnime.Logos = &entities.CachedAnimeLogos{
- Small: animeData.Logos.Small,
- Medium: animeData.Logos.Medium,
- Large: animeData.Logos.Large,
- XLarge: animeData.Logos.XLarge,
- Original: animeData.Logos.Original,
- }
-
- // Add Covers
- cachedAnime.Covers = &entities.CachedAnimeCovers{
- Small: animeData.Covers.Small,
- Large: animeData.Covers.Large,
- Original: animeData.Covers.Original,
- }
-
- // Add Scores
- cachedAnime.Scores = &entities.CachedAnimeScores{
- Score: animeData.Scores.Score,
- ScoredBy: animeData.Scores.ScoredBy,
- Rank: animeData.Scores.Rank,
- Popularity: animeData.Scores.Popularity,
- Members: animeData.Scores.Members,
- Favorites: animeData.Scores.Favorites,
- }
-
- // Add AiringStatus
- if animeData.AiringStatus.From.Year > 0 || animeData.AiringStatus.From.String != "" {
- cachedAnime.AiringStatus = &entities.CachedAiringStatus{
- String: animeData.AiringStatus.String,
- }
-
- if animeData.AiringStatus.From.Year > 0 || animeData.AiringStatus.From.String != "" {
- cachedAnime.AiringStatus.From = &entities.CachedAiringStatusDates{
- Day: animeData.AiringStatus.From.Day,
- Month: animeData.AiringStatus.From.Month,
- Year: animeData.AiringStatus.From.Year,
- String: animeData.AiringStatus.From.String,
- }
- }
-
- if animeData.AiringStatus.To.Year > 0 || animeData.AiringStatus.To.String != "" {
- cachedAnime.AiringStatus.To = &entities.CachedAiringStatusDates{
- Day: animeData.AiringStatus.To.Day,
- Month: animeData.AiringStatus.To.Month,
- Year: animeData.AiringStatus.To.Year,
- String: animeData.AiringStatus.To.String,
- }
- }
- }
-
- // Add Broadcast
- if animeData.Broadcast.Day != "" || animeData.Broadcast.Time != "" {
- cachedAnime.Broadcast = &entities.CachedAnimeBroadcast{
- Day: animeData.Broadcast.Day,
- Time: animeData.Broadcast.Time,
- Timezone: animeData.Broadcast.Timezone,
- String: animeData.Broadcast.String,
+ var mapping entities.AnimeMapping
+ if err := DB.Where("mal = ?", cached.MALID).First(&mapping).Error; err == nil {
+ anime.Mappings = types.AnimeMappings{
+ AniDB: mapping.AniDB,
+ Anilist: mapping.Anilist,
+ AnimeCountdown: mapping.AnimeCountdown,
+ AnimePlanet: mapping.AnimePlanet,
+ AniSearch: mapping.AniSearch,
+ IMDB: mapping.IMDB,
+ Kitsu: mapping.Kitsu,
+ LiveChart: mapping.LiveChart,
+ NotifyMoe: mapping.NotifyMoe,
+ Simkl: mapping.Simkl,
+ TMDB: mapping.TMDB,
+ TVDB: mapping.TVDB,
}
}
- // Add Genres
- if len(animeData.Genres) > 0 {
- cachedAnime.Genres = make([]entities.CachedAnimeGenre, len(animeData.Genres))
- for i, genre := range animeData.Genres {
- cachedAnime.Genres[i] = entities.CachedAnimeGenre{
- Name: genre.Name,
- GenreID: genre.GenreID,
- URL: genre.URL,
- }
- }
- }
-
- // Add Producers
- if len(animeData.Producers) > 0 {
- cachedAnime.Producers = make([]entities.CachedAnimeProducer, len(animeData.Producers))
- for i, producer := range animeData.Producers {
- cachedAnime.Producers[i] = entities.CachedAnimeProducer{
- Name: producer.Name,
- ProducerID: producer.ProducerID,
- URL: producer.URL,
- }
- }
- }
-
- // Add Studios
- if len(animeData.Studios) > 0 {
- cachedAnime.Studios = make([]entities.CachedAnimeStudio, len(animeData.Studios))
- for i, studio := range animeData.Studios {
- cachedAnime.Studios[i] = entities.CachedAnimeStudio{
- Name: studio.Name,
- StudioID: studio.StudioID,
- URL: studio.URL,
- }
- }
- }
-
- // Add Licensors
- if len(animeData.Licensors) > 0 {
- cachedAnime.Licensors = make([]entities.CachedAnimeLicensor, len(animeData.Licensors))
- for i, licensor := range animeData.Licensors {
- cachedAnime.Licensors[i] = entities.CachedAnimeLicensor{
- Name: licensor.Name,
- ProducerID: licensor.ProducerID,
- URL: licensor.URL,
- }
- }
- }
-
- // Get the current timestamp
- currentTime := time.Now().Unix()
-
- // Determine the next airing episode from the schedule
- var nextEpisode *types.AnimeAiringEpisode
-
- // Process next airing episode data - first check if there's a valid next airing episode directly provided
- if animeData.NextAiringEpisode.AiringAt > 0 && animeData.NextAiringEpisode.Episode > 0 {
- // Check if it's still in the future
- if int64(animeData.NextAiringEpisode.AiringAt) > currentTime {
- nextEpisode = &types.AnimeAiringEpisode{
- AiringAt: animeData.NextAiringEpisode.AiringAt,
- Episode: animeData.NextAiringEpisode.Episode,
- }
- }
- }
-
- // If we don't have a valid next episode yet, or the one we have has already aired,
- // scan the schedule to find the actual next episode
- if (nextEpisode == nil || nextEpisode.AiringAt == 0) && len(animeData.AiringSchedule) > 0 {
- // Sort the schedule by airing time
- sortedSchedule := make([]types.AnimeAiringEpisode, len(animeData.AiringSchedule))
- copy(sortedSchedule, animeData.AiringSchedule)
-
- // Sort by airing time
- for i := 0; i < len(sortedSchedule)-1; i++ {
- for j := i + 1; j < len(sortedSchedule); j++ {
- if sortedSchedule[i].AiringAt > sortedSchedule[j].AiringAt {
- sortedSchedule[i], sortedSchedule[j] = sortedSchedule[j], sortedSchedule[i]
- }
- }
- }
-
- // Find the first episode that hasn't aired yet
- for _, episode := range sortedSchedule {
- if int64(episode.AiringAt) > currentTime {
- nextEpisode = &types.AnimeAiringEpisode{
- AiringAt: episode.AiringAt,
- Episode: episode.Episode,
- }
- break
- }
- }
- }
-
- // Add NextAiringEpisode if we found a valid next episode
- if nextEpisode != nil && nextEpisode.AiringAt > 0 {
- cachedAnime.NextAiringEpisode = &entities.CachedNextEpisode{
- AiringAt: nextEpisode.AiringAt,
- Episode: nextEpisode.Episode,
- }
- logger.Log(fmt.Sprintf("Set next airing episode for %s (ID: %d): Episode %d at %s",
- cachedAnime.TitleRomaji, cachedAnime.MALID,
- nextEpisode.Episode,
- time.Unix(int64(nextEpisode.AiringAt), 0).Format(time.RFC3339)),
- logger.LogOptions{
- Level: logger.Debug,
- Prefix: "AnimeCache",
- })
- }
-
- // Add AiringSchedule
- if len(animeData.AiringSchedule) > 0 {
- cachedAnime.AiringSchedule = make([]entities.CachedScheduleEpisode, len(animeData.AiringSchedule))
- for i, episode := range animeData.AiringSchedule {
- cachedAnime.AiringSchedule[i] = entities.CachedScheduleEpisode{
- AiringAt: episode.AiringAt,
- Episode: episode.Episode,
- }
- }
- }
-
- // Add Episodes
- if len(animeData.Episodes.Episodes) > 0 {
- cachedAnime.Episodes = make([]entities.CachedAnimeSingleEpisode, len(animeData.Episodes.Episodes))
- for i, episode := range animeData.Episodes.Episodes {
- // Create episode titles
- titles := &entities.CachedEpisodeTitles{
- English: episode.Titles.English,
- Japanese: episode.Titles.Japanese,
- Romaji: episode.Titles.Romaji,
- }
-
- cachedAnime.Episodes[i] = entities.CachedAnimeSingleEpisode{
- Description: episode.Description,
- Aired: episode.Aired,
- Score: episode.Score,
- Filler: episode.Filler,
- Recap: episode.Recap,
- ForumURL: episode.ForumURL,
- URL: episode.URL,
- ThumbnailURL: episode.ThumbnailURL,
- Titles: titles,
- }
- }
- }
-
- // Add Characters
- if len(animeData.Characters) > 0 {
- cachedAnime.Characters = make([]entities.CachedAnimeCharacter, len(animeData.Characters))
- for i, character := range animeData.Characters {
- char := entities.CachedAnimeCharacter{
- MALID: character.MALID,
- URL: character.URL,
- ImageURL: character.ImageURL,
- Name: character.Name,
- Role: character.Role,
- }
-
- if len(character.VoiceActors) > 0 {
- char.VoiceActors = make([]entities.CachedAnimeVoiceActor, len(character.VoiceActors))
- for j, va := range character.VoiceActors {
- char.VoiceActors[j] = entities.CachedAnimeVoiceActor{
- MALID: va.MALID,
- URL: va.URL,
- Image: va.Image,
- Name: va.Name,
- Language: va.Language,
- }
- }
- }
- cachedAnime.Characters[i] = char
- }
- }
-
- // Add Seasons
- if len(animeData.Seasons) > 0 {
- cachedAnime.Seasons = make([]entities.CachedAnimeSeason, len(animeData.Seasons))
- for i, season := range animeData.Seasons {
- cachedSeason := entities.CachedAnimeSeason{
- ParentAnimeID: cachedAnime.ID,
- MALID: season.MALID,
- TitleRomaji: season.Titles.Romaji,
- TitleEnglish: season.Titles.English,
- TitleJapanese: season.Titles.Japanese,
- TitleSynonyms: strings.Join(season.Titles.Synonyms, ","),
- Synopsis: season.Synopsis,
- Type: string(season.Type),
- Source: season.Source,
- Airing: season.Airing,
- Status: season.Status,
- Duration: season.Duration,
- Season: season.Season,
- Year: season.Year,
- Current: season.Current,
- }
-
- // Add Images
- cachedSeason.Images = &entities.CachedAnimeImages{
- Small: season.Images.Small,
- Large: season.Images.Large,
- Original: season.Images.Original,
- }
-
- // Add Scores
- cachedSeason.Scores = &entities.CachedAnimeScores{
- Score: season.Scores.Score,
- ScoredBy: season.Scores.ScoredBy,
- Rank: season.Scores.Rank,
- Popularity: season.Scores.Popularity,
- Members: season.Scores.Members,
- Favorites: season.Scores.Favorites,
- }
-
- // Add AiringStatus
- if season.AiringStatus.From.Year > 0 || season.AiringStatus.From.String != "" {
- cachedSeason.AiringStatus = &entities.CachedAiringStatus{
- String: season.AiringStatus.String,
- }
-
- if season.AiringStatus.From.Year > 0 || season.AiringStatus.From.String != "" {
- cachedSeason.AiringStatus.From = &entities.CachedAiringStatusDates{
- Day: season.AiringStatus.From.Day,
- Month: season.AiringStatus.From.Month,
- Year: season.AiringStatus.From.Year,
- String: season.AiringStatus.From.String,
- }
- }
-
- if season.AiringStatus.To.Year > 0 || season.AiringStatus.To.String != "" {
- cachedSeason.AiringStatus.To = &entities.CachedAiringStatusDates{
- Day: season.AiringStatus.To.Day,
- Month: season.AiringStatus.To.Month,
- Year: season.AiringStatus.To.Year,
- String: season.AiringStatus.To.String,
- }
- }
- }
-
- cachedAnime.Seasons[i] = cachedSeason
- }
- }
-
- return cachedAnime
-}
-
-// hasLargeDataset checks if the anime has a large number of episodes that might exceed SQLite limits
-func hasLargeDataset(anime *entities.CachedAnime) bool {
- // SQLite has a limit of 999 variables per statement. Each episode has multiple fields,
- // so we need to be conservative. If we have more than 100 episodes, use batching.
- return len(anime.Episodes) > 100
-}
-
-// saveCachedAnimeWithBatching saves anime data using batching for large datasets (SQLite only)
-func saveCachedAnimeWithBatching(tx *gorm.DB, cachedAnime *entities.CachedAnime) error {
- // First save the main anime record without episodes and other large collections
- mainAnime := &entities.CachedAnime{
- MALID: cachedAnime.MALID,
- TitleRomaji: cachedAnime.TitleRomaji,
- TitleEnglish: cachedAnime.TitleEnglish,
- TitleJapanese: cachedAnime.TitleJapanese,
- TitleSynonyms: cachedAnime.TitleSynonyms,
- Synopsis: cachedAnime.Synopsis,
- Type: cachedAnime.Type,
- Source: cachedAnime.Source,
- Airing: cachedAnime.Airing,
- Status: cachedAnime.Status,
- Duration: cachedAnime.Duration,
- Color: cachedAnime.Color,
- Season: cachedAnime.Season,
- Year: cachedAnime.Year,
- SubbedCount: cachedAnime.SubbedCount,
- DubbedCount: cachedAnime.DubbedCount,
- TotalEpisodes: cachedAnime.TotalEpisodes,
- AiredEpisodes: cachedAnime.AiredEpisodes,
- LastUpdated: cachedAnime.LastUpdated,
-
- // Include small collections that won't cause variable limit issues
- Images: cachedAnime.Images,
- Logos: cachedAnime.Logos,
- Covers: cachedAnime.Covers,
- Scores: cachedAnime.Scores,
- AiringStatus: cachedAnime.AiringStatus,
- Broadcast: cachedAnime.Broadcast,
- NextAiringEpisode: cachedAnime.NextAiringEpisode,
- Genres: cachedAnime.Genres,
- Producers: cachedAnime.Producers,
- Studios: cachedAnime.Studios,
- Licensors: cachedAnime.Licensors,
- AiringSchedule: cachedAnime.AiringSchedule,
- }
-
- // Save main anime with small collections
- if err := tx.Create(mainAnime).Error; err != nil {
- return fmt.Errorf("failed to save main anime record: %w", err)
- }
-
- // Now handle large collections in batches
- animeID := mainAnime.ID
-
- // Save episodes in batches
- if len(cachedAnime.Episodes) > 0 {
- batchSize := 50
- logger.Log(fmt.Sprintf("Saving %d episodes in batches of %d for anime %d",
- len(cachedAnime.Episodes), batchSize, animeID), logger.LogOptions{
- Level: logger.Debug,
- Prefix: "AnimeCache",
- })
-
- for i := 0; i < len(cachedAnime.Episodes); i += batchSize {
- end := i + batchSize
- if end > len(cachedAnime.Episodes) {
- end = len(cachedAnime.Episodes)
- }
-
- batch := make([]entities.CachedAnimeSingleEpisode, end-i)
- copy(batch, cachedAnime.Episodes[i:end])
-
- // Set the anime ID for each episode in the batch
- for j := range batch {
- batch[j].AnimeID = animeID
- }
-
- if err := tx.Create(&batch).Error; err != nil {
- return fmt.Errorf("failed to save episodes batch %d-%d: %w", i, end-1, err)
- }
- }
- }
-
- // Save characters in batches (they can also be large with voice actors)
- if len(cachedAnime.Characters) > 0 {
- batchSize := 20 // Smaller batch for characters due to nested voice actors
-
- for i := 0; i < len(cachedAnime.Characters); i += batchSize {
- end := i + batchSize
- if end > len(cachedAnime.Characters) {
- end = len(cachedAnime.Characters)
- }
-
- batch := make([]entities.CachedAnimeCharacter, end-i)
- copy(batch, cachedAnime.Characters[i:end])
-
- // Set the anime ID for each character in the batch
- for j := range batch {
- batch[j].AnimeID = animeID
- }
-
- if err := tx.Create(&batch).Error; err != nil {
- return fmt.Errorf("failed to save characters batch %d-%d: %w", i, end-1, err)
- }
- }
- }
-
- // Save seasons in batches
- if len(cachedAnime.Seasons) > 0 {
- batchSize := 10 // Even smaller for seasons due to complex nested relationships
-
- for i := 0; i < len(cachedAnime.Seasons); i += batchSize {
- end := i + batchSize
- if end > len(cachedAnime.Seasons) {
- end = len(cachedAnime.Seasons)
- }
-
- batch := make([]entities.CachedAnimeSeason, end-i)
- copy(batch, cachedAnime.Seasons[i:end])
-
- // Set the parent anime ID for each season in the batch
- for j := range batch {
- batch[j].ParentAnimeID = animeID
- }
-
- if err := tx.Create(&batch).Error; err != nil {
- return fmt.Errorf("failed to save seasons batch %d-%d: %w", i, end-1, err)
- }
- }
- }
-
- return nil
+ return anime
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 03:44:53 +0000