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

internal/infrastructure/persistence/repositories/roleRepository.go

@@ -145,8 +145,8 @@ func (r *RoleRepository) Delete(id uint32) error {
 		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&entity.Role{}, id).Error; err != nil {
 			return mapNotFoundErr(err, role.ErrRoleNotFound)
 		}
-		var members int64
-		if err := tx.Model(&entity.User{}).Where("role_id = ?", id).Count(&members).Error; err != nil {
+		members, err := countMembers(tx, id)
+		if err != nil {
 			return err
 		}
 		if members > 0 {
@@ -159,24 +159,68 @@ func (r *RoleRepository) Delete(id uint32) error {
 	})
 }
 
-func (r *RoleRepository) ReassignMembers(from uint32, to uint32) (int, error) {
-	moved := r.db.Model(&entity.User{}).
-		Where("role_id = ? AND EXISTS (SELECT 1 FROM roles WHERE id = ?)", from, to).
-		UpdateColumn("role_id", to)
-	if moved.Error != nil {
-		return 0, moved.Error
-	}
-	if moved.RowsAffected > 0 {
-		return int(moved.RowsAffected), nil
-	}
-	var targets int64
-	if err := r.db.Model(&entity.Role{}).Where("id = ?", to).Count(&targets).Error; err != nil {
+func countMembers(tx *gorm.DB, id uint32) (int64, error) {
+	var users, invites int64
+	if err := tx.Model(&entity.User{}).Where("role_id = ?", id).Count(&users).Error; err != nil {
 		return 0, err
 	}
-	if targets == 0 {
-		return 0, role.ErrInvalidReassign
+	if err := tx.Model(&entity.Invite{}).Where("role_id = ? AND accepted_at IS NULL", id).Count(&invites).Error; err != nil {
+		return 0, err
 	}
-	return 0, nil
+	return users + invites, nil
+}
+
+type memberRow struct {
+	RoleID  uint32
+	Members int
+}
+
+func (r *RoleRepository) MemberCounts() (map[uint32]int, error) {
+	var users, invites []memberRow
+	if err := r.db.Model(&entity.User{}).Select("role_id, COUNT(*) AS members").Where("role_id IS NOT NULL").Group("role_id").Scan(&users).Error; err != nil {
+		return nil, err
+	}
+	if err := r.db.Model(&entity.Invite{}).Select("role_id, COUNT(*) AS members").Where("role_id IS NOT NULL AND accepted_at IS NULL").Group("role_id").Scan(&invites).Error; err != nil {
+		return nil, err
+	}
+	counts := map[uint32]int{}
+	for _, row := range append(users, invites...) {
+		if row.RoleID != 0 {
+			counts[row.RoleID] += row.Members
+		}
+	}
+	return counts, nil
+}
+
+func (r *RoleRepository) ReassignMembers(from uint32, to uint32) (int, error) {
+	moved := 0
+	err := r.db.Transaction(func(tx *gorm.DB) error {
+		target := "EXISTS (SELECT 1 FROM roles WHERE id = ?)"
+		users := tx.Model(&entity.User{}).Where("role_id = ? AND "+target, from, to).UpdateColumn("role_id", to)
+		if users.Error != nil {
+			return users.Error
+		}
+		invites := tx.Model(&entity.Invite{}).Where("role_id = ? AND accepted_at IS NULL AND "+target, from, to).UpdateColumn("role_id", to)
+		if invites.Error != nil {
+			return invites.Error
+		}
+		moved = int(users.RowsAffected + invites.RowsAffected)
+		if moved > 0 {
+			return nil
+		}
+		var targets int64
+		if err := tx.Model(&entity.Role{}).Where("id = ?", to).Count(&targets).Error; err != nil {
+			return err
+		}
+		if targets == 0 {
+			return role.ErrInvalidReassign
+		}
+		return nil
+	})
+	if err != nil {
+		return 0, err
+	}
+	return moved, nil
 }
 
 func (r *RoleRepository) RemoveTypedGrants(typeKey string) (int, error) {

internal/infrastructure/persistence/repositories/userRepository.go

@@ -1,12 +1,14 @@
 package persistence
 
 import (
+	"RenewCMS/internal/domain/role"
 	domainUser "RenewCMS/internal/domain/user"
 	"RenewCMS/internal/infrastructure/persistence/mappers"
 	entity "RenewCMS/internal/infrastructure/persistence/models"
 	"time"
 
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
 type UserRepository struct {
@@ -34,7 +36,7 @@ func (u *UserRepository) Create(user domainUser.User) (domainUser.User, error) {
 		PasswordResetCode:      mappers.DomainToNullableString(user.PasswordResetCode),
 		Email:                  user.Email,
 		IsVerified:             user.IsVerified,
-		Role:                   string(user.Role),
+		RoleID:                 mappers.DomainToNullableID(user.RoleID),
 		VerificationCode:       mappers.DomainToNullableString(user.VerificationCode),
 		VerificationExpiration: user.VerificationExpiration,
 	}
@@ -145,14 +147,17 @@ func (u *UserRepository) UpdatePasswordResetCode(userId uint32, code string, exp
 
 func (u *UserRepository) ClearVerificationCode(userId uint32) (domainUser.User, error) {
 	var localUser entity.User
-	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
-	if err != nil {
-		return domainUser.User{}, mapNotFoundErr(err, domainUser.ErrUserNotFound)
-	}
-
-	localUser.IsVerified = true
-	localUser.VerificationCode = mappers.DomainToNullableString("")
-	err = u.db.Save(&localUser).Error
+	err := u.db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Model(&entity.User{}).First(&localUser, userId).Error; err != nil {
+			return mapNotFoundErr(err, domainUser.ErrUserNotFound)
+		}
+		if err := refuseSecondVerifiedOwner(tx, localUser); err != nil {
+			return err
+		}
+		localUser.IsVerified = true
+		localUser.VerificationCode = mappers.DomainToNullableString("")
+		return tx.Save(&localUser).Error
+	})
 	if err != nil {
 		return domainUser.User{}, err
 	}
@@ -160,6 +165,26 @@ func (u *UserRepository) ClearVerificationCode(userId uint32) (domainUser.User,
 	return mappers.UserToDomain(localUser), nil
 }
 
+func refuseSecondVerifiedOwner(tx *gorm.DB, candidate entity.User) error {
+	if candidate.RoleID == nil {
+		return nil
+	}
+	var roles []entity.Role
+	err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("id = ? AND built_in = ? AND name = ?", *candidate.RoleID, true, role.OwnerName).Find(&roles).Error
+	if err != nil || len(roles) == 0 {
+		return err
+	}
+	var others int64
+	err = tx.Model(&entity.User{}).Where("role_id = ? AND is_verified = ? AND id <> ?", *candidate.RoleID, true, candidate.ID).Count(&others).Error
+	if err != nil {
+		return err
+	}
+	if others > 0 {
+		return domainUser.ErrInvalidVerificationCode
+	}
+	return nil
+}
+
 func (u *UserRepository) ResetPassword(userId uint32, hashedPassword string) (domainUser.User, error) {
 	var localUser entity.User
 	err := u.db.Model(&entity.User{}).First(&localUser, userId).Error
@@ -195,4 +220,68 @@ func (u *UserRepository) UpdateDisplayName(userId uint32, displayName string) (d
 	return mappers.UserToDomain(localUser), nil
 }
 
+func (u *UserRepository) UpdateRole(id uint32, from uint32, to uint32) (domainUser.User, error) {
+	err := u.db.Transaction(func(tx *gorm.DB) error {
+		query := tx.Model(&entity.User{}).Where("id = ? AND EXISTS (SELECT 1 FROM roles WHERE id = ?)", id, to)
+		if from == 0 {
+			query = query.Where("(role_id IS NULL OR role_id = 0)")
+		} else {
+			query = query.Where("role_id = ?", from)
+		}
+		result := query.Update("role_id", to)
+		if result.Error != nil {
+			return result.Error
+		}
+		if result.RowsAffected > 0 {
+			return nil
+		}
+		return u.explainRoleRefusal(tx, id, to)
+	})
+	if err != nil {
+		return domainUser.User{}, err
+	}
+	return u.Get(id)
+}
+
+func (u *UserRepository) explainRoleRefusal(tx *gorm.DB, id uint32, to uint32) error {
+	var users int64
+	if err := tx.Model(&entity.User{}).Where("id = ?", id).Count(&users).Error; err != nil {
+		return err
+	}
+	if users == 0 {
+		return domainUser.ErrUserNotFound
+	}
+	var roles int64
+	if err := tx.Model(&entity.Role{}).Where("id = ?", to).Count(&roles).Error; err != nil {
+		return err
+	}
+	if roles == 0 {
+		return role.ErrRoleNotFound
+	}
+	return domainUser.ErrRoleChanged
+}
+
+func (u *UserRepository) TransferOwnership(from uint32, to uint32, ownerRoleID uint32, formerRoleID uint32) error {
+	if from == to {
+		return domainUser.ErrInvalidTransfer
+	}
+	return u.db.Transaction(func(tx *gorm.DB) error {
+		demoted := tx.Model(&entity.User{}).Where("id = ? AND role_id = ?", from, ownerRoleID).Update("role_id", formerRoleID)
+		if demoted.Error != nil {
+			return demoted.Error
+		}
+		if demoted.RowsAffected == 0 {
+			return domainUser.ErrRoleChanged
+		}
+		promoted := tx.Model(&entity.User{}).Where("id = ? AND is_verified = ?", to, true).Update("role_id", ownerRoleID)
+		if promoted.Error != nil {
+			return promoted.Error
+		}
+		if promoted.RowsAffected == 0 {
+			return domainUser.ErrInvalidTransfer
+		}
+		return nil
+	})
+}
+
 var _ domainUser.Repository = &UserRepository{}