[TASK:PPD2B002]

src/main/java/com/soupulsar/modulith/auth/api/controllers/AuthController.java

@@ -1,36 +1,38 @@
 package com.soupulsar.modulith.auth.api.controllers;
 
 import com.soupulsar.modulith.auth.application.dto.AuthUserRequest;
-import com.soupulsar.modulith.auth.application.dto.CreateUserRequest;
-import com.soupulsar.modulith.auth.application.dto.CreateUserResponse;
+import com.soupulsar.modulith.auth.application.dto.AuthUserResponse;
+import com.soupulsar.modulith.auth.application.dto.RegistrationRequest;
+import com.soupulsar.modulith.auth.application.dto.RegistrationResponse;
 import com.soupulsar.modulith.auth.application.usecase.AuthenticateUserUseCase;
-import com.soupulsar.modulith.auth.application.usecase.RegisterUserUseCase;
+import com.soupulsar.modulith.auth.application.usecase.RegistrationUseCase;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.net.URI;
+
 @RestController
 @RequestMapping("/api/auth")
 @RequiredArgsConstructor
 public class AuthController {
 
     private final AuthenticateUserUseCase authenticateUserUseCase;
-    private final RegisterUserUseCase registerUserUseCase;
+    private final RegistrationUseCase registrationUseCase;
 
 
     @PostMapping(value = {"/login", "/signin"})
-    public ResponseEntity<String> login(@RequestBody AuthUserRequest request) {
-        String token = authenticateUserUseCase.execute(request);
-        return ResponseEntity.ok(token);
+    public ResponseEntity<AuthUserResponse> login(@RequestBody @Valid AuthUserRequest request) {
+        return ResponseEntity.ok(authenticateUserUseCase.execute(request));
     }
 
     @PostMapping(value = {"/register", "/signup"})
-    public ResponseEntity<CreateUserResponse> register(@RequestBody CreateUserRequest request) {
-        var response = registerUserUseCase.execute(request);
-        return ResponseEntity.ok(response);
-
+    public ResponseEntity<RegistrationResponse> register(@RequestBody @Valid RegistrationRequest request) {
+        var response = registrationUseCase.execute(request);
+        return ResponseEntity.created(URI.create("/api/users/" + response.userId())).body(response);
     }
 }

src/main/java/com/soupulsar/modulith/auth/application/config/AuthUseCaseConfig.java

@@ -3,7 +3,9 @@
 import com.soupulsar.modulith.auth.application.security.JwtService;
 import com.soupulsar.modulith.auth.application.security.PasswordHasher;
 import com.soupulsar.modulith.auth.application.usecase.AuthenticateUserUseCase;
-import com.soupulsar.modulith.auth.application.usecase.RegisterUserUseCase;
+import com.soupulsar.modulith.auth.application.usecase.RegistrationUseCase;
+import com.soupulsar.modulith.auth.domain.repository.ClientProfileRepository;
+import com.soupulsar.modulith.auth.domain.repository.SpecialistProfileRepository;
 import com.soupulsar.modulith.auth.domain.repository.UserRepository;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -17,8 +19,9 @@ public AuthenticateUserUseCase authenticateUserUseCase(UserRepository userReposi
     }
 
     @Bean
-    public RegisterUserUseCase registerUserUseCase(UserRepository userRepository, PasswordHasher passwordHasher) {
-        return new RegisterUserUseCase(userRepository, passwordHasher);
+    public RegistrationUseCase registrationUseCase(UserRepository userRepository, ClientProfileRepository clientProfileRepository,
+                                                   SpecialistProfileRepository specialistProfileRepository, PasswordHasher passwordHasher) {
+        return new RegistrationUseCase(userRepository, clientProfileRepository, specialistProfileRepository,passwordHasher);
     }
 
 

src/main/java/com/soupulsar/modulith/auth/application/dto/AuthUserResponse.java

@@ -0,0 +1,13 @@
+package com.soupulsar.modulith.auth.application.dto;
+
+import java.util.Date;
+
+public record AuthUserResponse(
+
+        String accessToken,
+        String tokenType,
+        String subject,
+        Date issuedAt,
+        Long expiresIn
+) {
+}

src/main/java/com/soupulsar/modulith/auth/application/dto/RegistrationRequest.java

@@ -0,0 +1,44 @@
+package com.soupulsar.modulith.auth.application.dto;
+
+import com.soupulsar.modulith.auth.domain.model.enums.UserRole;
+import com.soupulsar.modulith.auth.domain.model.vo.Address;
+import com.soupulsar.modulith.auth.domain.model.vo.EmergencyContact;
+import com.soupulsar.modulith.auth.domain.model.vo.Presentation;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import org.hibernate.validator.constraints.br.CPF;
+
+import java.util.Date;
+import java.util.List;
+
+public record RegistrationRequest(
+
+        // User info
+        @NotBlank
+        String name,
+        @NotBlank
+        @CPF
+        String cpf,
+        @NotBlank
+        String telephone,
+        @NotBlank
+        String email,
+        @NotBlank
+        String password,
+        @NotNull
+        UserRole role,
+        @NotNull
+        Address address,
+
+        // Client info
+        Date dateOfBirth,
+        EmergencyContact emergencyContact,
+
+        // Specialist info
+        String registrationNumber,
+        Presentation presentation,
+        List<String> formations,
+        List<String> specialties,
+        List<String> approaches
+) {
+}

src/main/java/com/soupulsar/modulith/auth/application/dto/CreateUserResponse.java → src/main/java/com/soupulsar/modulith/auth/application/dto/RegistrationResponse.java

@@ -2,7 +2,8 @@
 
 import java.util.UUID;
 
-public record CreateUserResponse(
+public record RegistrationResponse(
+
         UUID userId
 ) {
 }

src/main/java/com/soupulsar/modulith/auth/application/usecase/AuthenticateUserUseCase.java

@@ -1,21 +1,25 @@
 package com.soupulsar.modulith.auth.application.usecase;
 
 import com.soupulsar.modulith.auth.application.dto.AuthUserRequest;
+import com.soupulsar.modulith.auth.application.dto.AuthUserResponse;
 import com.soupulsar.modulith.auth.application.security.JwtService;
 import com.soupulsar.modulith.auth.application.security.PasswordHasher;
 import com.soupulsar.modulith.auth.domain.model.User;
 import com.soupulsar.modulith.auth.domain.model.enums.UserStatus;
 import com.soupulsar.modulith.auth.domain.repository.UserRepository;
+import io.jsonwebtoken.Claims;
 import lombok.RequiredArgsConstructor;
 
+import java.util.Date;
+
 @RequiredArgsConstructor
 public class AuthenticateUserUseCase {
 
     private final UserRepository userRepository;
     private final PasswordHasher passwordHasher;
     private final JwtService jwtService;
 
-    public String execute(AuthUserRequest request) {
+    public AuthUserResponse execute(AuthUserRequest request) {
 
         User user = userRepository.findByEmail(request.email())
                 .orElseThrow(() -> new IllegalArgumentException("Invalid email or password"));
@@ -28,7 +32,17 @@ public String execute(AuthUserRequest request) {
             throw new IllegalArgumentException("Invalid email or password");
         }
 
-        return jwtService.generateToken(user);
-
+        var token = jwtService.generateToken(user);
+        Date issuedAt = jwtService.extractClaim(token, Claims::getIssuedAt);
+        String subject = jwtService.extractClaim(token, Claims::getSubject);
+        Long expiresIn = (jwtService.extractClaim(token, Claims::getExpiration).getTime() - System.currentTimeMillis()) / 1000;
+
+        return new AuthUserResponse(
+                token,
+                "Bearer",
+                subject,
+                issuedAt,
+                expiresIn
+        );
     }
 }

src/main/java/com/soupulsar/modulith/auth/application/usecase/RegistrationUseCase.java

@@ -0,0 +1,74 @@
+package com.soupulsar.modulith.auth.application.usecase;
+
+import com.soupulsar.modulith.auth.application.dto.RegistrationRequest;
+import com.soupulsar.modulith.auth.application.dto.RegistrationResponse;
+import com.soupulsar.modulith.auth.application.security.PasswordHasher;
+import com.soupulsar.modulith.auth.domain.model.ClientProfile;
+import com.soupulsar.modulith.auth.domain.model.SpecialistProfile;
+import com.soupulsar.modulith.auth.domain.model.User;
+import com.soupulsar.modulith.auth.domain.model.enums.UserRole;
+import com.soupulsar.modulith.auth.domain.repository.ClientProfileRepository;
+import com.soupulsar.modulith.auth.domain.repository.SpecialistProfileRepository;
+import com.soupulsar.modulith.auth.domain.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.transaction.annotation.Transactional;
+
+
+@RequiredArgsConstructor
+public class RegistrationUseCase {
+
+    private final UserRepository userRepository;
+    private final ClientProfileRepository clientProfileRepository;
+    private final SpecialistProfileRepository specialistProfileRepository;
+    private final PasswordHasher passwordHasher;
+
+    @Transactional
+    public RegistrationResponse execute(RegistrationRequest request) {
+
+        if(userRepository.existsByEmail(request.email()) || userRepository.existsByCpf(request.cpf())) {
+            throw new IllegalArgumentException("Email or CPF already exists");
+        }
+
+        User user = User.create(
+                request.name(),
+                normalizeDigits(request.cpf()),
+                normalizeDigits(request.telephone()),
+                request.email(),
+                passwordHasher.hash(request.password()),
+                request.role(),
+                request.address().withZipCode(normalizeDigits(request.address().getZipCode()))
+        );
+        userRepository.save(user);
+
+        if (request.role() == UserRole.CLIENT) {
+            ClientProfile clientProfile = ClientProfile.create(
+                    user.getUserId(),
+                    request.dateOfBirth(),
+                    request.emergencyContact().withPhoneNumber(normalizeDigits(request.emergencyContact().getPhoneNumber()))
+            );
+            clientProfileRepository.save(clientProfile);
+
+        } else if (request.role() == UserRole.SPECIALIST) {
+            SpecialistProfile specialistProfile = SpecialistProfile.create(
+                    user.getUserId(),
+                    request.registrationNumber(),
+                    request.presentation(),
+                    request.formations(),
+                    request.specialties(),
+                    request.approaches()
+            );
+            specialistProfileRepository.save(specialistProfile);
+        } else {
+            throw new IllegalArgumentException("Invalid user role");
+        }
+
+        return new RegistrationResponse(user.getUserId());
+
+    }
+
+
+    private String normalizeDigits(String input) {
+        return input != null ? input.replaceAll("\\D", "") : null;
+    }
+
+}

src/main/java/com/soupulsar/modulith/auth/domain/model/ClientProfile.java

@@ -0,0 +1,43 @@
+package com.soupulsar.modulith.auth.domain.model;
+
+import com.soupulsar.modulith.auth.domain.model.vo.EmergencyContact;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.Date;
+import java.util.UUID;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+@Builder
+public class ClientProfile {
+
+    private final UUID profileId;
+    private final UUID userId;
+    private final Date dateOfBirth;
+    private final EmergencyContact emergencyContact;
+
+
+    public static ClientProfile create(UUID userId, Date dateOfBirth, EmergencyContact emergencyContact) {
+        if (userId == null) throw new IllegalArgumentException("User ID cannot be null");
+        if (dateOfBirth == null) throw new IllegalArgumentException("Date of birth cannot be null");
+        if (emergencyContact == null) throw new IllegalArgumentException("Emergency contact cannot be null");
+        return ClientProfile.builder()
+                .profileId(UUID.randomUUID())
+                .userId(userId)
+                .dateOfBirth(dateOfBirth)
+                .emergencyContact(emergencyContact)
+                .build();
+    }
+
+    public static ClientProfile restore(UUID profileId, UUID userId, Date dateOfBirth, EmergencyContact emergencyContact) {
+        return ClientProfile.builder()
+                .profileId(profileId)
+                .userId(userId)
+                .dateOfBirth(dateOfBirth)
+                .emergencyContact(emergencyContact)
+                .build();
+    }
+}