canape/backend/torrents/handlers.go

package torrents

import (
	"encoding/json"
	"errors"
	"net/http"
	"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"
	polochon "github.com/odwrtw/polochon/lib"
	"github.com/sirupsen/logrus"
)

// DownloadHandler downloads a movie via polochon
func DownloadHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	torrent := &papi.Torrent{}
	err := json.NewDecoder(r.Body).Decode(torrent)
	if err != nil {
		return env.RenderError(w, errors.New("failed to get the url"))
	}

	user := auth.GetCurrentUser(r, env.Log)

	client, err := user.NewPapiClient(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

	err = client.AddTorrent(torrent)
	if err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderOK(w, "Torrent added")
}

// ListHandler lists torrents of a polochon
func ListHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	user := auth.GetCurrentUser(r, env.Log)

	client, err := user.NewPapiClient(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

	list, err := client.GetTorrents()
	if err != nil {
		return env.RenderError(w, err)
	}

	torrents := models.NewTorrentVideos(env.Backend.Detailer, env.Database, env.Log, list)
	return env.RenderJSON(w, torrents)
}

// RemoveHandler removes a torrents via polochon
func RemoveHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	user := auth.GetCurrentUser(r, env.Log)

	// Get the torrent ID from the URL
	vars := mux.Vars(r)
	torrentID := vars["id"]

	client, err := user.NewPapiClient(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

	err = client.RemoveTorrent(torrentID)
	if err != nil {
		return env.RenderError(w, err)
	}

	return env.RenderOK(w, "Torrent removed")
}

// SearchHandler search for torrents
func SearchHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "torrents.SearchHandler",
	})

	vars := mux.Vars(r)
	searchType := vars["type"]
	searchStr := vars["search"]

	// Get the appropriate torrenters
	var torrenters []polochon.Torrenter
	switch searchType {
	case "movies":
		torrenters = env.Config.Movie.Torrenters
	case "shows":
		torrenters = env.Config.Show.Torrenters
	default:
		return env.RenderError(w, errors.New("invalid search type"))
	}

	log.Debugf("searching for %s torrents for the query %q", searchType, searchStr)

	// Search for torrents
	results := []*polochon.Torrent{}
	for _, torrenter := range torrenters {
		torrents, err := torrenter.SearchTorrents(searchStr)
		if err != nil {
			log.Warn(err)
			continue
		}

		if torrents == nil {
			continue
		}

		results = append(results, torrents...)
	}

	// Sort by seeds
	sort.Slice(results, func(i, j int) bool {
		// Let's avoid the panic while sorting
		if results[i].Result == nil {
			results[i].Result = &polochon.TorrentResult{}
		}
		if results[j].Result == nil {
			results[j].Result = &polochon.TorrentResult{}
		}

		return results[i].Result.Seeders > results[j].Result.Seeders
	})

	return env.RenderJSON(w, results)
}