refactor: find protocol stage service

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

@@ -7,6 +7,7 @@ interface RegisterUserAccountService {
     fun register(presenter: RegisterUserAccountPresenter, request: RequestModel)
 
     data class RequestModel(
+        val name: String,
         val username: String,
         val password: String,
         val email: 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

@@ -10,6 +10,7 @@ interface RetrieveUserProfileService {
 
     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

@@ -26,6 +26,7 @@ class RetrieveUserProfileServiceImpl(
 
         val profile = ResponseModel(
             userId = userProfile.id,
+            name = userProfile.name,
             username = userCredentials.username,
             email = userProfile.email,
             affiliation = userProfile.affiliation,

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/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/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,26 @@
+package br.all.application.user.update
+
+import java.util.UUID
+
+interface PatchUserProfileService {
+    fun patchProfile(presenter: PatchUserProfilePresenter, request: RequestModel)
+
+    data class RequestModel(
+        val userId: UUID,
+        val name: String?,
+        val username: String?,
+        val email: String?,
+        val affiliation: String?,
+        val country: String?
+    )
+
+    data class ResponseModel(
+        val userId: UUID,
+        val name: String,
+        val username: String,
+        val email: String,
+        val affiliation: String,
+        val country: String,
+        val invalidEntries: List<String>
+    )
+}

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

@@ -0,0 +1,48 @@
+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.domain.shared.user.Email
+import br.all.domain.shared.user.Text
+import br.all.domain.shared.user.Username
+
+class PatchUserProfileServiceImpl(
+    private val repository: UserAccountRepository
+) : PatchUserProfileService {
+    override fun patchProfile(
+        presenter: PatchUserProfilePresenter,
+        request: RequestModel
+    ) {
+        if (repository.loadCredentialsById(request.userId) == null) {
+            presenter.prepareFailView(NoSuchElementException("User with id ${request.userId} not found!"))
+        }
+
+        if (presenter.isDone()) return
+
+//        val newUsername = Username(request.username)
+//        val newEmail = Email(request.email)
+//        val affiliation = Text(request.affiliation)
+//        val country = Text(request.country)
+
+        // TODO(): add invalid entries to the response model array
+        // TODO(): update only the valid entries
+
+        //    data class RequestModel(
+        //        val userId: UUID,
+        //        val username: String,
+        //        val email: String,
+        //        val affiliation: String,
+        //        val country: String
+        //    )
+        //
+        //    data class ResponseModel(
+        //        val userId: UUID,
+        //        val username: String,
+        //        val email: String,
+        //        val affiliation: String,
+        //        val country: String,
+        //        val invalidEntries: List<String>
+        //    )
+    }
+}

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,

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

@@ -16,13 +16,14 @@ fun UserAccountDto.toUserAccountEntity(): UserAccountEntity {
         isCredentialsNonExpired,
         isEnabled
     )
-    return UserAccountEntity(id, credentials, email, country, affiliation, createdAt)
+    return UserAccountEntity(id, name, credentials, email, country, affiliation, createdAt)
 }
 
 fun AccountCredentialsEntity.toAccountCredentialsDto() = AccountCredentialsDto(id, username, password, authorities, refreshToken)
 
 fun UserAccountEntity.toUserProfileDto() = UserProfileDto(
     id = this.id,
+    name = this.name,
     email = this.email,
     country = this.country,
     affiliation = this.affiliation

account/src/test/kotlin/br/all/application/user/find/RetrieveUserProfileServiceImplTest.kt

@@ -56,6 +56,7 @@ class RetrieveUserProfileServiceImplTest {
 
             val capturedResponse = responseSlot.captured
             assertEquals(userProfile.id, capturedResponse.userId)
+            assertEquals(userProfile.name, capturedResponse.name)
             assertEquals(userCredentials.username, capturedResponse.username)
             assertEquals(userProfile.email, capturedResponse.email)
             assertEquals(userProfile.affiliation, capturedResponse.affiliation)

account/src/test/kotlin/br/all/application/user/utils/TestDataFactory.kt

@@ -14,7 +14,8 @@ class TestDataFactory {
         password = faker.pearlJam.songs(),
         email = faker.internet.email(),
         country = faker.address.countryCode(),
-        affiliation = faker.lorem.words()
+        affiliation = faker.lorem.words(),
+        name = faker.name.neutralFirstName()
     )
 
     fun accountCredentials()
@@ -31,5 +32,6 @@ class TestDataFactory {
         email = faker.internet.email(),
         country = faker.address.countryCode(),
         affiliation = faker.leagueOfLegends.rank(),
+        name = faker.name.firstName()
     )
 }

account/src/test/kotlin/br/all/domain/user/UserAccountTest.kt

@@ -1,6 +1,9 @@
 package br.all.domain.user
 
 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 io.github.serpro69.kfaker.Faker
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Tag
@@ -53,6 +56,8 @@ class UserAccountTest{
         Assertions.assertTrue(user.accountCredentials.isEnabled)
     }
 
+    // Although the user won't be able to change their username through the front-end,
+    // I think we should still let this test here.
     @Test
     fun `should change username in account credentials`(){
         val user = createUser()
@@ -71,16 +76,18 @@ class UserAccountTest{
 
     private fun createUser(
         id: UUID = UUID.randomUUID(),
+        name: Name = Name(faker.name.name()),
         createdAt: LocalDateTime = LocalDateTime.now(),
         email: Email = Email(faker.internet.email()),
         country: Text = Text(faker.address.countryCode()),
         affiliation: String = faker.lorem.words(),
         username: Username = Username(faker.name.firstName()),
         password: String = faker.pearlJam.songs(),
         authorities: Set<Authority> = setOf(Authority.USER)
-        ) = UserAccount(
-        UserAccountId(id),
-        createdAt, email, country, affiliation, username, password, authorities
+    ) = UserAccount(
+        id = UserAccountId(id),
+        name = name,
+        createdAt = createdAt, email = email, country = country, affiliation = affiliation, username = username, password = password, authorities = authorities
     )
 
 }

review/src/main/kotlin/br/all/application/protocol/find/FindProtocolStageService.kt

@@ -19,14 +19,18 @@ interface FindProtocolStageService {
     )
 
     enum class ProtocolStage {
-        PROTOCOL_PART_I,
+        GENERAL_DEFINITION,
+        RESEARCH_QUESTIONS,
         PICOC,
-        PROTOCOL_PART_II,
-        PROTOCOL_PART_III,
+        ELIGIBILITY_CRITERIA,
+        INFORMATION_SOURCES_AND_SEARCH_STRATEGY,
+        SELECTION_AND_EXTRACTION,
+        RISK_OF_BIAS,
+        ANALYSIS_AND_SYNTHESIS_METHOD,
+
         IDENTIFICATION,
         SELECTION,
         EXTRACTION,
-        GRAPHICS,
-        FINALIZATION
+        GRAPHICS
     }
 }