Skip to content

Modern Docker Management, Designed for Everyone

12.0 KB
Raw Blame
package user

import (
	"context"
	"errors"
	"strings"
	"time"

	"github.com/danielgtaylor/huma/v2"
	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/user"
	"go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/userctx"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/validation"
)

// UserHandler handles user management endpoints.
type UserHandler struct {
	userService              *UserService
	invalidateUserTokenCache func(string)
	settingsService          *settings.SettingsService
}

type ListUsersInput struct {
	Search string `query:"search" doc:"Search query"`
	Sort   string `query:"sort" doc:"Column to sort by"`
	Order  string `query:"order" default:"asc" doc:"Sort direction"`
	Start  int    `query:"start" default:"0" doc:"Start index"`
	Limit  int    `query:"limit" default:"20" doc:"Items per page"`
}

type CreateUserInput struct {
	Body user.CreateUser
}

type GetUserInput struct {
	UserID string `path:"userId" doc:"User ID"`
}

type UpdateUserInput struct {
	UserID string `path:"userId" doc:"User ID"`
	Body   user.UpdateUser
}

type DeleteUserInput struct {
	UserID string `path:"userId" doc:"User ID"`
}

type GetUserAvatarInput struct {
	UserID string `path:"userId" doc:"User ID"`
}

type GetUserAvatarOutput struct {
	ContentType         string `header:"Content-Type"`
	CacheControl        string `header:"Cache-Control"`
	XContentTypeOptions string `header:"X-Content-Type-Options"`
	Body                []byte
}

// ListUsers returns a paginated list of users.
func (h *UserHandler) ListUsers(ctx context.Context, input *ListUsersInput) (*handlerutil.Page[user.User], error) {
	params := handlerutil.PaginationParams(input.Start, input.Limit, input.Sort, input.Order, input.Search)

	users, paginationResp, err := h.userService.ListUsersPaginated(ctx, params)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to list users: " + err.Error())
	}

	return &handlerutil.Page[user.User]{
		Body: base.Paginated[user.User]{
			Success:    true,
			Data:       users,
			Pagination: handlerutil.PaginationResponse(paginationResp),
		},
	}, nil
}

// CreateUser creates a new usertypes.
func (h *UserHandler) CreateUser(ctx context.Context, input *CreateUserInput) (*handlerutil.Out[user.User], error) {
	normalizedUsername, err := normalizeUsernameInternal(input.Body.Username)
	if err != nil {
		return nil, huma.Error400BadRequest(err.Error())
	}
	input.Body.Username = normalizedUsername

	normalizedEmail, err := NormalizeOptionalEmail(input.Body.Email)
	if err != nil {
		return nil, huma.Error400BadRequest(err.Error())
	}
	input.Body.Email = normalizedEmail

	passwordPolicy := h.passwordPolicyInternal(ctx)
	if validatePasswordPolicyErr := validation.ValidatePasswordPolicy(input.Body.Password, passwordPolicy); validatePasswordPolicyErr != nil {
		return nil, handlerutil.Error400BadRequestWithType(validatePasswordPolicyErr.Error(), validation.PasswordPolicyProblemType(passwordPolicy))
	}

	hashedPassword, err := h.userService.HashPassword(ctx, input.Body.Password)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to hash password")
	}

	userModel := &User{
		Username:     input.Body.Username,
		PasswordHash: hashedPassword,
		DisplayName:  input.Body.DisplayName,
		Email:        input.Body.Email,
		Locale:       input.Body.Locale,
		TimeFormat:   user.TimeFormatAuto,
		CreatedAt:    time.Now(),
	}
	if input.Body.TimeFormat != nil {
		userModel.TimeFormat = *input.Body.TimeFormat
	}

	createdUser, err := h.userService.CreateUser(ctx, userModel)
	if err != nil {
		if errors.Is(err, ErrUsernameTaken) {
			return nil, huma.Error409Conflict(ErrUsernameTaken.Error())
		}
		if errors.Is(err, ErrEmailTaken) {
			return nil, huma.Error409Conflict(ErrEmailTaken.Error())
		}
		return nil, huma.Error500InternalServerError("Failed to create user")
	}

	out, err := h.userService.ToUserResponseDto(ctx, *createdUser)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to map user")
	}

	return &handlerutil.Out[user.User]{
		Body: base.ApiResponse[user.User]{
			Success: true,
			Data:    out,
		},
	}, nil
}

// GetUser returns a user by ID.
func (h *UserHandler) GetUser(ctx context.Context, input *GetUserInput) (*handlerutil.Out[user.User], error) {
	userModel, err := h.userService.GetUserByID(ctx, input.UserID)
	if err != nil {
		return nil, huma.Error404NotFound("User not found")
	}

	out, err := h.userService.ToUserResponseDto(ctx, *userModel)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to map user")
	}

	return &handlerutil.Out[user.User]{
		Body: base.ApiResponse[user.User]{
			Success: true,
			Data:    out,
		},
	}, nil
}

// UpdateUser updates a usertypes.
func (h *UserHandler) UpdateUser(ctx context.Context, input *UpdateUserInput) (*handlerutil.Out[user.User], error) {
	userModel, err := h.userService.GetUserByID(ctx, input.UserID)
	if err != nil {
		return nil, huma.Error404NotFound("User not found")
	}

	normalizedEmail, err := NormalizeOptionalEmail(input.Body.Email)
	if err != nil {
		return nil, huma.Error400BadRequest(err.Error())
	}
	input.Body.Email = normalizedEmail

	if input.Body.Username != nil {
		normalizedUsername, normalizeUsernameErr := normalizeUsernameInternal(*input.Body.Username)
		if normalizeUsernameErr != nil {
			return nil, huma.Error400BadRequest(normalizeUsernameErr.Error())
		}
		userModel.Username = normalizedUsername
	}
	if input.Body.DisplayName != nil {
		userModel.DisplayName = input.Body.DisplayName
	}
	if input.Body.Email != nil {
		userModel.Email = input.Body.Email
	}
	if input.Body.Locale != nil {
		userModel.Locale = input.Body.Locale
	}
	if input.Body.TimeFormat != nil {
		userModel.TimeFormat = *input.Body.TimeFormat
	}

	userModel.UpdatedAt = new(time.Now())

	callerPerms, err := h.checkUpdateUserPrivilegesInternal(ctx, input, userModel.ID)
	if err != nil {
		return nil, err
	}

	if input.Body.Password != nil && *input.Body.Password != "" {
		passwordPolicy := h.passwordPolicyInternal(ctx)
		if validatePasswordPolicyErr := validation.ValidatePasswordPolicy(*input.Body.Password, passwordPolicy); validatePasswordPolicyErr != nil {
			return nil, handlerutil.Error400BadRequestWithType(validatePasswordPolicyErr.Error(), validation.PasswordPolicyProblemType(passwordPolicy))
		}
	}

	updatedUser, err := h.userService.UpdateUser(ctx, userModel, callerPerms)
	if err != nil {
		if errors.Is(err, ErrInsufficientPrivilege) {
			return nil, huma.Error403Forbidden(ErrInsufficientPrivilege.Error())
		}
		if errors.Is(err, ErrCannotRemoveLastAdmin) {
			return nil, huma.Error409Conflict(ErrCannotRemoveLastAdmin.Error())
		}
		if errors.Is(err, ErrUsernameTaken) {
			return nil, huma.Error409Conflict(ErrUsernameTaken.Error())
		}
		if errors.Is(err, ErrEmailTaken) {
			return nil, huma.Error409Conflict(ErrEmailTaken.Error())
		}
		if errors.Is(err, common.ErrUserNotFound) {
			return nil, huma.Error404NotFound("User not found")
		}
		return nil, huma.Error500InternalServerError("Failed to update user")
	}

	if input.Body.Password != nil && *input.Body.Password != "" {
		caller, _ := userctx.CurrentUserFromContext(ctx)
		currentSessionID, _ := middleware.GetCurrentSessionIDFromContext(ctx)
		exceptSessionID := kit.Ternary(caller != nil && caller.ID == updatedUser.ID, currentSessionID, "")
		if _, setPasswordErr := h.userService.SetPasswordAndRevokeSessionsExcept(ctx, updatedUser, *input.Body.Password, exceptSessionID, callerPerms); setPasswordErr != nil {
			return nil, huma.Error500InternalServerError("Failed to update password")
		}
	}

	if h.invalidateUserTokenCache != nil {
		h.invalidateUserTokenCache(updatedUser.ID)
	}

	out, err := h.userService.ToUserResponseDto(ctx, *updatedUser)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to map user")
	}

	return &handlerutil.Out[user.User]{
		Body: base.ApiResponse[user.User]{
			Success: true,
			Data:    out,
		},
	}, nil
}

// DeleteUser deletes a usertypes.
func (h *UserHandler) DeleteUser(ctx context.Context, input *DeleteUserInput) (*handlerutil.Out[base.MessageResponse], error) {
	// Privilege ordering: a non-admin caller may not delete a global admin
	// target. The service enforces the same check; this pre-check produces a
	// clean 403 without entering the delete path.
	callerPerms, _ := middleware.PermissionsFromContext(ctx)
	caller, _ := userctx.CurrentUserFromContext(ctx)
	if callerPerms != nil && !callerPerms.IsGlobalAdmin() && caller != nil && caller.ID != input.UserID {
		targetPerms, err := h.userService.ResolveUserPermissions(ctx, input.UserID)
		if err != nil {
			return nil, huma.Error500InternalServerError("Failed to resolve target permissions")
		}
		if targetPerms != nil && targetPerms.IsGlobalAdmin() {
			return nil, huma.Error403Forbidden(ErrInsufficientPrivilege.Error())
		}
	}

	if err := h.userService.DeleteUser(ctx, input.UserID, callerPerms); err != nil {
		if errors.Is(err, ErrInsufficientPrivilege) {
			return nil, huma.Error403Forbidden(ErrInsufficientPrivilege.Error())
		}
		if errors.Is(err, ErrCannotRemoveLastAdmin) {
			return nil, huma.Error409Conflict(ErrCannotRemoveLastAdmin.Error())
		}
		if errors.Is(err, common.ErrUserNotFound) {
			return nil, huma.Error404NotFound("User not found")
		}
		return nil, huma.Error500InternalServerError("Failed to delete user")
	}

	if h.invalidateUserTokenCache != nil {
		h.invalidateUserTokenCache(input.UserID)
	}

	return handlerutil.MessageOutput("User deleted successfully", ""), nil
}

// GetUserAvatar returns the custom profile picture for a usertypes.
func (h *UserHandler) GetUserAvatar(ctx context.Context, input *GetUserAvatarInput) (*GetUserAvatarOutput, error) {
	data, mimeType, err := h.userService.GetAvatar(ctx, input.UserID)
	if err != nil {
		if errors.Is(err, common.ErrUserNotFound) {
			return nil, huma.Error404NotFound("User not found")
		}
		return nil, huma.Error500InternalServerError("failed to retrieve avatar")
	}

	if len(data) == 0 {
		return nil, huma.Error404NotFound("user has no custom avatar")
	}

	return &GetUserAvatarOutput{
		ContentType:         mimeType,
		CacheControl:        "public, max-age=3600, stale-while-revalidate=86400",
		XContentTypeOptions: "nosniff",
		Body:                data,
	}, nil
}

func NormalizeOptionalEmail(email *string) (*string, error) {
	if email == nil {
		return nil, nil
	}

	trimmedEmail := strings.TrimSpace(*email)
	if trimmedEmail == "" {
		return nil, nil
	}

	if !validation.IsValidUserEmail(trimmedEmail) {
		return nil, errors.New("must be a valid email")
	}

	return &trimmedEmail, nil
}

// checkUpdateUserPrivilegesInternal enforces that a non-admin caller may not
// modify a global admin target, nor set another user's password. The service
// re-enforces the target-admin check.
func (h *UserHandler) checkUpdateUserPrivilegesInternal(ctx context.Context, input *UpdateUserInput, targetID string) (*authz.PermissionSet, error) {
	callerPerms, _ := middleware.PermissionsFromContext(ctx)
	caller, _ := userctx.CurrentUserFromContext(ctx)
	if callerPerms != nil && !callerPerms.IsGlobalAdmin() {
		if input.Body.Password != nil && *input.Body.Password != "" && caller != nil && caller.ID != targetID {
			return nil, huma.Error403Forbidden(ErrInsufficientPrivilege.Error())
		}
		targetPerms, err := h.userService.ResolveUserPermissions(ctx, targetID)
		if err != nil {
			return nil, huma.Error500InternalServerError("Failed to resolve target permissions")
		}
		if targetPerms != nil && targetPerms.IsGlobalAdmin() {
			return nil, huma.Error403Forbidden(ErrInsufficientPrivilege.Error())
		}
	}
	return callerPerms, nil
}

func (h *UserHandler) passwordPolicyInternal(ctx context.Context) string {
	if h.settingsService == nil {
		return validation.PasswordPolicyStrong
	}
	return h.settingsService.GetStringSetting(ctx, "authPasswordPolicy", validation.PasswordPolicyStrong)
}