508 lines
11 KiB
Go
Raw Normal View History

2019-06-03 09:32:43 +00:00
package arn
import (
"errors"
"fmt"
"sort"
"sync"
"github.com/aerogo/nano"
)
// AnimeList is a list of anime list items.
type AnimeList struct {
UserID UserID `json:"userId"`
Items []*AnimeListItem `json:"items"`
sync.Mutex
}
// Add adds an anime to the list if it hasn't been added yet.
2019-06-07 01:50:38 +00:00
func (list *AnimeList) Add(animeID AnimeID) error {
2019-06-03 09:32:43 +00:00
if list.Contains(animeID) {
return errors.New("Anime " + animeID + " has already been added")
}
creationDate := DateTimeUTC()
item := &AnimeListItem{
AnimeID: animeID,
Status: AnimeListStatusPlanned,
Rating: AnimeListItemRating{},
Created: creationDate,
Edited: creationDate,
}
if item.Anime() == nil {
return errors.New("Invalid anime ID")
}
list.Lock()
list.Items = append(list.Items, item)
list.Unlock()
return nil
}
// Remove removes the anime ID from the list.
2019-06-07 01:50:38 +00:00
func (list *AnimeList) Remove(animeID AnimeID) bool {
2019-06-03 09:32:43 +00:00
list.Lock()
defer list.Unlock()
for index, item := range list.Items {
if item.AnimeID == animeID {
list.Items = append(list.Items[:index], list.Items[index+1:]...)
return true
}
}
return false
}
// Contains checks if the list contains the anime ID already.
2019-06-07 01:50:38 +00:00
func (list *AnimeList) Contains(animeID AnimeID) bool {
2019-06-03 09:32:43 +00:00
list.Lock()
defer list.Unlock()
for _, item := range list.Items {
if item.AnimeID == animeID {
return true
}
}
return false
}
// HasItemsWithStatus checks if the list contains an anime with the given status.
func (list *AnimeList) HasItemsWithStatus(status string) bool {
list.Lock()
defer list.Unlock()
for _, item := range list.Items {
if item.Status == status {
return true
}
}
return false
}
// Find returns the list item with the specified anime ID, if available.
2019-06-07 01:50:38 +00:00
func (list *AnimeList) Find(animeID AnimeID) *AnimeListItem {
2019-06-03 09:32:43 +00:00
list.Lock()
defer list.Unlock()
for _, item := range list.Items {
if item.AnimeID == animeID {
return item
}
}
return nil
}
// Import adds an anime to the list if it hasn't been added yet
// and if it did exist it will update episode, rating and notes.
func (list *AnimeList) Import(item *AnimeListItem) {
existing := list.Find(item.AnimeID)
// If it doesn't exist yet: Simply add it.
if existing == nil {
list.Lock()
list.Items = append(list.Items, item)
list.Unlock()
return
}
// Temporary save it before changing the status
// because status changes can modify the episode count.
// This will prevent loss of "episodes watched" data.
existingEpisodes := existing.Episodes
// Status
existing.Status = item.Status
existing.OnStatusChange()
// Episodes
if item.Episodes > existingEpisodes {
existing.Episodes = item.Episodes
} else {
existing.Episodes = existingEpisodes
}
existing.OnEpisodesChange()
// Rating
if existing.Rating.Overall == 0 {
existing.Rating.Overall = item.Rating.Overall
existing.Rating.Clamp()
}
if existing.Notes == "" {
existing.Notes = item.Notes
}
if item.RewatchCount > existing.RewatchCount {
existing.RewatchCount = item.RewatchCount
}
// Edited
existing.Edited = DateTimeUTC()
}
// User returns the user this anime list belongs to.
func (list *AnimeList) User() *User {
user, _ := GetUser(list.UserID)
return user
}
// Sort ...
func (list *AnimeList) Sort() {
list.Lock()
defer list.Unlock()
sort.Slice(list.Items, func(i, j int) bool {
a := list.Items[i]
b := list.Items[j]
if (a.Status != AnimeListStatusWatching && a.Status != AnimeListStatusPlanned) && (b.Status != AnimeListStatusWatching && b.Status != AnimeListStatusPlanned) {
if a.Rating.Overall == b.Rating.Overall {
return a.Anime().Title.Canonical < b.Anime().Title.Canonical
}
return a.Rating.Overall > b.Rating.Overall
}
epsA := a.Anime().UpcomingEpisode()
epsB := b.Anime().UpcomingEpisode()
if epsA == nil && epsB == nil {
if a.Rating.Overall == b.Rating.Overall {
return a.Anime().Title.Canonical < b.Anime().Title.Canonical
}
return a.Rating.Overall > b.Rating.Overall
}
if epsA == nil {
return false
}
if epsB == nil {
return true
}
return epsA.Episode.AiringDate.Start < epsB.Episode.AiringDate.Start
})
}
// SortByRating sorts the anime list by overall rating.
func (list *AnimeList) SortByRating() {
list.Lock()
defer list.Unlock()
sort.Slice(list.Items, func(i, j int) bool {
a := list.Items[i]
b := list.Items[j]
if a.Rating.Overall == b.Rating.Overall {
return a.Anime().Title.Canonical < b.Anime().Title.Canonical
}
return a.Rating.Overall > b.Rating.Overall
})
}
// Top returns the top entries.
func (list *AnimeList) Top(count int) []*AnimeListItem {
list.Lock()
defer list.Unlock()
sort.Slice(list.Items, func(i, j int) bool {
a := list.Items[i]
b := list.Items[j]
if a.Rating.Overall == b.Rating.Overall {
return a.Anime().Title.Canonical < b.Anime().Title.Canonical
}
return a.Rating.Overall > b.Rating.Overall
})
if count > len(list.Items) {
count = len(list.Items)
}
tmp := make([]*AnimeListItem, count)
copy(tmp, list.Items[:count])
return tmp
}
// Watching ...
func (list *AnimeList) Watching() *AnimeList {
return list.FilterStatus(AnimeListStatusWatching)
}
// FilterStatus ...
func (list *AnimeList) FilterStatus(status string) *AnimeList {
newList := &AnimeList{
UserID: list.UserID,
Items: []*AnimeListItem{},
}
list.Lock()
defer list.Unlock()
for _, item := range list.Items {
if item.Status == status {
newList.Items = append(newList.Items, item)
}
}
return newList
}
// WithoutPrivateItems returns a new anime list with the private items removed.
func (list *AnimeList) WithoutPrivateItems() *AnimeList {
list.Lock()
defer list.Unlock()
newList := &AnimeList{
UserID: list.UserID,
Items: make([]*AnimeListItem, 0, len(list.Items)),
}
for _, item := range list.Items {
if !item.Private {
newList.Items = append(newList.Items, item)
}
}
return newList
}
// SplitByStatus splits the anime list into multiple ones by status.
func (list *AnimeList) SplitByStatus() map[string]*AnimeList {
statusToList := map[string]*AnimeList{}
statusToList[AnimeListStatusWatching] = &AnimeList{
UserID: list.UserID,
Items: []*AnimeListItem{},
}
statusToList[AnimeListStatusCompleted] = &AnimeList{
UserID: list.UserID,
Items: []*AnimeListItem{},
}
statusToList[AnimeListStatusPlanned] = &AnimeList{
UserID: list.UserID,
Items: []*AnimeListItem{},
}
statusToList[AnimeListStatusHold] = &AnimeList{
UserID: list.UserID,
Items: []*AnimeListItem{},
}
statusToList[AnimeListStatusDropped] = &AnimeList{
UserID: list.UserID,
Items: []*AnimeListItem{},
}
list.Lock()
defer list.Unlock()
for _, item := range list.Items {
statusList := statusToList[item.Status]
statusList.Items = append(statusList.Items, item)
}
return statusToList
}
// NormalizeRatings normalizes all ratings so that they are perfectly stretched among the full scale.
func (list *AnimeList) NormalizeRatings() {
list.Lock()
defer list.Unlock()
mapped := map[float64]float64{}
all := make([]float64, 0, len(list.Items))
for _, item := range list.Items {
// Zero rating counts as not rated
if item.Rating.Overall == 0 {
continue
}
_, found := mapped[item.Rating.Overall]
if !found {
mapped[item.Rating.Overall] = item.Rating.Overall
all = append(all, item.Rating.Overall)
}
}
sort.Slice(all, func(i, j int) bool {
return all[i] < all[j]
})
count := len(all)
// Prevent division by zero
if count <= 1 {
return
}
step := 9.9 / float64(count-1)
currentRating := 0.1
for _, rating := range all {
mapped[rating] = currentRating
currentRating += step
}
for _, item := range list.Items {
item.Rating.Overall = mapped[item.Rating.Overall]
item.Rating.Clamp()
}
}
// GetID returns the anime ID.
func (list *AnimeList) GetID() string {
return list.UserID
}
// TypeName returns the type name.
func (list *AnimeList) TypeName() string {
return "AnimeList"
}
// Self returns the object itself.
func (list *AnimeList) Self() Loggable {
return list
}
// Genres returns a map of genre names mapped to the list items that belong to that genre.
func (list *AnimeList) Genres() map[string][]*AnimeListItem {
genreToListItems := map[string][]*AnimeListItem{}
for _, item := range list.Items {
for _, genre := range item.Anime().Genres {
genreToListItems[genre] = append(genreToListItems[genre], item)
}
}
return genreToListItems
}
// TopGenres returns the most liked genres for the user's anime list.
func (list *AnimeList) TopGenres(count int) []string {
genreItems := list.Genres()
genreAffinity := map[string]float64{}
bestGenres := make([]string, 0, len(genreItems))
for genre, animeListItems := range genreItems {
if genre == "Action" || genre == "Comedy" {
continue
}
affinity := 0.0
for _, item := range animeListItems {
if item.Status != AnimeListStatusCompleted {
continue
}
if item.Rating.Overall != 0 {
affinity += item.Rating.Overall - AverageRating
} else {
// Add 0.1 to avoid all affinities being 0 when a user doesn't have any rated anime.
affinity += 0.1
}
}
genreAffinity[genre] = affinity
bestGenres = append(bestGenres, genre)
}
sort.Slice(bestGenres, func(i, j int) bool {
aAffinity := genreAffinity[bestGenres[i]]
bAffinity := genreAffinity[bestGenres[j]]
if aAffinity == bAffinity {
return bestGenres[i] < bestGenres[j]
}
return aAffinity > bAffinity
})
if len(bestGenres) > count {
bestGenres = bestGenres[:count]
}
return bestGenres
}
// RemoveDuplicates removes duplicate entries.
func (list *AnimeList) RemoveDuplicates() {
list.Lock()
defer list.Unlock()
existed := map[string]bool{}
newItems := make([]*AnimeListItem, 0, len(list.Items))
for _, item := range list.Items {
_, exists := existed[item.AnimeID]
if exists {
fmt.Println(list.User().Nick, "removed anime list item duplicate", item.AnimeID)
continue
}
newItems = append(newItems, item)
existed[item.AnimeID] = true
}
list.Items = newItems
}
// StreamAnimeLists returns a stream of all anime.
func StreamAnimeLists() <-chan *AnimeList {
channel := make(chan *AnimeList, nano.ChannelBufferSize)
go func() {
for obj := range DB.All("AnimeList") {
channel <- obj.(*AnimeList)
}
close(channel)
}()
return channel
}
// AllAnimeLists returns a slice of all anime.
func AllAnimeLists() ([]*AnimeList, error) {
all := make([]*AnimeList, 0, DB.Collection("AnimeList").Count())
stream := StreamAnimeLists()
for obj := range stream {
all = append(all, obj)
}
return all, nil
}
// GetAnimeList ...
func GetAnimeList(userID UserID) (*AnimeList, error) {
animeList, err := DB.Get("AnimeList", userID)
if err != nil {
return nil, err
}
return animeList.(*AnimeList), nil
}