go-skeletor/controller/user.go

package controller

import (
	"arno/skeletor/config"
	"arno/skeletor/entity"
	"arno/skeletor/repository"
	"arno/skeletor/service"
	"arno/skeletor/tool"
	"net/http"
	"strconv"

	"github.com/google/uuid"
	"github.com/martini-contrib/render"
	"github.com/martini-contrib/sessions"
)

func UserList(ctn *service.Container, session sessions.Session, req *http.Request, r render.Render) {
	myconfig := config.Must(ctn)
	mydb := repository.Must(ctn)

	var users []entity.User
	mydb.Find(&users)

	rendermap := map[string]interface{}{
		"conf":         myconfig,
		"session":      tool.Rendersession(session),
		"useheader":    true,
		"usesidebar":   true,
		"usecontainer": true,
		"users":        users,
	}

	r.HTML(200, "user/list", rendermap)
}

func UserSubmit(ctn *service.Container, session sessions.Session, req *http.Request, r render.Render) {
	myconfig := config.Must(ctn)
	mydb := repository.Must(ctn)

	var user entity.User
	var myerr string
	var isvalid bool

	user.Avatar = "noavatar.png"
	user.Apikey = uuid.New().String()
	user.Role = 50

	if req.Method == http.MethodPost {
		myerr, isvalid = UserValidate(req)
		if isvalid {
			req.ParseForm()

			// Encrypter le password
			salt := []byte("example key 1234")
			password := tool.Encrypt(salt, req.Form.Get("password"))

			user.Login = req.Form.Get("login")
			user.Password = password
			user.Salt = salt
			user.Role, _ = strconv.Atoi(req.Form.Get("role"))
			user.Avatar = req.Form.Get("avatar")
			user.Firstname = req.Form.Get("firstname")
			user.Lastname = req.Form.Get("lastname")
			user.Email = req.Form.Get("email")
			user.Apikey = req.Form.Get("apikey")

			err := mydb.Create(&user).Error

			if err == nil {
				r.Redirect(myconfig.AppRoutes["userlist"])
			} else {
				myerr = "Cet utilisateur existe déjà avec soit ce login / cet email / cette apikey<br>" + err.Error()
			}
		}

		// Si erreur on reinit le password à vide
		user.Password = ""
	}

	rendermap := map[string]interface{}{
		"conf":         myconfig,
		"session":      tool.Rendersession(session),
		"useheader":    true,
		"usesidebar":   true,
		"usecontainer": true,
		"mode":         "submit",
		"user":         user,
		"error":        myerr,
	}

	r.HTML(200, "user/edit", rendermap)
}

func UserUpdate(ctn *service.Container, session sessions.Session, req *http.Request, r render.Render, id string, from string) {
	myconfig := config.Must(ctn)
	mydb := repository.Must(ctn)

	var user entity.User
	var myerr string
	var isvalid bool

	result := mydb.First(&user, "id = ?", id)
	if result.RowsAffected == 0 {
		r.Redirect(myconfig.AppRoutes["userlist"])
	}

	if req.Method == http.MethodPost {
		myerr, isvalid = UserValidate(req)
		if isvalid {
			req.ParseForm()

			// Encrypter le password
			if req.Form.Get("password") != "" {
				salt := []byte("example key 1234")
				password := tool.Encrypt(salt, req.Form.Get("password"))
				user.Password = password
				user.Salt = salt
			}

			user.Firstname = req.Form.Get("firstname")
			user.Lastname = req.Form.Get("lastname")
			user.Email = req.Form.Get("email")
			user.Apikey = req.Form.Get("apikey")
			user.Avatar = req.Form.Get("avatar")

			if from == "update" {
				user.Role, _ = strconv.Atoi(req.Form.Get("role"))
			}

			err := mydb.Save(&user).Error

			if err == nil {
				userid := session.Get("Userid").(string)
				if strconv.FormatUint(uint64(user.Id), 10) == userid {
					RefreshSession(session, user)
				}

				if from == "update" {
					r.Redirect(myconfig.AppRoutes["userlist"])
				} else {
					r.Redirect(myconfig.AppRoutes["home"])
				}

			} else {
				myerr = "Cet utilisateur existe déjà avec soit cet email / cette apikey" + err.Error()
			}
		}
	}

	usesidebar := true
	if from == "profil" {
		usesidebar = false
	}
	rendermap := map[string]interface{}{
		"conf":         myconfig,
		"session":      tool.Rendersession(session),
		"useheader":    true,
		"usesidebar":   usesidebar,
		"usecontainer": true,
		"mode":         from,
		"user":         user,
		"error":        myerr,
	}

	r.HTML(200, "user/edit", rendermap)
}

func UserDelete(ctn *service.Container, session sessions.Session, req *http.Request, r render.Render, id string) {
	myconfig := config.Must(ctn)
	mydb := repository.Must(ctn)

	var user entity.User
	result := mydb.First(&user, "id = ?", id)
	if result.RowsAffected == 0 {
		r.Redirect(myconfig.AppRoutes["userlist"])
	}

	var myerr string
	err := mydb.Delete(&user).Error
	if err == nil {
		r.Redirect(myconfig.AppRoutes["userlist"])
	} else {
		myerr = "Problème à la suppression de l'enregistrement<br>" + err.Error()
	}

	rendermap := map[string]interface{}{
		"conf":         myconfig,
		"session":      tool.Rendersession(session),
		"useheader":    true,
		"usesidebar":   true,
		"usecontainer": true,
		"mode":         "update",
		"user":         user,
		"error":        myerr,
	}

	r.HTML(200, "user/edit", rendermap)
}

func UserValidate(req *http.Request) (string, bool) {
	req.ParseForm()

	if len(req.Form.Get("login")) < 5 {
		myerr := "Votre Login doit comporter au minimum 5 caractères"
		return myerr, false
	}

	if req.Form.Get("password") != "" {
		if !tool.IsPasswordValid(req.Form.Get("password")) {
			myerr := "Mot de passe invalide<br><li>Minium 7 caractères</li><li>Minimum une majuscule</li><li>Minimum une minuscule</li><li>Minimum un chiffre</li><li>Minimum un caractère spécial</li>"
			return myerr, false
		}
	}

	return "", true
}