canape/src/internal/movies/handlers.go

package movies

import (
	"fmt"
	"net"
	"net/http"
	"net/url"
	"path/filepath"

	"github.com/odwrtw/papi"
	"github.com/odwrtw/polochon/lib"
	"github.com/odwrtw/polochon/modules/mock"
	traktdetailer "github.com/odwrtw/polochon/modules/trakttv"
	"github.com/odwrtw/trakttv"

	"gitlab.quimbo.fr/odwrtw/canape-sql/src/internal/auth"
	"gitlab.quimbo.fr/odwrtw/canape-sql/src/internal/config"
	"gitlab.quimbo.fr/odwrtw/canape-sql/src/internal/users"
	"gitlab.quimbo.fr/odwrtw/canape-sql/src/internal/web"
)

var ErrPolochonUnavailable = fmt.Errorf("Invalid polochon address")

func getPolochonMovies(user *users.User) ([]*Movie, error) {
	movies := []*Movie{}

	var polochonConfig config.UserPolochon
	err := user.GetConfig("polochon", &polochonConfig)
	if err != nil {
		return movies, err
	}

	client, err := papi.New(polochonConfig.URL)
	if err != nil {
		return movies, err
	}

	if polochonConfig.Token != "" {
		client.SetToken(polochonConfig.Token)
	}

	pmovies, err := client.GetMovies()
	if err != nil {
		// Catch network error for accessing specified polochon address
		if uerr, ok := err.(*url.Error); ok {
			if nerr, ok := uerr.Err.(*net.OpError); ok {
				if nerr.Op == "dial" {
					return movies, ErrPolochonUnavailable
				}

			}
		}
		return movies, err
	}
	for _, pmovie := range pmovies {
		movies = append(movies, New(pmovie.ImdbID))
	}
	return movies, nil
}

func FromPolochon(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	v := auth.GetCurrentUser(r, env.Log)

	user, ok := v.(*users.User)
	if !ok {
		return fmt.Errorf("invalid user type")
	}
	web.SetData(r, "user", user)

	movies, err := getPolochonMovies(user)

	if err != nil {
		// Catch network error for accessing specified polochon address
		if err == ErrPolochonUnavailable {
			web.SetData(r, "error", "Invalid address")
			return env.Rends(w, r, "movies/library")
		}

		return err
	}

	//TODO use configurable detailer
	// detailer, err := tmdb.New(&tmdb.Params{"57be344f84917b3f32c68a678f1482eb"})
	detailer, _ := mock.NewDetailer(nil)
	if err != nil {
		return err
	}

	for _, m := range movies {
		m.Detailers = []polochon.Detailer{detailer}
		err := m.GetDetails(env.Database, filepath.Join(env.Config.PublicDir, "img", "movies"), env.Log)
		if err != nil {
			env.Log.Error(err)
		}
	}

	env.Log.Info(movies)

	return nil
}

func ExplorePopular(env *web.Env, w http.ResponseWriter, r *http.Request) error {

	queryOption := trakttv.QueryOption{
		ExtendedInfos: []trakttv.ExtendedInfo{
			trakttv.ExtendedInfoMin,
		},
		Pagination: trakttv.Pagination{
			Page:  1,
			Limit: 20,
		},
	}
	trakt := trakttv.New(env.Config.TraktTVClientID)
	trakt.Endpoint = trakttv.ProductionEndpoint
	tmovies, err := trakt.PopularMovies(queryOption)
	if err != nil {
		return err
	}

	detailer, err := traktdetailer.New(&traktdetailer.Params{env.Config.TraktTVClientID})
	if err != nil {
		return err
	}

	movies := []*Movie{}
	ids := []string{}
	for _, m := range tmovies {
		movie := New(m.IDs.ImDB)
		movie.Detailers = []polochon.Detailer{detailer}
		err := movie.GetDetails(env.Database, filepath.Join(env.Config.PublicDir, "img", "movies"), env.Log)
		if err != nil {
			env.Log.Error(err)
			continue
		}
		movies = append(movies, movie)
		ids = append(ids, m.IDs.ImDB)
	}
	web.SetData(r, "movies", movies)
	return env.Rends(w, r, "movies/library")
}