canape/backend/polochons/handlers.go

package polochons

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

	"git.quimbo.fr/odwrtw/canape/backend/auth"
	"git.quimbo.fr/odwrtw/canape/backend/users"
	"git.quimbo.fr/odwrtw/canape/backend/web"
	"github.com/gorilla/mux"
	"github.com/sirupsen/logrus"
)

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

	log.Debug("Getting public polochons")

	polochons, err := backend.GetAllPolochons(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

	type MinimalPolochon struct {
		ID   string `json:"id"`
		Name string `json:"name"`
		URL  string `json:"url"`
	}

	mPolochons := []*MinimalPolochon{}
	for _, p := range polochons {
		mPolochons = append(mPolochons, &MinimalPolochon{
			ID:   p.ID,
			Name: p.Name,
			URL:  p.URL,
		})
	}

	return env.RenderJSON(w, mPolochons)
}

// GetPolochonsHandler returns the list of polochons and their users
func GetPolochonsHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "polochons.GetPolochonsHandler",
	})

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, fmt.Errorf("invalid user type"))
	}

	log.Debug("Getting polochons")

	polochons, err := backend.GetAllPolochonsByUser(env.Database, user.ID)
	if err != nil {
		return env.RenderError(w, err)
	}

	for _, p := range polochons {
		users, err := users.GetPolochonUsers(env.Database, p.ID)
		if err != nil {
			return env.RenderError(w, err)
		}
		p.Users = users
	}

	return env.RenderJSON(w, polochons)
}

// NewPolochonHandler handles the creation of a new polochon
func NewPolochonHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "polochons.NewPolochonHandler",
	})

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, fmt.Errorf("invalid user type"))
	}

	var data struct {
		Name  string `json:"name"`
		URL   string `json:"url"`
		Token string `json:"token"`
	}
	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
		return env.RenderError(w, err)
	}

	for _, c := range []string{
		data.Name,
		data.URL,
		data.Token,
	} {
		if c == "" {
			return env.RenderError(w, fmt.Errorf("name, url and token are mandatory fields"))
		}
	}
	log.Debugf("creating new polochon ...")

	p := backend.Polochon{
		Name:    data.Name,
		URL:     data.URL,
		Token:   data.Token,
		AdminID: user.ID,
	}

	if err := p.Add(env.Database); err != nil {
		return env.RenderError(w, err)
	}
	log.Debugf("new polochon %s created ...", data.Name)

	return env.RenderOK(w, "Polochon created")
}

// EditPolochonHandler handles the edit of a polochon
func EditPolochonHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "polochons.EditPolochonHandler",
	})
	log.Debugf("editing polochon ...")

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, fmt.Errorf("invalid user type"))
	}

	// Get the polochon
	vars := mux.Vars(r)
	id := vars["id"]
	p, err := backend.GetPolochonByID(env.Database, id)
	if err != nil {
		return env.RenderError(w, err)
	}

	// Check that the logged-in user is the polochon admin
	if p.AdminID != user.ID {
		return env.RenderError(w, fmt.Errorf("forbidden"))
	}

	var data struct {
		Name  string `json:"name"`
		URL   string `json:"url"`
		Token string `json:"token"`
	}
	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
		return env.RenderError(w, err)
	}

	for _, c := range []string{
		data.Name,
		data.URL,
		data.Token,
	} {
		if c == "" {
			return env.RenderError(w, fmt.Errorf("name, url and token are mandatory fields"))
		}
	}
	p.Name = data.Name
	p.URL = data.URL
	p.Token = data.Token

	err = p.Update(env.Database)
	if err != nil {
		return env.RenderError(w, err)
	}

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

// PolochonDeactivateUserHandler handles the users of a polochon
func PolochonDeactivateUserHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	if err := PolochonActivateUser(env, w, r, false); err != nil {
		return env.RenderError(w, err)
	}
	return env.RenderOK(w, "User deactivated")
}

// PolochonActivateUserHandler handles the users of a polochon
func PolochonActivateUserHandler(env *web.Env, w http.ResponseWriter, r *http.Request) error {
	if err := PolochonActivateUser(env, w, r, true); err != nil {
		return env.RenderError(w, err)
	}
	return env.RenderOK(w, "User activated")
}

// PolochonActivateUser activates or deactivate a user's polochon
func PolochonActivateUser(env *web.Env, w http.ResponseWriter, r *http.Request, activated bool) error {
	log := env.Log.WithFields(logrus.Fields{
		"function": "polochons.PolochonUserHandler",
	})
	log.Debugf("editing polochon users ...")

	v := auth.GetCurrentUser(r, env.Log)
	user, ok := v.(*users.User)
	if !ok {
		return env.RenderError(w, fmt.Errorf("invalid user type"))
	}

	// Get the polochon
	vars := mux.Vars(r)
	id := vars["id"]
	p, err := backend.GetPolochonByID(env.Database, id)
	if err != nil {
		return env.RenderError(w, err)
	}

	// Check that the logged-in user is the polochon admin
	if p.AdminID != user.ID {
		return env.RenderError(w, fmt.Errorf("forbidden"))
	}

	// Get the user
	userID := vars["user_id"]
	u, err := users.GetByID(env.Database, userID)
	if err != nil {
		return env.RenderError(w, err)
	}

	u.PolochonActivated = activated

	return u.Update(env.Database)
}