file.go

   1 package anidb
   2
   3 import (
   4         "encoding/json"
   5         "fmt"
   6         "github.com/EliasFleckenstein03/go-anidb/misc"
   7         "image"
   8         "strconv"
   9         "time"
  10 )
  11
  12 type FileVersion int
  13
  14 func (v FileVersion) String() string {
  15         if v == 1 {
  16                 return ""
  17         }
  18         return fmt.Sprintf("v%d", int(v))
  19 }
  20
  21 type FileSource string
  22
  23 type AudioStream struct {
  24         Codec    string
  25         Bitrate  int
  26         Language Language
  27 }
  28
  29 type VideoInfo struct {
  30         Codec      string
  31         Bitrate    int
  32         Resolution image.Rectangle
  33         ColorDepth int
  34 }
  35
  36 type File struct {
  37         FID FID
  38
  39         AID AID
  40         EID EID
  41         GID GID
  42         LID LIDMap
  43
  44         EpisodeString string
  45         EpisodeNumber misc.EpisodeList
  46
  47         Incomplete bool
  48
  49         Deprecated bool
  50         CRCMatch   bool
  51         BadCRC     bool
  52         Version    FileVersion
  53         Uncensored bool // Meaning unclear, may not be simply !Censored
  54         Censored   bool // Meaning unclear, may not be simply !Uncensored
  55
  56         Filesize int64
  57         Ed2kHash string
  58         SHA1Hash string
  59         CRC32    string
  60
  61         Length  time.Duration
  62         AirDate time.Time
  63
  64         AudioStreams      []AudioStream
  65         SubtitleLanguages []Language
  66         VideoInfo         VideoInfo
  67         FileExtension     string
  68
  69         Source FileSource
  70
  71         // Map of related EIDs to percentages (range 0.0-1.0).
  72         // The percentage indicates how much of the EID is covered by this file.
  73         RelatedEpisodes RelatedEpisodes
  74
  75         Cached time.Time
  76 }
  77
  78 func (f *File) Anime() *Anime {
  79         return f.AID.Anime()
  80 }
  81
  82 func (f *File) Episode() *Episode {
  83         return f.EID.Episode()
  84 }
  85
  86 func (f *File) Group() *Group {
  87         return f.GID.Group()
  88 }
  89
  90 func (f *File) UserMyList(user *User) *MyListEntry {
  91         if f != nil && user != nil && f.LID[user.UID] > 0 {
  92                 return f.LID[user.UID].MyListEntry()
  93         }
  94         return nil
  95 }
  96
  97 type RelatedEpisodes map[EID]float32
  98
  99 func (er RelatedEpisodes) MarshalJSON() ([]byte, error) {
 100         generic := make(map[string]float32, len(er))
 101         for k, v := range er {
 102                 generic[strconv.Itoa(int(k))] = v
 103         }
 104         return json.Marshal(generic)
 105 }
 106
 107 func (er RelatedEpisodes) UnmarshalJSON(b []byte) error {
 108         var generic map[string]float32
 109         if err := json.Unmarshal(b, &generic); err != nil {
 110                 return err
 111         }
 112         for k, v := range generic {
 113                 ik, err := strconv.ParseInt(k, 10, 32)
 114                 if err != nil {
 115                         return err
 116                 }
 117
 118                 er[EID(ik)] = v
 119         }
 120
 121         return nil
 122 }
 123
 124 type LIDMap map[UID]LID
 125
 126 func (m LIDMap) MarshalJSON() ([]byte, error) {
 127         generic := make(map[string]int, len(m))
 128         for k, v := range m {
 129                 generic[strconv.Itoa(int(k))] = int(v)
 130         }
 131         return json.Marshal(generic)
 132 }
 133
 134 func (m LIDMap) UnmarshalJSON(b []byte) error {
 135         var generic map[string]int
 136         if err := json.Unmarshal(b, &generic); err != nil {
 137                 return err
 138         }
 139         for k, v := range generic {
 140                 ik, err := strconv.ParseInt(k, 10, 32)
 141                 if err != nil {
 142                         return err
 143                 }
 144
 145                 m[UID(ik)] = LID(v)
 146         }
 147
 148         return nil
 149 }