feat: add new change account password endpoint

account/pom.xml

@@ -65,5 +65,10 @@
             <version>1.0-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>io.swagger.core.v3</groupId>
+            <artifactId>swagger-annotations-jakarta</artifactId>
+            <version>2.2.31</version>
+        </dependency>
     </dependencies>
 </project>

account/src/main/kotlin/br/all/application/user/create/RegisterUserAccountService.kt

@@ -1,19 +1,22 @@
 package br.all.application.user.create
 
+import io.swagger.v3.oas.annotations.media.Schema
 import java.util.UUID
 
 interface RegisterUserAccountService {
 
     fun register(presenter: RegisterUserAccountPresenter, request: RequestModel)
 
     data class RequestModel(
+        val name: String,
         val username: String,
         val password: String,
         val email: String,
         val country: String,
         val affiliation: String,
     )
 
+    @Schema(name = "RegisterUserAccountResponseModel", description = "Response model for Register User Account Service")
     data class ResponseModel(
         val id: UUID,
         val username: String,

account/src/main/kotlin/br/all/application/user/create/RegisterUserAccountServiceImpl.kt

@@ -6,6 +6,9 @@ import br.all.application.user.repository.UserAccountRepository
 import br.all.application.user.repository.toDto
 import br.all.domain.shared.exception.UniquenessViolationException
 import br.all.domain.shared.user.Email
+import br.all.domain.shared.user.Name
+import br.all.domain.shared.user.Text
+import br.all.domain.shared.user.Username
 import br.all.domain.user.*
 
 class RegisterUserAccountServiceImpl(private val repository: UserAccountRepository) : RegisterUserAccountService {
@@ -20,12 +23,14 @@ class RegisterUserAccountServiceImpl(private val repository: UserAccountReposito
         if (presenter.isDone()) return
 
         val userAccountId = UserAccountId()
+        val name = Name(request.name)
         val username = Username(request.username)
         val email = Email(request.email)
         val country = Text(request.country)
 
         val userAccount = UserAccount(
             id = userAccountId,
+            name = name,
             username = username,
             password = request.password,
             email = email,

account/src/main/kotlin/br/all/application/user/find/RetrieveUserProfileService.kt

@@ -1,4 +1,5 @@
 package br.all.application.user.find
+import io.swagger.v3.oas.annotations.media.Schema
 import java.util.UUID
 
 interface RetrieveUserProfileService {
@@ -8,8 +9,10 @@ interface RetrieveUserProfileService {
         val userId: UUID
     )
 
+    @Schema(name = "RetrieveUserProfileService", description = "Response model for Retrieve User Profile Service")
     data class ResponseModel(
         val userId: UUID,
+        val name: String,
         val username: String,
         val email: String,
         val affiliation: String,

account/src/main/kotlin/br/all/application/user/find/RetrieveUserProfileServiceImpl.kt

@@ -5,32 +5,26 @@ import br.all.application.user.find.RetrieveUserProfileService.ResponseModel
 import br.all.application.user.repository.UserAccountRepository
 
 class RetrieveUserProfileServiceImpl(
-    private val userAccountRepository: UserAccountRepository
+    private val repository: UserAccountRepository
 ) : RetrieveUserProfileService {
     override fun retrieveData(
         presenter: RetrieveUserProfilePresenter,
         request: RequestModel
     ) {
-        val userProfile = userAccountRepository.loadUserProfileById(request.userId)
-        if (userProfile == null) {
+        val userAccount = repository.loadFullUserAccountById(request.userId)
+        if (userAccount == null) {
             presenter.prepareFailView(NoSuchElementException("User with id ${request.userId} doesn't exist!"))
             return
         }
 
-        val userCredentials = userAccountRepository.loadCredentialsById(request.userId)
-        if (userCredentials == null) {
-            presenter.prepareFailView(NoSuchElementException("Account credentials with id ${request.userId} doesn't exist!"))
-            return
-        }
-
-
         val profile = ResponseModel(
-            userId = userProfile.id,
-            username = userCredentials.username,
-            email = userProfile.email,
-            affiliation = userProfile.affiliation,
-            country = userProfile.country,
-            authorities = userCredentials.authorities
+            userId = userAccount.id,
+            name = userAccount.name,
+            username = userAccount.username,
+            email = userAccount.email,
+            affiliation = userAccount.affiliation,
+            country = userAccount.country,
+            authorities = userAccount.authorities
         )
 
         presenter.prepareSuccessView(profile)

account/src/main/kotlin/br/all/application/user/repository/UserAccountDto.kt

@@ -5,6 +5,7 @@ import java.util.*
 
 data class UserAccountDto(
     val id: UUID,
+    val name: String,
     val username: String,
     val password: String,
     val email: String,

account/src/main/kotlin/br/all/application/user/repository/UserAccountMapper.kt

@@ -4,6 +4,7 @@ import br.all.domain.user.UserAccount
 
 fun UserAccount.toDto() = UserAccountDto(
     id.value(),
+    name.value,
     accountCredentials.username.value,
     accountCredentials.password,
     email.email,
@@ -17,4 +18,3 @@ fun UserAccount.toDto() = UserAccountDto(
     accountCredentials.isCredentialsNonExpired,
     accountCredentials.isEnabled
 )
-

account/src/main/kotlin/br/all/application/user/repository/UserAccountRepository.kt

@@ -12,4 +12,6 @@ interface UserAccountRepository {
     fun existsByUsername(username: String): Boolean
     fun deleteById(id: UUID)
     fun loadUserProfileById(id: UUID): UserProfileDto?
+    fun loadFullUserAccountById(id: UUID): UserAccountDto?
+    fun updatePassword(id: UUID, newHashedPassword: String)
 }

account/src/main/kotlin/br/all/application/user/repository/UserProfileDto.kt

@@ -4,6 +4,7 @@ import java.util.UUID
 
 data class UserProfileDto(
     val id: UUID,
+    val name: String,
     val email: String,
     val country: String,
     val affiliation: String,

account/src/main/kotlin/br/all/application/user/update/ChangeAccountPasswordPresenter.kt

@@ -0,0 +1,6 @@
+package br.all.application.user.update
+
+import br.all.application.user.update.ChangeAccountPasswordService.ResponseModel
+import br.all.domain.shared.presenter.GenericPresenter
+
+interface ChangeAccountPasswordPresenter : GenericPresenter<ResponseModel>

account/src/main/kotlin/br/all/application/user/update/ChangeAccountPasswordService.kt

@@ -0,0 +1,20 @@
+package br.all.application.user.update
+
+import io.swagger.v3.oas.annotations.media.Schema
+import java.util.UUID
+
+interface ChangeAccountPasswordService {
+    fun changePassword(presenter: ChangeAccountPasswordPresenter, request: RequestModel)
+
+    data class RequestModel(
+        val userId: UUID,
+        val oldPassword: String,
+        val newPassword: String,
+        val confirmPassword: String
+    )
+
+    @Schema(name = "ChangeAccountPasswordServiceResponseModel", description = "Response model for Change Account Password Service")
+    data class ResponseModel(
+        val userId: UUID
+    )
+}

account/src/main/kotlin/br/all/application/user/update/ChangeAccountPasswordServiceImpl.kt

@@ -0,0 +1,47 @@
+package br.all.application.user.update
+
+import br.all.application.user.repository.UserAccountRepository
+import br.all.domain.shared.service.PasswordEncoderPort
+
+class ChangeAccountPasswordServiceImpl(
+    private val repository: UserAccountRepository,
+    private val encoder: PasswordEncoderPort
+) : ChangeAccountPasswordService {
+    override fun changePassword(
+        presenter: ChangeAccountPasswordPresenter,
+        request: ChangeAccountPasswordService.RequestModel
+    ) {
+        val userCredentials = repository.loadCredentialsById(request.userId)
+        if (userCredentials == null) {
+            presenter.prepareFailView(NoSuchElementException("User with id ${request.userId} doesn't exist!"))
+            return
+        }
+
+        if (!encoder.matches(request.oldPassword, userCredentials.password)) {
+            presenter.prepareFailView(IllegalArgumentException("Invalid old password provided!"))
+            return
+        }
+
+        if (request.newPassword != request.confirmPassword) {
+            presenter.prepareFailView(IllegalArgumentException("Confirm password does not match new password!"))
+            return
+        }
+
+        if (encoder.matches(request.newPassword, userCredentials.password)) {
+            presenter.prepareFailView(IllegalArgumentException("New password cannot be the same as the old password!"))
+            return
+        }
+
+        val newHashedPassword = encoder.encode(request.newPassword)
+
+        try {
+            repository.updatePassword(request.userId, newHashedPassword)
+            presenter.prepareSuccessView(ChangeAccountPasswordService.ResponseModel(
+                request.userId,
+            ))
+        } catch (e: Exception) {
+            presenter.prepareFailView(e)
+        }
+    }
+
+}

account/src/main/kotlin/br/all/application/user/update/PatchUserProfilePresenter.kt

@@ -0,0 +1,6 @@
+package br.all.application.user.update
+
+import br.all.domain.shared.presenter.GenericPresenter
+import br.all.application.user.update.PatchUserProfileService.ResponseModel
+
+interface PatchUserProfilePresenter : GenericPresenter<ResponseModel>

account/src/main/kotlin/br/all/application/user/update/PatchUserProfileService.kt

@@ -0,0 +1,33 @@
+package br.all.application.user.update
+
+import io.swagger.v3.oas.annotations.media.Schema
+import java.util.UUID
+
+interface PatchUserProfileService {
+    fun patchProfile(presenter: PatchUserProfilePresenter, request: RequestModel)
+
+    data class RequestModel(
+        val userId: UUID,
+        val name: String,
+        val email: String,
+        val affiliation: String,
+        val country: String
+    )
+
+    @Schema(name = "PatchUserProfileServiceResponseModel", description = "Response model for Patch User Profile Service")
+    data class ResponseModel(
+        val userId: UUID,
+        val name: String,
+        val username: String,
+        val email: String,
+        val affiliation: String,
+        val country: String,
+        val invalidEntries: List<InvalidEntry>
+    )
+
+    data class InvalidEntry(
+        val field: String,
+        val entry: String,
+        val message: String
+    )
+}

account/src/main/kotlin/br/all/application/user/update/PatchUserProfileServiceImpl.kt

@@ -0,0 +1,71 @@
+package br.all.application.user.update
+
+import br.all.application.user.repository.UserAccountRepository
+import br.all.application.user.update.PatchUserProfileService.RequestModel
+import br.all.application.user.update.PatchUserProfileService.ResponseModel
+import br.all.application.user.update.PatchUserProfileService.InvalidEntry
+import br.all.domain.shared.user.Email
+import br.all.domain.shared.user.Name
+import br.all.domain.shared.user.Text
+
+class PatchUserProfileServiceImpl(
+    private val repository: UserAccountRepository
+) : PatchUserProfileService {
+    override fun patchProfile(
+        presenter: PatchUserProfilePresenter,
+        request: RequestModel
+    ) {
+        val userAccount = repository.loadFullUserAccountById(request.userId)
+        if (userAccount == null) {
+            presenter.prepareFailView(NoSuchElementException("User with id ${request.userId} doesn't exist!"))
+            return
+        }
+
+        val invalidEntries = mutableListOf<InvalidEntry>()
+
+        val updatedName = validateField("name", request.name, userAccount.name, invalidEntries) { Name(it).value }
+        val updatedEmail = validateField("email", request.email, userAccount.email, invalidEntries) { Email(it).email }
+        val updatedCountry = validateField("country", request.country, userAccount.country, invalidEntries) { Text(it).value }
+        val updatedAffiliation = validateField("affiliation", request.affiliation, userAccount.affiliation, invalidEntries) { Text(it).value }
+
+        val updatedUserAccount = userAccount.copy(
+            name = updatedName,
+            email = updatedEmail,
+            country = updatedCountry,
+            affiliation = updatedAffiliation
+        )
+
+        val responseModel = ResponseModel(
+            userId = request.userId,
+            name = updatedName,
+            username = userAccount.username,
+            email = updatedEmail,
+            affiliation = updatedAffiliation,
+            country = updatedCountry,
+            invalidEntries = invalidEntries
+        )
+
+        repository.save(updatedUserAccount)
+        presenter.prepareSuccessView(responseModel)
+    }
+
+    private fun validateField(
+        fieldName: String,
+        newValue: String,
+        currentValue: String,
+        errors: MutableList<InvalidEntry>,
+        validationLogic: (String) -> String
+    ): String {
+        return try {
+            validationLogic(newValue)
+        } catch (e: Exception) {
+            errors.add(InvalidEntry(
+                field = fieldName,
+                entry = newValue,
+                message = e.message ?: "Invalid $fieldName format"
+            ))
+
+            currentValue
+        }
+    }
+}

account/src/main/kotlin/br/all/domain/user/AccountCredentials.kt

@@ -1,5 +1,7 @@
 package br.all.domain.user
 
+import br.all.domain.shared.user.Username
+
 class AccountCredentials (
     val username: Username,
     val password: String,

account/src/main/kotlin/br/all/domain/user/UserAccount.kt

@@ -2,11 +2,15 @@ package br.all.domain.user
 
 import br.all.domain.shared.ddd.Entity
 import br.all.domain.shared.user.Email
+import br.all.domain.shared.user.Name
+import br.all.domain.shared.user.Text
+import br.all.domain.shared.user.Username
 import java.time.LocalDateTime
 import java.util.UUID
 
 class UserAccount(
     id: UserAccountId,
+    var name: Name,
     val createdAt: LocalDateTime = LocalDateTime.now(),
     var email: Email,
     var country: Text,

account/src/main/kotlin/br/all/infrastructure/user/UserAccountEntity.kt

@@ -8,6 +8,8 @@ import java.util.*
 @Table(name = "USER_ACCOUNTS")
 class UserAccountEntity (
     @Id var id: UUID,
+    @Column(nullable = false)
+    var name: String,
     @OneToOne( mappedBy = "userAccount", cascade = [CascadeType.ALL])
     @PrimaryKeyJoinColumn
     var accountCredentialsEntity: AccountCredentialsEntity,