RenewCMS/internal/infrastructure/useCases/AcceptInvite.go

package useCases

import (
	"RenewCMS/internal/domain/audit"
	"RenewCMS/internal/domain/hash"
	"RenewCMS/internal/domain/invite"
	"RenewCMS/internal/domain/role"
	"RenewCMS/internal/domain/user"
	"context"
	"errors"
	"strings"
	"time"
)

type AcceptInviteUseCase struct {
	userRepository   user.Repository
	inviteRepository invite.Repository
	roles            role.Repository
	hasher           hash.Hasher
	recorder         audit.Recorder
}

type AcceptInviteCommand struct {
	Code     string
	Username string
	Password string
}

func NewAcceptInviteUseCase(userRepository user.Repository, inviteRepository invite.Repository, roles role.Repository, hasher hash.Hasher, recorder audit.Recorder) *AcceptInviteUseCase {
	return &AcceptInviteUseCase{userRepository, inviteRepository, roles, hasher, recorder}
}

func (a *AcceptInviteUseCase) invitedRole(pending invite.Invite) (role.Role, error) {
	assigned, err := assignableRole(a.roles, pending.RoleID)
	if errors.Is(err, role.ErrUnknownRole) || errors.Is(err, role.ErrRoleLocked) {
		return role.Role{}, invite.ErrInviteInvalid
	}
	return assigned, err
}

func (a *AcceptInviteUseCase) AcceptInvite(ctx context.Context, command AcceptInviteCommand) (user.User, error) {
	event := audit.NewEvent(audit.ActionInviteAccept, audit.CategoryUsers)
	now := time.Now()

	pending, err := findUsableInvite(a.inviteRepository, a.hasher, command.Code, now)
	if err != nil {
		a.recordRefusal(ctx, event, command, err)
		return user.User{}, err
	}
	event.Target = inviteTarget(pending)

	assigned, err := a.invitedRole(pending)
	if err != nil {
		a.recordRefusal(ctx, event, command, err)
		return user.User{}, err
	}

	created, err := a.accept(command, pending, assigned, now)
	if err != nil {
		a.recordRefusal(ctx, event, command, err)
		return user.User{}, err
	}
	event = inviteRoleParams(event, assigned)
	event.Actor = audit.UserActor(created)
	a.recorder.Record(ctx, event)
	return created, nil
}

func (a *AcceptInviteUseCase) recordRefusal(ctx context.Context, event audit.Event, command AcceptInviteCommand, cause error) {
	event.Actor = audit.AnonymousActor(command.Username)
	recordFailure(ctx, a.recorder, event, cause)
}

func (a *AcceptInviteUseCase) accept(command AcceptInviteCommand, pending invite.Invite, assigned role.Role, now time.Time) (user.User, error) {
	hasAccount, err := a.emailHasAccount(pending.Email)
	if err != nil {
		return user.User{}, err
	}
	if hasAccount {
		if _, err := findUsableInvite(a.inviteRepository, a.hasher, command.Code, now); err != nil {
			return user.User{}, err
		}
		return user.User{}, invite.ErrEmailHasAccount
	}

	if err := a.ensureUsernameFree(command.Username); err != nil {
		return user.User{}, err
	}

	if err := user.ValidatePassword(command.Password); err != nil {
		return user.User{}, err
	}

	hashedPassword, err := a.hasher.Hash(command.Password)
	if err != nil {
		return user.User{}, err
	}

	inviterID, err := a.inviterOf(pending)
	if err != nil {
		return user.User{}, err
	}
	createdUser, err := a.inviteRepository.AcceptWithUser(pending.ID, now, user.User{
		Username:         command.Username,
		Password:         hashedPassword,
		Email:            pending.Email,
		IsVerified:       true,
		RoleID:           assigned.ID,
		RoleAssignedByID: inviterID,
	})
	if errors.Is(err, invite.ErrInviteNotFound) {
		return user.User{}, invite.ErrInviteInvalid
	}
	if err != nil {
		return user.User{}, err
	}

	return createdUser, nil
}

func (a *AcceptInviteUseCase) inviterOf(pending invite.Invite) (uint32, error) {
	assigner, err := resolveRoleAssigner(a.userRepository, pending.InvitedBy)
	if err != nil || assigner == nil {
		return 0, err
	}
	return assigner.ID, nil
}

func (a *AcceptInviteUseCase) emailHasAccount(email string) (bool, error) {
	users, err := a.userRepository.GetAll()
	if err != nil {
		return false, err
	}
	for _, existingUser := range users {
		if strings.EqualFold(existingUser.Email, email) {
			return true, nil
		}
	}
	return false, nil
}

func (a *AcceptInviteUseCase) ensureUsernameFree(username string) error {
	_, err := a.userRepository.GetByUsername(username)
	if err == nil {
		return user.ErrUsernameTaken
	}
	if errors.Is(err, user.ErrUserNotFound) {
		return nil
	}
	return err
}