feat: Users API, ownership transfer and removal of the legacy role string

internal/infrastructure/useCases/RenewInvite.go

@@ -2,9 +2,11 @@ package useCases
 
 import (
 	"RenewCMS/internal/domain/audit"
+	"RenewCMS/internal/domain/contenttype"
 	"RenewCMS/internal/domain/hash"
 	"RenewCMS/internal/domain/invite"
 	"RenewCMS/internal/domain/mail"
+	"RenewCMS/internal/domain/role"
 	"RenewCMS/internal/domain/user"
 	"context"
 	"errors"
@@ -14,61 +16,75 @@ import (
 type RenewInviteUseCase struct {
 	userRepository   user.Repository
 	inviteRepository invite.Repository
+	roles            role.Repository
+	contentTypes     contenttype.Repository
 	hasher           hash.Hasher
 	mailer           inviteMailer
 	recorder         audit.Recorder
 }
 
 type RenewInviteCommand struct {
+	Caller    ContentCaller
 	ID        uint32
 	RenewedBy uint32
 }
 
-func NewRenewInviteUseCase(userRepository user.Repository, inviteRepository invite.Repository, hasher hash.Hasher, mailRepository mail.Repository, publicURL string, recorder audit.Recorder) *RenewInviteUseCase {
-	return &RenewInviteUseCase{userRepository, inviteRepository, hasher, inviteMailer{mailRepository, publicURL}, recorder}
+func NewRenewInviteUseCase(userRepository user.Repository, inviteRepository invite.Repository, roles role.Repository, contentTypes contenttype.Repository, hasher hash.Hasher, mailRepository mail.Repository, publicURL string, recorder audit.Recorder) *RenewInviteUseCase {
+	return &RenewInviteUseCase{userRepository, inviteRepository, roles, contentTypes, hasher, inviteMailer{mailRepository, publicURL}, recorder}
 }
 
-func (u *RenewInviteUseCase) RenewInvite(ctx context.Context, command RenewInviteCommand) (invite.Invite, error) {
+func (u *RenewInviteUseCase) coveredRole(caller ContentCaller, previous invite.Invite) (role.Role, error) {
+	return coveredAssignableRole(caller, u.roles, u.contentTypes, previous.RoleID)
+}
+
+func (u *RenewInviteUseCase) RenewInvite(ctx context.Context, command RenewInviteCommand) (InviteView, error) {
 	event := audit.NewEvent(audit.ActionInviteRenew, audit.CategoryUsers)
-	renewed, err := u.renew(command)
+	renewed, held, err := u.renew(command)
 	if err != nil {
-		recordFailure(ctx, u.recorder, event, err)
-		return invite.Invite{}, err
+		if !isInviteRoleRefusal(err) {
+			recordFailure(ctx, u.recorder, event, err)
+		}
+		return InviteView{}, err
 	}
 	event.Target = inviteTarget(renewed)
 	u.recorder.Record(ctx, event)
-	return renewed, nil
+	return InviteView{Invite: renewed, Role: NewRoleRef(held)}, nil
 }
 
-func (u *RenewInviteUseCase) renew(command RenewInviteCommand) (invite.Invite, error) {
+func (u *RenewInviteUseCase) renew(command RenewInviteCommand) (invite.Invite, role.Role, error) {
 	now := time.Now()
 
 	renewer, err := u.userRepository.Get(command.RenewedBy)
 	if err != nil {
-		return invite.Invite{}, err
+		return invite.Invite{}, role.Role{}, err
 	}
 
 	previous, err := findManageableInvite(u.inviteRepository, command.ID)
 	if err != nil {
-		return invite.Invite{}, err
+		return invite.Invite{}, role.Role{}, err
+	}
+
+	held, err := u.coveredRole(command.Caller, previous)
+	if err != nil {
+		return invite.Invite{}, role.Role{}, err
 	}
 
 	rawCode, hashedCode, err := newInviteCode(u.hasher)
 	if err != nil {
-		return invite.Invite{}, err
+		return invite.Invite{}, role.Role{}, err
 	}
 
 	renewed, err := u.inviteRepository.Renew(previous.ID, hashedCode, now.Add(invite.Lifetime), now)
 	if err != nil {
-		return invite.Invite{}, err
+		return invite.Invite{}, role.Role{}, err
 	}
 
 	if sendErr := u.mailer.send(renewed.Email, rawCode, renewer); sendErr != nil {
 		if _, restoreErr := u.inviteRepository.Renew(previous.ID, previous.HashedCode, previous.ExpiresAt, previous.CreatedAt); restoreErr != nil {
-			return invite.Invite{}, errors.Join(sendErr, restoreErr)
+			return invite.Invite{}, role.Role{}, errors.Join(sendErr, restoreErr)
 		}
-		return invite.Invite{}, sendErr
+		return invite.Invite{}, role.Role{}, sendErr
 	}
 
-	return renewed, nil
+	return renewed, held, nil
 }