backend/dbhandler/mongo/user_pass_authentication.go

package mongo

import (
	"context"

	"git.acooldomain.co/server-manager/backend/dbhandler"
	"git.acooldomain.co/server-manager/backend/models"
	"github.com/google/uuid"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"golang.org/x/crypto/bcrypt"
)

type AuthUser struct {
	Username       string            `bson:"username"`
	Nickname       string            `bson:"nickname"`
	HashedPassword string            `bson:"hashed_password"`
	Permissions    models.Permission `bson:"permissions"`
	MaxOwnedSevers uint              `bson:"max_owned_severs"`
	Email          string            `bson:"email"`
}

type UserPassAuthenticationDbHandler struct {
	dbhandler.UserPassAuthanticationDbHandler
	collection *mongo.Collection
}

func (i *UserPassAuthenticationDbHandler) ListUsers(ctx context.Context) ([]models.User, error) {
	cursor, err := i.collection.Find(ctx, bson.M{})
	if err != nil {
		return nil, err
	}

	var authUsers []AuthUser

	cursor.All(ctx, &authUsers)

	modelUsers := make([]models.User, len(authUsers))
	for i, authUser := range authUsers {
		modelUsers[i] = models.User{
			Username:        authUser.Username,
			Nickname:        authUser.Nickname,
			Email:           authUser.Email,
			MaxOwnedServers: authUser.MaxOwnedSevers,
			Permissions:     authUser.Permissions,
		}
	}

	return modelUsers, nil
}

func (i *UserPassAuthenticationDbHandler) AuthenticateUser(ctx context.Context, username string, password string) (*models.User, error) {
	var user AuthUser
	err := i.collection.FindOne(ctx, bson.M{"username": username}).Decode(&user)
	if err != nil {
		return nil, err
	}

	err = bcrypt.CompareHashAndPassword([]byte(user.HashedPassword), []byte(password))
	if err != nil {
		return nil, err
	}

	return &models.User{
		Username:        user.Username,
		Nickname:        user.Nickname,
		Email:           user.Email,
		MaxOwnedServers: user.MaxOwnedSevers,
		Permissions:     user.Permissions,
	}, nil
}

func (i *UserPassAuthenticationDbHandler) CreateUser(
	ctx context.Context,
	username string,
	password string,
	permissions models.Permission,
	email string,
	maxOwnedServers uint,
) error {
	hashedPassword, err := dbhandler.HashPassword(password)
	if err != nil {
		return err
	}

	_, err = i.collection.InsertOne(ctx, &AuthUser{
		Username:       username,
		HashedPassword: hashedPassword,
		Permissions:    permissions,
		Email:          email,
		MaxOwnedSevers: maxOwnedServers,
	})

	return err
}

func (i *UserPassAuthenticationDbHandler) CountUsers(ctx context.Context) (uint, error) {
	count, err := i.collection.CountDocuments(ctx, bson.M{})
	if err != nil {
		return 0, err
	}
	return uint(count), nil
}

func (i *UserPassAuthenticationDbHandler) RemoveUser(ctx context.Context, username string) error {
	_, err := i.collection.DeleteOne(
		ctx,
		bson.M{
			"username": username,
		},
	)

	return err
}

func (i *UserPassAuthenticationDbHandler) SetPermissions(
	ctx context.Context,
	username string,
	permissions models.Permission,
) error {
	_, err := i.collection.UpdateOne(
		ctx,
		bson.M{
			"username": username,
		},
		bson.M{
			"$set": bson.M{
				"permissions": permissions,
			},
		},
	)

	return err
}

func NewUserPassAuthHandler(config models.MongoDBConfig) (*UserPassAuthenticationDbHandler, error) {
	collection, err := getMongoCollection(config)
	if err != nil {
		return nil, err
	}

	return &UserPassAuthenticationDbHandler{
		collection: collection,
	}, nil
}

type InviteToken struct {
	Email       string            `bson:"email"`
	Token       string            `bson:"token"`
	Permissions models.Permission `bson:"permissions"`
}

type InviteTokenDbHandler struct {
	dbhandler.InviteTokenDbHandler
	collection *mongo.Collection
}

func (i *InviteTokenDbHandler) SaveInviteToken(ctx context.Context, email string, permissions models.Permission) (string, error) {
	token := uuid.NewString()

	_, err := i.collection.InsertOne(ctx, &InviteToken{
		Permissions: permissions,
		Email:       email,
		Token:       token,
	})
	if err != nil {
		return "", err
	}

	return token, nil
}

func (i *InviteTokenDbHandler) DeleteInviteToken(ctx context.Context, token string) error {
	_, err := i.collection.DeleteOne(ctx, bson.M{"token": token})
	return err
}

func (i *InviteTokenDbHandler) GetInviteToken(ctx context.Context, token string) (*dbhandler.InviteToken, error) {
	var inviteToken InviteToken
	err := i.collection.FindOne(ctx, bson.M{"token": token}).Decode(&inviteToken)
	if err != nil {
		return nil, err
	}
	return &dbhandler.InviteToken{
		Email:       inviteToken.Email,
		Permissions: inviteToken.Permissions,
		Token:       inviteToken.Token,
	}, nil
}

func NewInviteTokenDbHandler(config models.MongoDBConfig) (*InviteTokenDbHandler, error) {
	collection, err := getMongoCollection(config)
	if err != nil {
		return nil, err
	}

	return &InviteTokenDbHandler{
		collection: collection,
	}, nil
}