canape/backend/admins/users.go

package admin

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"net/http"

	"git.quimbo.fr/odwrtw/canape/backend/events"
	"git.quimbo.fr/odwrtw/canape/backend/models"
	"git.quimbo.fr/odwrtw/canape/backend/tokens"
	"git.quimbo.fr/odwrtw/canape/backend/web"

	"github.com/gorilla/mux"
	"github.com/sirupsen/logrus"
)

// GetUsersHandler returns the user list
func GetUsersHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "admin.GetUsersHandler",
	})

	log.Debug("Getting users")

	// Get all users
	users, err := models.GetAllUsers(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

	// Get all polochons
	polochons, err := models.GetAllPolochons(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

	// Map the polochons
	polochonMap := map[string]*models.Polochon{}
	for _, p := range polochons {
		polochonMap[p.ID] = p
	}

	// Fill the users with the polochons
	for _, u := range users {
		if u.PolochonID.Valid == false {
			continue
		}
		u.Polochon = polochonMap[u.PolochonID.String]
	}

	return env.RenderJSON(w, users)
}

// GenerateUserToken generates a user token
func GenerateUserToken(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "admin.GenerateUserToken",
	})
	log.Debug("Generating user token")

	vars := mux.Vars(r)
	username := vars["username"]

	user, err := models.GetUser(env.Database, username)
	if err != nil {
		return err
	}

	t, err := env.Auth.GenerateJWTToken(r, user)
	if err != nil {
		return err
	}
	t.Description = "generated token for polochon"

	if err := t.Add(env.Database); err != nil {
		return err
	}

	return env.RenderJSON(w, t)
}

// UpdateUserHandler updates the user data
func UpdateUserHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "admin.UpdateUserHandler",
	})

	var data struct {
		ID                string `json:"userId"`
		Admin             bool   `json:"admin"`
		Activated         bool   `json:"activated"`
		PolochonID        string `json:"polochonId"`
		PolochonToken     string `json:"polochonToken"`
		PolochonActivated bool   `json:"polochonActivated"`
		Password          string `json:"password"`
	}
	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
		return err
	}

	if data.ID == "" {
		return env.RenderError(w, fmt.Errorf("Empty user id"))
	}

	user, err := models.GetUserByID(env.Database, data.ID)
	if err != nil {
		return err
	}

	user.Admin = data.Admin
	user.Activated = data.Activated
	user.PolochonActivated = data.PolochonActivated
	user.PolochonID = sql.NullString{
		String: data.PolochonID,
		Valid:  true,
	}
	user.Token = data.PolochonToken

	if data.Password != "" {
		// Update the user config
		var err error
		user.Hash, err = env.Auth.GenHash(data.Password)
		if err != nil {
			return err
		}
	}

	log.Debugf("updating user")

	// Need to unsubscribe the user from all the eventers
	events.Unsubscribe(user)

	// Save the user with the new configurations
	if err := user.Update(env.Database); err != nil {
		return err
	}

	return env.RenderOK(w, "user updated")
}

// DeleteUserHandler deletes a user from the database
func DeleteUserHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "admin.DeleteUserHandler",
	})

	vars := mux.Vars(r)
	username := vars["username"]

	user, err := models.GetUser(env.Database, username)
	if err != nil {
		return err
	}
	log = log.WithField("username", user.Name)

	log.Infof("deleting movies wishlist")
	if err := models.DeleteUserMoviesWishlist(env.Database, user.ID); err != nil {
		return err
	}

	log.Infof("deleting shows wishlist")
	if err := models.DeleteUserShowsWishlist(env.Database, user.ID); err != nil {
		return err
	}

	log.Infof("deleting user tokens")
	if err := tokens.DeleteUserTokens(env.Database, user.Name); err != nil {
		return err
	}

	log.Infof("deleting user")
	if err := user.Delete(env.Database); err != nil {
		return err
	}

	return env.RenderOK(w, "user deleted")
}