134 lines
3.3 KiB
Go
134 lines
3.3 KiB
Go
package createuser
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"git.artlef.fr/bibliomane/internal/appcontext"
|
|
"git.artlef.fr/bibliomane/internal/i18nresource"
|
|
"git.artlef.fr/bibliomane/internal/model"
|
|
"git.artlef.fr/bibliomane/internal/myvalidator"
|
|
"golang.org/x/crypto/bcrypt"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// this method will hash the password
|
|
func CreateUser(ac appcontext.AppContext, username string, password string) error {
|
|
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
user := model.User{
|
|
Name: username,
|
|
Password: string(hashedPassword),
|
|
Admin: false,
|
|
}
|
|
return CreateUserWithHashedPassword(ac, &user)
|
|
}
|
|
|
|
// only call this method with hashed password
|
|
func CreateUserWithHashedPassword(ac appcontext.AppContext, userToCreate *model.User) error {
|
|
var existingUser model.User
|
|
err := ac.Db.Where("name = ?", userToCreate.Name).First(&existingUser).Error
|
|
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
if err == nil {
|
|
return myvalidator.HttpError{
|
|
StatusCode: http.StatusInternalServerError,
|
|
Err: errors.New(i18nresource.GetTranslatedMessage(&ac, "UserAlreadyExists")),
|
|
}
|
|
}
|
|
return ac.Db.Model(&model.User{}).Save(&userToCreate).Error
|
|
}
|
|
|
|
func CreateDefaultUsers(ac appcontext.AppContext) error {
|
|
usersPasswordMap, err := createNormalUsersMap(ac)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = createDefaultUsersFromMap(ac, usersPasswordMap, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
adminUsersPasswordMap, err := createDefaultUsersMap(ac, ac.Config.AddAdminUser)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return createDefaultUsersFromMap(ac, adminUsersPasswordMap, true)
|
|
}
|
|
|
|
func createNormalUsersMap(ac appcontext.AppContext) (map[string]string, error) {
|
|
usersPasswordMap, err := createDefaultUsersMap(ac, ac.Config.AddUser)
|
|
if err != nil {
|
|
return usersPasswordMap, err
|
|
}
|
|
_, ok := usersPasswordMap[ac.Config.DemoUsername]
|
|
if !ok {
|
|
usersPasswordMap[ac.Config.DemoUsername] = ""
|
|
}
|
|
return usersPasswordMap, nil
|
|
}
|
|
|
|
func createDefaultUsersMap(ac appcontext.AppContext, adduser []string) (map[string]string, error) {
|
|
usersPasswordMap := make(map[string]string)
|
|
for _, s := range adduser {
|
|
splittedString := strings.Split(s, ":")
|
|
if len(splittedString) < 2 {
|
|
return usersPasswordMap,
|
|
fmt.Errorf(i18nresource.GetTranslatedMessage(&ac, "ErrorWhenCreatingUserFromStr"), s)
|
|
}
|
|
usersPasswordMap[splittedString[0]] = splittedString[1]
|
|
}
|
|
return usersPasswordMap, nil
|
|
}
|
|
|
|
func createDefaultUsersFromMap(
|
|
ac appcontext.AppContext,
|
|
usersPasswordMap map[string]string,
|
|
isAdmin bool) error {
|
|
|
|
var existingUsers []model.User
|
|
err := ac.Db.Where("name IN ?", mapToArrayKey(usersPasswordMap)).Find(&existingUsers).Error
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for username, password := range usersPasswordMap {
|
|
if isInExistingUsers(username, existingUsers) {
|
|
continue
|
|
}
|
|
|
|
user := model.User{
|
|
Name: username,
|
|
Password: password,
|
|
Admin: isAdmin,
|
|
}
|
|
err = CreateUserWithHashedPassword(ac, &user)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func isInExistingUsers(username string, existingUsers []model.User) bool {
|
|
for _, existingUser := range existingUsers {
|
|
if username == existingUser.Name {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func mapToArrayKey(m map[string]string) []string {
|
|
var a []string
|
|
for k := range m {
|
|
a = append(a, k)
|
|
}
|
|
return a
|
|
}
|