Get the movie poster with a get details

This requires the eventers to have the app env

backend/events/channel.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"git.quimbo.fr/odwrtw/canape/backend/models"
+	"git.quimbo.fr/odwrtw/canape/backend/web"
 	"github.com/gorilla/websocket"
 	"github.com/jmoiron/sqlx"
 	"github.com/sirupsen/logrus"
@@ -12,7 +13,6 @@ import (
 
 // Channel represents the channel of the user and the server
 type Channel struct {
-	log *logrus.Entry
 	// Channel where the eventer will write messages to
 	serverEventStream chan ServerEvent
 	// Channel where the eventer will write errors to
@@ -31,7 +31,7 @@ type Channel struct {
 }
 
 // go routine writing events to the websocket connection
-func (c *Channel) writer() {
+func (c *Channel) writer(env *web.Env) {
 	// Create the ping timer that will ping the client every pingWait seconds
 	// to check that he's still listening
 	pingTicker := time.NewTicker(pingWait)
@@ -46,30 +46,30 @@ func (c *Channel) writer() {
 		case <-pingTicker.C:
 			_ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
 			if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
-				c.log.Warnf("error writing message: %s", err)
+				env.Log.Warnf("error writing message: %s", err)
 				return
 			}
 		case e := <-c.serverEventStream:
 			_ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
 			if err := c.conn.WriteJSON(e); err != nil {
-				c.log.Warnf("error writing JSON message: %s", err)
+				env.Log.Warnf("error writing JSON message: %s", err)
 				return
 			}
 		case err := <-c.serverErrorStream:
 			_ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
 			if err := c.conn.WriteJSON(err); err != nil {
-				c.log.Warnf("error writing JSON error: %s", err)
+				env.Log.Warnf("error writing JSON error: %s", err)
 				return
 			}
 		case <-c.done:
-			c.log.Debug("all done finished")
+			env.Log.Debug("all done finished")
 			return
 		}
 	}
 }
 
 // go routine reading messages from the websocket connection
-func (c *Channel) reader() {
+func (c *Channel) reader(env *web.Env) {
 	// Read loop
 	_ = c.conn.SetReadDeadline(time.Now().Add(pongWait))
 	for {
@@ -79,19 +79,19 @@ func (c *Channel) reader() {
 		if err := c.conn.ReadJSON(&msg); err != nil {
 			switch e := err.(type) {
 			case *websocket.CloseError:
-				c.log.Info("close error")
+				env.Log.Info("close error")
 			case net.Error:
 				if e.Timeout() {
-					c.log.WithField(
+					env.Log.WithField(
 						"error", err,
 					).Warn("timeout")
 				} else {
-					c.log.WithField(
+					env.Log.WithField(
 						"error", err,
 					).Warn("unknown net error")
 				}
 			default:
-				c.log.WithField(
+				env.Log.WithField(
 					"error", err,
 				).Warn("unknown error reading message")
 			}
@@ -104,31 +104,31 @@ func (c *Channel) reader() {
 
 		e, ok := Eventers[msg.Message]
 		if !ok {
-			c.log.Warnf("no such event to subscribe %q", msg.Message)
+			env.Log.Warnf("no such event to subscribe %q", msg.Message)
 			continue
 		}
 
 		switch msg.Type {
 		case "subscribe":
-			c.log.Debugf("subscribe to %s", msg.Message)
+			env.Log.Debugf("subscribe to %s", msg.Message)
 			if _, ok := c.Events[e.Name]; ok {
-				c.log.Infof("user %s is already subscribed to %s", c.User.Name, e.Name)
+				env.Log.Infof("user %s is already subscribed to %s", c.User.Name, e.Name)
 				continue
 			}
 			if err := e.Subscribe(c); err != nil {
-				c.Error(e.Name, err)
+				c.Error(e.Name, err, env.Log)
 				continue
 			}
 			c.Events[e.Name] = struct{}{}
 		case "unsubscribe":
-			c.log.Debugf("unsubscribe from %s", msg.Message)
+			env.Log.Debugf("unsubscribe from %s", msg.Message)
 			if _, ok := c.Events[e.Name]; !ok {
-				c.log.Infof("user %s is not subscribed to %s", c.User.Name, e.Name)
+				env.Log.Infof("user %s is not subscribed to %s", c.User.Name, e.Name)
 				continue
 			}
 			e.Unsubscribe(c)
 		default:
-			c.log.Warnf("invalid type: %s", msg.Type)
+			env.Log.Warnf("invalid type: %s", msg.Type)
 		}
 	}
 }
@@ -147,11 +147,11 @@ func (c *Channel) close() {
 }
 
 // Error sends an error into the errorStream channel
-func (c *Channel) Error(name string, err error) {
+func (c *Channel) Error(name string, err error, log *logrus.Entry) {
 	if c.closed {
 		return
 	}
-	c.log.WithField("name", name).Warn(err)
+	log.WithField("name", name).Warn(err)
 	c.serverErrorStream <- ServerError{
 		Event: Event{
 			Type:   name,
@@ -165,11 +165,11 @@ func (c *Channel) Error(name string, err error) {
 }
 
 // FatalError sends an error into the errorStream channel
-func (c *Channel) FatalError(name string, err error) {
+func (c *Channel) FatalError(name string, err error, log *logrus.Entry) {
 	if c.closed {
 		return
 	}
-	c.log.WithField("name", name).Warn(err)
+	log.WithField("name", name).Warn(err)
 	c.serverErrorStream <- ServerError{
 		Event: Event{
 			Type:   name,

backend/events/handlers.go

@@ -22,14 +22,26 @@ const (
 	writeWait = 30 * time.Second
 )
 
-// Eventers is a map of all the available Eventers
-var Eventers = map[string]*PolochonEventers{
-	torrentEventName: NewTorrentEventers(),
-	videoEventName:   NewVideoEventers(),
+// Eventers is a global map of all the available Eventers
+var Eventers map[string]*PolochonEventers
+var eventersSetup bool
+
+func initEventers(env *web.Env) {
+	if eventersSetup {
+		return
+	}
+
+	Eventers = map[string]*PolochonEventers{
+		torrentEventName: NewTorrentEventers(env),
+		videoEventName:   NewVideoEventers(env),
+	}
+	eventersSetup = true
 }
 
 // WsHandler handles the websockets messages
 func WsHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
+	initEventers(env)
+
 	// Get the user
 	user := auth.GetCurrentUser(r, env.Log)
 
@@ -67,7 +79,6 @@ func WsHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
 		serverErrorStream: serverErrorStream,
 		done:              make(chan struct{}, 1),
 		conn:              ws,
-		log:               env.Log,
 		User:              user,
 		db:                env.Database,
 		Events:            map[string]struct{}{},
@@ -76,9 +87,9 @@ func WsHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
 	}
 
 	// Launch the go routine responsible for writing events in the websocket
-	go c.writer()
+	go c.writer(env)
 	// Launch the reader responsible for reading events from the websocket
-	c.reader()
+	c.reader(env)
 
 	return nil
 }
@@ -122,6 +133,7 @@ func PolochonHookHandler(env *web.Env, w http.ResponseWriter, r *http.Request) e
 
 // HookDebugHandler handles the websockets messages
 func HookDebugHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
+	initEventers(env)
 	debug := map[string]map[string][]*Channel{}
 
 	for e, event := range Eventers {

backend/events/polochons.go

@@ -5,13 +5,13 @@ import (
 	"sync"
 
 	"git.quimbo.fr/odwrtw/canape/backend/models"
-	"github.com/sirupsen/logrus"
+	"git.quimbo.fr/odwrtw/canape/backend/web"
 )
 
 // BaseEventer represents the basis of a Eventer
 type BaseEventer struct {
+	env   *web.Env
 	users []*Channel
-	log   *logrus.Entry
 	name  string
 }
 
@@ -20,22 +20,17 @@ type BaseEventer struct {
 // Eventer per polochon
 type PolochonEventers struct {
 	sync.RWMutex
+	env        *web.Env
 	Name       string
-	log        *logrus.Entry
 	polochons  map[string]Eventer
-	NewEventer func(polo *models.Polochon, log *logrus.Entry) (Eventer, error)
+	NewEventer func(*web.Env, *models.Polochon) (Eventer, error)
 }
 
 // NewEventers returns a new PolochonEventers
-func NewEventers() *PolochonEventers {
-	// Setup the logger
-	logger := logrus.New()
-	logger.Formatter = &logrus.TextFormatter{FullTimestamp: true}
-	logger.Level = logrus.DebugLevel
-
+func NewEventers(env *web.Env) *PolochonEventers {
 	return &PolochonEventers{
+		env:       env,
 		polochons: map[string]Eventer{},
-		log:       logrus.NewEntry(logger),
 	}
 }
 
@@ -46,7 +41,7 @@ func (p *PolochonEventers) Subscribe(chanl *Channel) error {
 	p.Lock()
 	defer p.Unlock()
 
-	p.log.Debugf("subscribing with the user %s", chanl.User.Name)
+	p.env.Log.Debugf("subscribing with the user %s", chanl.User.Name)
 	if !chanl.User.PolochonActivated {
 		return fmt.Errorf("polochon not activated")
 	}
@@ -55,7 +50,7 @@ func (p *PolochonEventers) Subscribe(chanl *Channel) error {
 	// listening
 	tn, ok := p.polochons[chanl.User.PolochonID.String]
 	if !ok {
-		p.log.Debugf("create new eventer for polochon %s", chanl.User.PolochonID.String)
+		p.env.Log.Debugf("create new eventer for polochon %s", chanl.User.PolochonID.String)
 
 		// Get the user's polochon
 		polo, err := chanl.User.GetPolochon(chanl.db)
@@ -64,7 +59,7 @@ func (p *PolochonEventers) Subscribe(chanl *Channel) error {
 		}
 
 		// Create a new Eventer for this polochon
-		tn, err = p.NewEventer(polo, p.log)
+		tn, err = p.NewEventer(p.env, polo)
 		if err != nil {
 			return err
 		}
@@ -82,7 +77,7 @@ func (p *PolochonEventers) Subscribe(chanl *Channel) error {
 	// Add the Channel to the Eventer
 	tn.Append(chanl)
 
-	p.log.Debugf("eventer created for polochon %s", chanl.User.PolochonID.String)
+	p.env.Log.Debugf("eventer created for polochon %s", chanl.User.PolochonID.String)
 	return nil
 }
 
@@ -93,21 +88,21 @@ func (p *PolochonEventers) Unsubscribe(chanl *Channel) {
 	p.Lock()
 	defer p.Unlock()
 
-	p.log.Debugf("unsubscribing from %s with %s", p.Name, chanl.User.Name)
+	p.env.Log.Debugf("unsubscribing from %s with %s", p.Name, chanl.User.Name)
 
 	tn, ok := p.polochons[chanl.User.PolochonID.String]
 	if !ok {
-		p.log.Warnf("no eventer for polochon %s, not unsubscribing", chanl.User.PolochonID.String)
+		p.env.Log.Warnf("no eventer for polochon %s, not unsubscribing", chanl.User.PolochonID.String)
 		return
 	}
 
 	if err := tn.Unsubscribe(chanl); err != nil {
-		p.log.Errorf("failed to unsubscribe eventer:  %s", err.Error())
+		p.env.Log.Errorf("failed to unsubscribe eventer:  %s", err.Error())
 		// TODO: check if we need to return here
 	}
 
 	if len(tn.Subscribers()) == 0 {
-		p.log.Debugf("empty subscribers for this polochon, delete it")
+		p.env.Log.Debugf("empty subscribers for this polochon, delete it")
 		tn.Finish()
 		// Delete the polochon from the Eventer when it's finished
 		delete(p.polochons, chanl.User.PolochonID.String)
@@ -133,7 +128,7 @@ func (e *BaseEventer) Unsubscribe(chanl *Channel) error {
 			i++
 			continue
 		}
-		e.log.Debugf("found the user channel %s for user %s, deleting it...", chanl.ID, chanl.User.Name)
+		e.env.Log.Debugf("found the user channel %s for user %s, deleting it...", chanl.ID, chanl.User.Name)
 
 		// Delete this event from the list of events the channel is subscribed
 		delete(e.users[i].Events, e.name)
@@ -162,7 +157,7 @@ func (e *BaseEventer) Unsubscribe(chanl *Channel) error {
 func (e *BaseEventer) FatalError(err error) {
 	for _, chanl := range e.users {
 		// Send the error
-		chanl.FatalError(e.name, err)
+		chanl.FatalError(e.name, err, e.env.Log)
 		// Delete the event from the channel events
 		delete(chanl.Events, e.name)
 	}
@@ -191,7 +186,7 @@ func (e *BaseEventer) NotifyAll(data interface{}) {
 
 	// Send the events to all the subscribed users
 	for _, chanl := range e.users {
-		e.log.Debugf("sending event to %s", chanl.User.Name)
+		e.env.Log.Debugf("sending event to %s", chanl.User.Name)
 		chanl.sendEvent(event)
 	}
 }

backend/events/torrent_eventer.go

@@ -6,8 +6,8 @@ import (
 	"time"
 
 	"git.quimbo.fr/odwrtw/canape/backend/models"
+	"git.quimbo.fr/odwrtw/canape/backend/web"
 	"github.com/odwrtw/papi"
-	"github.com/sirupsen/logrus"
 )
 
 // TorrentEventer represents the Eventer for torrents
@@ -21,15 +21,15 @@ type TorrentEventer struct {
 var torrentEventName = "torrents"
 
 // NewTorrentEventers returns a new PolochonEventers for torrents
-func NewTorrentEventers() *PolochonEventers {
-	eventer := NewEventers()
+func NewTorrentEventers(env *web.Env) *PolochonEventers {
+	eventer := NewEventers(env)
 	eventer.NewEventer = NewTorrentEventer
 	eventer.Name = torrentEventName
 	return eventer
 }
 
 // NewTorrentEventer returns a new Eventer for a specific Polochon
-func NewTorrentEventer(polo *models.Polochon, log *logrus.Entry) (Eventer, error) {
+func NewTorrentEventer(env *web.Env, polo *models.Polochon) (Eventer, error) {
 	// Create a new papi client
 	client, err := polo.NewPapiClient()
 	if err != nil {
@@ -39,8 +39,8 @@ func NewTorrentEventer(polo *models.Polochon, log *logrus.Entry) (Eventer, error
 	// This is the first time this polochon is requested, create the TorrentEventer
 	tn := &TorrentEventer{
 		BaseEventer: &BaseEventer{
+			env:   env,
 			users: []*Channel{},
-			log:   log,
 			name:  torrentEventName,
 		},
 		pClient:  client,
@@ -77,7 +77,7 @@ func (t *TorrentEventer) Launch() error {
 
 	err := t.torrentsUpdate()
 	if err != nil {
-		t.log.Warnf("got error getting torrents: %s", err)
+		t.env.Log.Warnf("got error getting torrents: %s", err)
 	}
 
 	for {
@@ -85,10 +85,10 @@ func (t *TorrentEventer) Launch() error {
 		case <-timeTicker.C:
 			err := t.torrentsUpdate()
 			if err != nil {
-				t.log.Warnf("got error getting torrents: %s", err)
+				t.env.Log.Warnf("got error getting torrents: %s", err)
 			}
 		case <-t.done:
-			t.log.Debug("quit torrent notifier")
+			t.env.Log.Debug("quit torrent notifier")
 			return nil
 		}
 	}
@@ -106,9 +106,15 @@ func (t *TorrentEventer) torrentsUpdate() error {
 		return nil
 	}
 
-	t.log.Debugf("torrents have changed!")
+	t.env.Log.Debugf("torrents have changed!")
 
-	t.NotifyAll(torrents)
+	notification := make([]*models.TorrentVideo, len(torrents))
+	for i := range torrents {
+		notification[i] = models.NewTorrentVideo(&torrents[i])
+		notification[i].Update(t.env.Backend.Detailer, t.env.Log)
+	}
+
+	t.NotifyAll(notification)
 
 	t.torrents = torrents
 
@@ -118,6 +124,6 @@ func (t *TorrentEventer) torrentsUpdate() error {
 // Finish implements the Eventer interface
 // It is called when there is no more users subscribed
 func (t *TorrentEventer) Finish() {
-	t.log.Debugf("sending the done channel")
+	t.env.Log.Debugf("sending the done channel")
 	t.done <- struct{}{}
 }

backend/events/video_eventer.go

@@ -2,7 +2,7 @@ package events
 
 import (
 	"git.quimbo.fr/odwrtw/canape/backend/models"
-	"github.com/sirupsen/logrus"
+	"git.quimbo.fr/odwrtw/canape/backend/web"
 )
 
 // VideoEventer represents the Eventer for tests
@@ -13,19 +13,19 @@ type VideoEventer struct {
 var videoEventName = "newVideo"
 
 // NewVideoEventers implements the Eventer interface
-func NewVideoEventers() *PolochonEventers {
-	eventer := NewEventers()
+func NewVideoEventers(env *web.Env) *PolochonEventers {
+	eventer := NewEventers(env)
 	eventer.NewEventer = NewVideoEventer
 	eventer.Name = videoEventName
 	return eventer
 }
 
 // NewVideoEventer returns a new Eventer
-func NewVideoEventer(polo *models.Polochon, log *logrus.Entry) (Eventer, error) {
+func NewVideoEventer(env *web.Env, polo *models.Polochon) (Eventer, error) {
 	return &VideoEventer{
 		BaseEventer: &BaseEventer{
+			env:   env,
 			users: []*Channel{},
-			log:   log,
 			name:  videoEventName,
 		},
 	}, nil

backend/main.go

@@ -49,7 +49,11 @@ func run() error {
 	if err != nil {
 		return err
 	}
-	backend := &models.Backend{Database: db}
+	backend := &models.Backend{
+		Database:     db,
+		PublicDir:    cf.PublicDir,
+		ImgURLPrefix: cf.ImgURLPrefix,
+	}
 
 	// Generate auth params
 	authParams := auth.Params{

backend/models/backend.go

@@ -7,8 +7,10 @@ import (
 
 // Backend represents the data backend
 type Backend struct {
-	Database   *sqlx.DB
-	configured bool
+	Database     *sqlx.DB
+	PublicDir    string
+	ImgURLPrefix string
+	configured   bool
 }
 
 // Name implements the Module interface

backend/models/detailer.go

@@ -2,6 +2,9 @@ package models
 
 import (
 	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
 
 	polochon "github.com/odwrtw/polochon/lib"
 	"github.com/sirupsen/logrus"
@@ -28,6 +31,15 @@ func (b *Backend) GetMovieDetails(pMovie *polochon.Movie, log *logrus.Entry) err
 		return err
 	}
 
+	// Add the movie images
+	imgURL := fmt.Sprintf("movies/%s.jpg", pMovie.ImdbID)
+	imgFile := filepath.Join(b.PublicDir, "img", imgURL)
+	posterURL := ""
+	if _, err := os.Stat(imgFile); !os.IsNotExist(err) {
+		posterURL = b.ImgURLPrefix + imgURL
+	}
+	pMovie.Thumb = posterURL
+
 	log.Debugf("got movie %s from backend", pMovie.ImdbID)
 
 	return nil

backend/models/episodes.go

@@ -25,8 +25,12 @@ const (
 	FROM episodes WHERE show_imdb_id=$1;`
 
 	getEpisodeQuery = `
-	SELECT *
-	FROM episodes WHERE show_imdb_id=$1 AND season=$2 AND episode=$3;`
+	SELECT s.title show_title, e.*
+	FROM shows s , episodes e
+	WHERE s.imdb_id = e.show_imdb_id
+	AND e.show_imdb_id=$1
+	AND e.season=$2
+	AND e.episode=$3;`
 )
 
 // episodeDB represents the Episode in the DB
@@ -36,6 +40,7 @@ type episodeDB struct {
 	ImdbID     string    `db:"imdb_id"`
 	ShowImdbID string    `db:"show_imdb_id"`
 	ShowTvdbID int       `db:"show_tvdb_id"`
+	ShowTitle  string    `db:"show_title"`
 	Season     int       `db:"season"`
 	Episode    int       `db:"episode"`
 	Title      string    `db:"title"`
@@ -70,6 +75,7 @@ func FillEpisodeFromDB(eDB *episodeDB, pEpisode *polochon.ShowEpisode) {
 	// Keep the data that never changes but only if we have it
 	updateIfNonEmpty(&pEpisode.EpisodeImdbID, eDB.ImdbID)
 	updateIfNonEmpty(&pEpisode.ShowImdbID, eDB.ShowImdbID)
+	updateIfNonEmpty(&pEpisode.ShowTitle, eDB.ShowTitle)
 	updateIfNonZeroInt(&pEpisode.TvdbID, eDB.TvdbID)
 	updateIfNonZeroInt(&pEpisode.ShowTvdbID, eDB.ShowTvdbID)
 	pEpisode.Season = eDB.Season

backend/models/torrent_video.go

@@ -0,0 +1,42 @@
+package models
+
+import (
+	"github.com/odwrtw/papi"
+	polochon "github.com/odwrtw/polochon/lib"
+	"github.com/sirupsen/logrus"
+)
+
+// TorrentVideo reprensents a torrent embeding the video inforamtions
+type TorrentVideo struct {
+	*papi.Torrent
+	Video polochon.Video `json:"video,omitempty"`
+}
+
+// NewTorrentVideo returns a new TorrentVideo
+func NewTorrentVideo(t *papi.Torrent) *TorrentVideo {
+	torrent := &polochon.Torrent{
+		ImdbID:  t.ImdbID,
+		Type:    polochon.VideoType(t.Type),
+		Quality: polochon.Quality(t.Quality),
+		Season:  t.Season,
+		Episode: t.Episode,
+	}
+
+	return &TorrentVideo{
+		Torrent: t,
+		Video:   torrent.Video(),
+	}
+}
+
+// Update updates the Torrent video with the database details
+func (t *TorrentVideo) Update(detailer polochon.Detailer, log *logrus.Entry) {
+	if t.Video == nil {
+		return
+	}
+
+	// TODO: refresh the video in db if not found
+	err := detailer.GetDetails(t.Video, log)
+	if err != nil {
+		log.WithField("function", "TorrentVideo.Update").Errorf(err.Error())
+	}
+}

backend/movies/movies.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
-	"os"
 	"path/filepath"
 	"time"
 
@@ -43,8 +42,9 @@ func (m *Movie) MarshalJSON() ([]byte, error) {
 		VideoCodec  string               `json:"video_codec"`
 		Container   string               `json:"container"`
 	}{
-		Alias:     (*Alias)(m),
-		PosterURL: m.PosterURL(),
+		Alias: (*Alias)(m),
+		// TODO: remove this field to use m.Thumb
+		PosterURL: m.Thumb,
 		Subtitles: []subtitles.Subtitle{},
 	}
 
@@ -244,15 +244,6 @@ func (m *Movie) imgFile() string {
 	return filepath.Join(m.publicDir, "img", m.imgURL())
 }
 
-// PosterURL returns the image URL or the default image if the poster is not yet downloaded
-func (m *Movie) PosterURL() string {
-	// Check if the movie image exists
-	if _, err := os.Stat(m.imgFile()); os.IsNotExist(err) {
-		return ""
-	}
-	return m.imgURLPrefix + m.imgURL()
-}
-
 // getPolochonMovies returns an array of the user's polochon movies
 func getPolochonMovies(user *models.User, env *web.Env) ([]*Movie, error) {
 	movies := []*Movie{}

backend/torrents/handlers.go

@@ -7,6 +7,7 @@ import (
 	"sort"
 
 	"git.quimbo.fr/odwrtw/canape/backend/auth"
+	"git.quimbo.fr/odwrtw/canape/backend/models"
 	"git.quimbo.fr/odwrtw/canape/backend/web"
 	"github.com/gorilla/mux"
 	"github.com/odwrtw/papi"
@@ -46,11 +47,18 @@ func ListHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
 		return env.RenderError(w, err)
 	}
 
-	torrents, err := client.GetTorrents()
+	list, err := client.GetTorrents()
 	if err != nil {
 		return env.RenderError(w, err)
 	}
 
+	torrents := make([]*models.TorrentVideo, len(list))
+	for i, t := range list {
+		tv := models.NewTorrentVideo(&t)
+		tv.Update(env.Backend.Detailer, env.Log)
+		torrents[i] = tv
+	}
+
 	return env.RenderJSON(w, torrents)
 }
 

frontend/js/components/torrents/list.js

@@ -1,9 +1,7 @@
-import React, { useState } from "react";
-import PropTypes from "prop-types";
-import { useDispatch, useSelector } from "react-redux";
+import React from "react";
 
-import { prettySize } from "../../utils";
-import { addTorrent, removeTorrent } from "../../actions/torrents";
+import { AddTorrent } from "./list/addTorrent";
+import { Torrents } from "./list/torrents";
 
 export const TorrentList = () => {
   return (
@@ -15,108 +13,3 @@ export const TorrentList = () => {
     </div>
   );
 };
-
-const AddTorrent = () => {
-  const dispatch = useDispatch();
-  const [url, setUrl] = useState("");
-
-  const handleSubmit = (e) => {
-    e.preventDefault();
-    if (url === "") {
-      return;
-    }
-    dispatch(
-      addTorrent({
-        result: { url: url },
-      })
-    );
-    setUrl("");
-  };
-
-  return (
-    <form onSubmit={(e) => handleSubmit(e)}>
-      <input
-        type="text"
-        className="form-control mb-3 w-100"
-        placeholder="Add torrent URL"
-        onSubmit={handleSubmit}
-        value={url}
-        onChange={(e) => setUrl(e.target.value)}
-      />
-    </form>
-  );
-};
-
-const Torrents = () => {
-  const torrents = useSelector((state) => state.torrents.torrents);
-
-  if (torrents.length === 0) {
-    return (
-      <div className="jumbotron">
-        <h2>No torrents</h2>
-      </div>
-    );
-  }
-
-  return (
-    <div className="d-flex flex-wrap">
-      {torrents.map((torrent, index) => (
-        <Torrent key={index} torrent={torrent} />
-      ))}
-    </div>
-  );
-};
-
-const Torrent = ({ torrent }) => {
-  const dispatch = useDispatch();
-
-  var progressStyle = torrent.status.is_finished
-    ? "success"
-    : "info progress-bar-striped progress-bar-animated";
-  const progressBarClass = "progress-bar bg-" + progressStyle;
-
-  var percentDone = torrent.status.percent_done;
-  const started = percentDone !== 0;
-  if (started) {
-    percentDone = Number(percentDone).toFixed(1) + "%";
-  }
-
-  // Pretty sizes
-  const downloadedSize = prettySize(torrent.status.downloaded_size);
-  const totalSize = prettySize(torrent.status.total_size);
-  const downloadRate = prettySize(torrent.status.download_rate) + "/s";
-  return (
-    <div className="card w-100 mb-3">
-      <h5 className="card-header">
-        <span className="text text-break">{torrent.status.name}</span>
-        <span
-          className="fa fa-trash clickable pull-right"
-          onClick={() => dispatch(removeTorrent(torrent.status.id))}
-        ></span>
-      </h5>
-      <div className="card-body pb-0">
-        {started && (
-          <React.Fragment>
-            <div className="progress bg-light">
-              <div
-                className={progressBarClass}
-                style={{ width: percentDone }}
-                role="progressbar"
-                aria-valuenow={percentDone}
-                aria-valuemin="0"
-                aria-valuemax="100"
-              ></div>
-            </div>
-            <p>
-              {downloadedSize} / {totalSize} - {percentDone} - {downloadRate}
-            </p>
-          </React.Fragment>
-        )}
-        {!started && <p>Download not yet started</p>}
-      </div>
-    </div>
-  );
-};
-Torrent.propTypes = {
-  torrent: PropTypes.object.isRequired,
-};

frontend/js/components/torrents/list/addTorrent.js

@@ -0,0 +1,35 @@
+import React, { useState } from "react";
+import { useDispatch } from "react-redux";
+
+import { addTorrent } from "../../../actions/torrents";
+
+export const AddTorrent = () => {
+  const dispatch = useDispatch();
+  const [url, setUrl] = useState("");
+
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (url === "") {
+      return;
+    }
+    dispatch(
+      addTorrent({
+        result: { url: url },
+      })
+    );
+    setUrl("");
+  };
+
+  return (
+    <form onSubmit={(e) => handleSubmit(e)}>
+      <input
+        type="text"
+        className="form-control mb-3 w-100"
+        placeholder="Add torrent URL"
+        onSubmit={handleSubmit}
+        value={url}
+        onChange={(e) => setUrl(e.target.value)}
+      />
+    </form>
+  );
+};

frontend/js/components/torrents/list/progress.js

@@ -0,0 +1,47 @@
+import React from "react";
+import PropTypes from "prop-types";
+
+import { prettySize } from "../../../utils";
+
+export const Progress = ({ torrent }) => {
+  var progressStyle = torrent.status.is_finished
+    ? "success"
+    : "info progress-bar-striped progress-bar-animated";
+  const progressBarClass = "progress-bar bg-" + progressStyle;
+
+  var percentDone = torrent.status.percent_done;
+  const started = percentDone !== 0;
+  if (started) {
+    percentDone = Number(percentDone).toFixed(1) + "%";
+  }
+
+  // Pretty sizes
+  const downloadedSize = prettySize(torrent.status.downloaded_size);
+  const totalSize = prettySize(torrent.status.total_size);
+  const downloadRate = prettySize(torrent.status.download_rate) + "/s";
+  return (
+    <div className="card-body pb-0">
+      {started && (
+        <>
+          <div className="progress bg-light">
+            <div
+              className={progressBarClass}
+              style={{ width: percentDone }}
+              role="progressbar"
+              aria-valuenow={percentDone}
+              aria-valuemin="0"
+              aria-valuemax="100"
+            ></div>
+          </div>
+          <p>
+            {downloadedSize} / {totalSize} - {percentDone} - {downloadRate}
+          </p>
+        </>
+      )}
+      {!started && <p>Download not yet started</p>}
+    </div>
+  );
+};
+Progress.propTypes = {
+  torrent: PropTypes.object.isRequired,
+};

frontend/js/components/torrents/list/torrent.js

@@ -0,0 +1,45 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { useDispatch } from "react-redux";
+
+import { prettyEpisodeName } from "../../../utils";
+import { removeTorrent } from "../../../actions/torrents";
+
+import { Progress } from "./progress";
+
+export const Torrent = ({ torrent }) => {
+  const dispatch = useDispatch();
+
+  const torrentTitle = (torrent) => {
+    switch (torrent.type) {
+      case "movie":
+        return torrent.video ? torrent.video.title : torrent.status.name;
+      case "episode":
+        return torrent.video
+          ? prettyEpisodeName(
+              torrent.video.show_title,
+              torrent.video.season,
+              torrent.video.episode
+            )
+          : torrent.status.name;
+      default:
+        return torrent.status.name;
+    }
+  };
+
+  return (
+    <div className="card w-100 mb-3">
+      <h5 className="card-header">
+        <span className="text text-break">{torrentTitle(torrent)}</span>
+        <span
+          className="fa fa-trash clickable pull-right"
+          onClick={() => dispatch(removeTorrent(torrent.status.id))}
+        ></span>
+      </h5>
+      <Progress torrent={torrent} />
+    </div>
+  );
+};
+Torrent.propTypes = {
+  torrent: PropTypes.object.isRequired,
+};

frontend/js/components/torrents/list/torrents.js

@@ -0,0 +1,24 @@
+import React from "react";
+import { useSelector } from "react-redux";
+
+import { Torrent } from "./torrent";
+
+export const Torrents = () => {
+  const torrents = useSelector((state) => state.torrents.torrents);
+
+  if (torrents.length === 0) {
+    return (
+      <div className="jumbotron">
+        <h2>No torrents</h2>
+      </div>
+    );
+  }
+
+  return (
+    <div className="d-flex flex-wrap">
+      {torrents.map((torrent, index) => (
+        <Torrent key={index} torrent={torrent} />
+      ))}
+    </div>
+  );
+};