access-handler/handlers/user.go

package handlers

import (
	"errors"
	"fmt"
	"net/http"
	"strconv"

	"gitea.tecamino.com/paadi/access-handler/internal/utils"
	"gitea.tecamino.com/paadi/access-handler/models"
	"github.com/gin-gonic/gin"
)

func (aH *AccessHandler) AddUserTable() error {
	return aH.dbHandler.AddNewTable(models.User{})
}

func (aH *AccessHandler) AddDefaultUser() (err error) {
	name := "admin"
	role := "admin"
	email := "zuercher@tecamino.ch"

	// Check if a user with this email already exists
	if err := aH.dbHandler.Exists(&models.User{}, "email", email, false); err == nil {
		aH.logger.Debug("AddDefaultUser", "user email "+email+" exists already")
		// Found a user → skip create
		return nil
	}

	// Create default settings for the new user
	settings := models.Settings{}
	aH.logger.Debug("AddDefaultUser", "set default quasar settings")
	settings.DefaultQuasarSettings()

	// Insert default admin user into the database
	aH.dbHandler.AddNewColum(&models.User{
		Name:     name,
		Role:     role,
		Email:    email,
		Password: "$2a$10$sZZOWBP8DSFLrLFQNoXw8OsEEr0tez1B8lPzKCHofaHg6PMNxx1pG",
		Settings: settings,
	})
	return
}

func (aH *AccessHandler) AddUser(c *gin.Context) {
	var user models.User
	err := c.BindJSON(&user)
	if err != nil {
		aH.logger.Error("AddUser", err)
		c.JSON(http.StatusInternalServerError, models.NewJsonErrorResponse(err))
		return
	}

	if !user.IsValid() {
		aH.logger.Error("AddUser", "user empty")
		c.JSON(http.StatusBadRequest, models.NewJsonMessageResponse("user empty"))
		return
	}

	// Check if a user with this email already exists
	if err := aH.dbHandler.Exists(&models.User{}, "email", user.Email, false); err == nil {
		// Found a user → skip create
		aH.logger.Error("AddUser", "user with email "+user.Email+" already exists")
		c.JSON(http.StatusBadRequest, models.NewJsonMessageResponse(fmt.Sprintf("user with email %s already exists", user.Email)))
		return
	}

	if !utils.IsValidEmail(user.Email) {
		aH.logger.Error("AddUser", "not valid email address")
		c.JSON(http.StatusBadRequest, models.NewJsonErrorResponse(errors.New("not valid email address")))
		return
	}

	// Hash the provided password before saving
	hash, err := utils.HashPassword(user.Password)
	if err != nil {
		aH.logger.Error("AddUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	aH.logger.Debug("AddUser", "add default quasar user setting ")
	user.Settings.DefaultQuasarSettings()

	aH.logger.Debug("AddUser", "add new user "+user.Name+" with role "+user.Role)

	// Insert the new user record
	aH.dbHandler.AddNewColum(&models.User{
		Name:     user.Name,
		Role:     user.Role,
		Email:    user.Email,
		Password: hash,
		Settings: user.Settings,
	})

	c.JSON(http.StatusOK, gin.H{
		"message": fmt.Sprintf("user '%s' successfully added", user.Name),
	})
}

func (aH *AccessHandler) GetUser(c *gin.Context) {
	var i int
	var err error

	id := c.Query("id")
	if id == "undefined" || id == "null" || id == "" {
		i = 0
	} else {
		i, err = strconv.Atoi(id)
		if err != nil {
			aH.logger.Error("GetUser", err)
			c.JSON(http.StatusInternalServerError, nil)
			return
		}
	}

	var users []models.User
	err = aH.dbHandler.GetById(&users, uint(i))
	if err != nil {
		aH.logger.Error("GetUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}
	c.JSON(http.StatusOK, users)
}

func (aH *AccessHandler) UpdateUser(c *gin.Context) {
	var user models.User
	if err := c.BindJSON(&user); err != nil {
		aH.logger.Error("UpdateUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}
	err := aH.dbHandler.UpdateValuesById(&user, user.Id)
	if err != nil {
		aH.logger.Error("UpdateUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}
	c.JSON(http.StatusOK, models.NewJsonMessageResponse("successfully updated user '"+user.Email+"'"))
}

func (aH *AccessHandler) DeleteUser(c *gin.Context) {
	queryId := c.Query("id")

	if queryId == "" || queryId == "null" || queryId == "undefined" {
		aH.logger.Error("DeleteUser", "id query missing or wrong value: "+queryId)
		c.JSON(http.StatusBadRequest, gin.H{
			"message": "id query missing or wrong value: " + queryId,
		})
		return
	}

	var request struct {
		Ids []int `json:"ids"`
	}

	err := c.BindJSON(&request)
	if err != nil {
		aH.logger.Error("DeleteUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	if len(request.Ids) == 0 {
		aH.logger.Error("DeleteUser", "no ids given to be deleted")
		c.JSON(http.StatusBadRequest, gin.H{
			"message": "no ids given to be deleted",
		})
		return
	}

	var ownId string
	removeIds := make([]uint, len(request.Ids))
	for i, id := range request.Ids {
		if queryId == fmt.Sprint(id) {
			ownId = queryId
			continue
		}
		removeIds[i] = uint(id)
	}

	if ownId != "" {
		aH.logger.Error("DeleteUser", "can not delete logged in member id: "+queryId)
		c.JSON(http.StatusBadRequest, gin.H{
			"message": "can not delete logged in member id: " + queryId,
			"id":      queryId,
		})
		return
	}

	err = aH.dbHandler.DeleteById(&models.User{}, removeIds...)
	if err != nil {
		aH.logger.Error("DeleteUser", err)
		c.JSON(http.StatusInternalServerError, nil)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message": "member(s) deleted",
	})
}