300 lines
6.8 KiB
Go
300 lines
6.8 KiB
Go
package handler
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/dustin/go-humanize"
|
|
"github.com/gorilla/mux"
|
|
"github.com/sirupsen/logrus"
|
|
"gopkg.in/h2non/filetype.v1"
|
|
|
|
"git.adphi.net/adphi/ytsflix/engine"
|
|
"git.adphi.net/adphi/ytsflix/templates"
|
|
"git.adphi.net/adphi/ytsflix/ytsclient"
|
|
)
|
|
|
|
var (
|
|
_ io.Reader = (*os.File)(nil)
|
|
)
|
|
|
|
type Handler struct {
|
|
engine *engine.Engine
|
|
clients map[string]int
|
|
yts ytsclient.Client
|
|
mutex sync.Mutex
|
|
storagePath string
|
|
}
|
|
|
|
type HomeData struct {
|
|
Categories map[string]map[string]Movie
|
|
}
|
|
|
|
type Movie struct {
|
|
Title string
|
|
Year int
|
|
Cover string
|
|
Link string
|
|
Synopsis string
|
|
Genre []string
|
|
Youtube string
|
|
Casting []Cast
|
|
}
|
|
|
|
type Cast struct {
|
|
Name string
|
|
Image string
|
|
}
|
|
|
|
type MovieData struct {
|
|
Title string
|
|
Link string
|
|
Subtitles map[string]string
|
|
}
|
|
|
|
func NewHandler(storagePath string) (*Handler, error) {
|
|
h := Handler{storagePath: storagePath}
|
|
var err error
|
|
h.engine, err = engine.NewEngine(storagePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
h.yts = ytsclient.NewClient()
|
|
h.clients = map[string]int{}
|
|
return &h, nil
|
|
}
|
|
|
|
func (h *Handler) Close() {
|
|
h.engine.Close()
|
|
}
|
|
|
|
func (h *Handler) Home(writer http.ResponseWriter, request *http.Request) {
|
|
hd := HomeData{Categories: map[string]map[string]Movie{}}
|
|
var mu sync.Mutex
|
|
var wg sync.WaitGroup
|
|
wg.Add(len(ytsclient.Genres))
|
|
for _, g := range ytsclient.Genres {
|
|
go func(genre ytsclient.Genre) {
|
|
defer wg.Done()
|
|
res, err := h.yts.List(&ytsclient.ListParams{
|
|
Genre: genre,
|
|
Limit: 50,
|
|
SortBy: ytsclient.Year,
|
|
OrderBy: ytsclient.Desc,
|
|
Quality: ytsclient.Quality1080p,
|
|
})
|
|
if err != nil {
|
|
logrus.WithField("genre", genre).Error(err)
|
|
return
|
|
}
|
|
ms := map[string]Movie{}
|
|
for _, m := range res {
|
|
ms[m.Title] = Movie{
|
|
Link: fmt.Sprintf("/movie/%d", m.ID),
|
|
Cover: m.MediumCoverImage,
|
|
}
|
|
}
|
|
if len(ms) >= 10 {
|
|
mu.Lock()
|
|
hd.Categories[string(genre)] = ms
|
|
mu.Unlock()
|
|
}
|
|
}(g)
|
|
}
|
|
wg.Wait()
|
|
t := templates.HomeTemplate()
|
|
writer.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
writer.WriteHeader(200)
|
|
t.Execute(writer, hd)
|
|
|
|
//fmt.Fprint(writer, html)
|
|
}
|
|
|
|
func (h *Handler) Movie(w http.ResponseWriter, r *http.Request) {
|
|
id := mux.Vars(r)["id"]
|
|
m, err := h.yts.Get(id, nil)
|
|
if err != nil {
|
|
sendError(w, err)
|
|
}
|
|
go func() { h.engine.Prepare(getMagnet(m)) }()
|
|
t := templates.MovieTemplate()
|
|
var cast []Cast
|
|
for _, c := range m.Cast {
|
|
cast = append(cast, Cast{Name: c.Name, Image: c.URLSmallImage})
|
|
}
|
|
md := Movie{
|
|
Title: m.Title,
|
|
Year: m.Year,
|
|
Genre: m.Genres,
|
|
Cover: m.MediumCoverImage,
|
|
Link: fmt.Sprintf("/torrent/%d", m.ID),
|
|
Synopsis: m.DescriptionFull,
|
|
Youtube: fmt.Sprintf("https://www.youtube.com/embed/%s", m.YtTrailerCode),
|
|
Casting: cast,
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
t.Execute(w, md)
|
|
}
|
|
|
|
func (h *Handler) Category(w http.ResponseWriter, r *http.Request) {
|
|
category := mux.Vars(r)["category"]
|
|
res, err := h.yts.List(&ytsclient.ListParams{Genre: ytsclient.Genre(category), Limit: 50, Page: 1})
|
|
if err != nil {
|
|
sendError(w, err)
|
|
}
|
|
mm := map[string]Movie{}
|
|
for _, m := range res {
|
|
mm[m.Title] = Movie{
|
|
Link: fmt.Sprintf("/movie/%d", m.ID),
|
|
Cover: m.MediumCoverImage,
|
|
}
|
|
}
|
|
d := struct {
|
|
Category string
|
|
Movies map[string]Movie
|
|
}{
|
|
Category: category,
|
|
Movies: mm,
|
|
}
|
|
t := templates.ListTemplate()
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
t.Execute(w, d)
|
|
}
|
|
|
|
func (h *Handler) Search(writer http.ResponseWriter, request *http.Request) {
|
|
vars := mux.Vars(request)
|
|
s := vars["search"]
|
|
res, err := h.yts.Search(s, &ytsclient.ListParams{Quality: ytsclient.Quality1080p})
|
|
if err != nil {
|
|
sendError(writer, err)
|
|
return
|
|
}
|
|
mm := map[string]Movie{}
|
|
for _, m := range res {
|
|
mm[m.Title] = Movie{
|
|
Link: fmt.Sprintf("/movie/%d", m.ID),
|
|
Cover: m.MediumCoverImage,
|
|
}
|
|
}
|
|
d := struct {
|
|
Category string
|
|
Movies map[string]Movie
|
|
}{
|
|
Category: fmt.Sprintf("Search: %s", s),
|
|
Movies: mm,
|
|
}
|
|
t := templates.ListTemplate()
|
|
writer.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
writer.WriteHeader(200)
|
|
t.Execute(writer, d)
|
|
}
|
|
|
|
func (h *Handler) Torrents(writer http.ResponseWriter, request *http.Request) {
|
|
id := mux.Vars(request)["id"]
|
|
m, err := h.yts.Get(id, nil)
|
|
if err != nil {
|
|
sendError(writer, err)
|
|
return
|
|
}
|
|
magnet := getMagnet(m)
|
|
mt, err := h.engine.Download(magnet)
|
|
if err != nil {
|
|
sendError(writer, err)
|
|
return
|
|
}
|
|
if err := mt.DownloadSubtitles(m.ImdbCode); err != nil {
|
|
logrus.Error(err)
|
|
}
|
|
cp := mt.Progress()
|
|
go func() {
|
|
for p := range cp {
|
|
hSize := humanize.Bytes(uint64(p.Size))
|
|
downloadSpeed := humanize.Bytes(p.DownloadSpeed) + "/s"
|
|
complete := humanize.Bytes(p.Downloaded)
|
|
logrus.Debugf("%s: Progress: %s / %s %s", mt.FileName, complete, hSize, downloadSpeed)
|
|
}
|
|
}()
|
|
link := fmt.Sprintf("/watch/%s", mt.FileName)
|
|
|
|
ss := map[string]string{}
|
|
for s, v := range mt.Subtitles {
|
|
ss[strings.Replace(s, ".vtt", "", -1)] = fmt.Sprintf("/subs/%s", v)
|
|
}
|
|
md := MovieData{Title: mt.FileName, Link: link, Subtitles: ss}
|
|
|
|
writer.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
writer.WriteHeader(200)
|
|
t := templates.WatchTemplate()
|
|
t.Execute(writer, md)
|
|
}
|
|
|
|
func (h *Handler) Serve(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
var mt *engine.MovieTorrent
|
|
var err error
|
|
movie := vars["movie"]
|
|
h.mutex.Lock()
|
|
h.clients[movie]++
|
|
h.mutex.Unlock()
|
|
if mt, err = h.engine.Get(movie); err != nil {
|
|
http.Error(w, "file not found", http.StatusBadRequest)
|
|
return
|
|
}
|
|
reader := mt.NewReader()
|
|
defer reader.Close()
|
|
defer func() {
|
|
h.mutex.Lock()
|
|
h.clients[movie]--
|
|
h.mutex.Unlock()
|
|
time.Sleep(5 * time.Second)
|
|
if h.clients[movie] == 0 {
|
|
logrus.Infof("The client closed the connection. Cleaning up: %s.", movie)
|
|
mt.Cancel()
|
|
}
|
|
}()
|
|
w.Header().Set("Connection", "Keep-Alive")
|
|
w.Header().Set("Content-Type", mt.MIME)
|
|
http.ServeContent(w, r, mt.FileName, time.Now(), reader)
|
|
}
|
|
|
|
func (h *Handler) Sub(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
m := vars["movie"]
|
|
s := vars["sub"]
|
|
logrus.Debugf("requesting subs: movie: %s, sub: %s", vars["movie"], vars["sub"])
|
|
f, err := os.Open(fmt.Sprintf("%s/%s/%s", h.storagePath, m, s))
|
|
if err != nil {
|
|
sendError(w, err)
|
|
return
|
|
}
|
|
mime := filetype.GetType(".vtt").MIME.Value
|
|
w.Header().Add("Context-Type", mime)
|
|
http.ServeContent(w, r, vars["sub"], time.Now(), f)
|
|
}
|
|
|
|
func sendError(writer http.ResponseWriter, err error) {
|
|
logrus.Error(err)
|
|
http.Error(writer, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
|
|
func getMagnet(m ytsclient.Movie) string {
|
|
var to *ytsclient.Torrent
|
|
for _, t := range m.Torrents {
|
|
if t.Quality == string(ytsclient.Quality1080p) {
|
|
to = &t
|
|
break
|
|
}
|
|
}
|
|
if to == nil {
|
|
to = &m.Torrents[0]
|
|
}
|
|
magnet, _ := m.Magnet(*to)
|
|
return magnet
|
|
}
|