added jwt auth to service

src/main/java/zw/qantra/tm/domain/controllers/AuthController.java

@@ -0,0 +1,36 @@
+package zw.qantra.tm.domain.controllers;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import zw.qantra.tm.domain.dtos.AuthResponse;
+import zw.qantra.tm.domain.dtos.LoginRequest;
+import zw.qantra.tm.domain.dtos.RegisterRequest;
+import zw.qantra.tm.domain.services.UserService;
+
+@RestController
+@RequestMapping("/auth")
+@RequiredArgsConstructor
+@CrossOrigin(origins = "*")
+public class AuthController {
+
+    private final UserService userService;
+
+    @PostMapping("/register")
+    public ResponseEntity<AuthResponse> register(@Valid @RequestBody RegisterRequest request) {
+        AuthResponse response = userService.register(request);
+        return ResponseEntity.ok(response);
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<AuthResponse> login(@Valid @RequestBody LoginRequest request) {
+        AuthResponse response = userService.login(request);
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping("/test")
+    public ResponseEntity<String> test() {
+        return ResponseEntity.ok("Authentication endpoints are working!");
+    }
+}

src/main/java/zw/qantra/tm/domain/controllers/TestController.java

@@ -0,0 +1,27 @@
+package zw.qantra.tm.domain.controllers;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/test")
+@CrossOrigin(origins = "*")
+public class TestController {
+
+    @GetMapping("/protected")
+    public ResponseEntity<String> protectedEndpoint() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        String username = authentication.getName();
+        return ResponseEntity.ok("Hello " + username + "! This is a protected endpoint.");
+    }
+
+    @GetMapping("/public")
+    public ResponseEntity<String> publicEndpoint() {
+        return ResponseEntity.ok("This is a public endpoint - no authentication required!");
+    }
+}

src/main/java/zw/qantra/tm/domain/dtos/AuthResponse.java

@@ -0,0 +1,16 @@
+package zw.qantra.tm.domain.dtos;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class AuthResponse {
+    private String token;
+    private String type = "Bearer";
+    private String username;
+    private String email;
+    private String phone;
+    private String firstName;
+    private String lastName;
+}

src/main/java/zw/qantra/tm/domain/dtos/LoginRequest.java

@@ -0,0 +1,13 @@
+package zw.qantra.tm.domain.dtos;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+@Data
+public class LoginRequest {
+    @NotBlank(message = "Username is required")
+    private String username;
+    
+    @NotBlank(message = "Password is required")
+    private String password;
+}

src/main/java/zw/qantra/tm/domain/dtos/RegisterRequest.java

@@ -0,0 +1,30 @@
+package zw.qantra.tm.domain.dtos;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Data
+public class RegisterRequest {
+    @NotBlank(message = "Username is required")
+    @Size(min = 3, max = 50, message = "Username must be between 3 and 50 characters")
+    private String username;
+    
+    @NotBlank(message = "Password is required")
+    @Size(min = 6, message = "Password must be at least 6 characters")
+    private String password;
+    
+    @NotBlank(message = "Email is required")
+    @Email(message = "Email should be valid")
+    private String email;
+    
+    @NotBlank(message = "First name is required")
+    private String firstName;
+    
+    @NotBlank(message = "Last name is required")
+    private String lastName;
+
+    @NotBlank(message = "Phone is required")
+    private String phone;
+}

src/main/java/zw/qantra/tm/domain/models/User.java

@@ -0,0 +1,71 @@
+package zw.qantra.tm.domain.models;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.util.Collection;
+import java.util.List;
+
+@Entity
+@Table(name = "users")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class User extends BaseEntity implements UserDetails {
+    
+    @Column(unique = true, nullable = false)
+    private String username;
+    
+    @Column(nullable = false)
+    private String password;
+    
+    @Column(unique = true, nullable = false)
+    private String email;
+    private String phone;
+    
+    @Column(name = "first_name")
+    private String firstName;
+    
+    @Column(name = "last_name")
+    private String lastName;
+    
+    @Column(name = "is_enabled")
+    private boolean enabled = true;
+    
+    @Column(name = "is_account_non_expired")
+    private boolean accountNonExpired = true;
+    
+    @Column(name = "is_account_non_locked")
+    private boolean accountNonLocked = true;
+    
+    @Column(name = "is_credentials_non_expired")
+    private boolean credentialsNonExpired = true;
+    
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        return List.of(new SimpleGrantedAuthority("ROLE_USER"));
+    }
+    
+    @Override
+    public boolean isAccountNonExpired() {
+        return accountNonExpired;
+    }
+    
+    @Override
+    public boolean isAccountNonLocked() {
+        return accountNonLocked;
+    }
+    
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return credentialsNonExpired;
+    }
+    
+    @Override
+    public boolean isEnabled() {
+        return enabled;
+    }
+}

src/main/java/zw/qantra/tm/domain/repositories/UserRepository.java

@@ -0,0 +1,16 @@
+package zw.qantra.tm.domain.repositories;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import zw.qantra.tm.domain.models.User;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByUsername(String username);
+    Optional<User> findByEmail(String email);
+    Optional<User> findByPhone(String phone);
+    boolean existsByUsername(String username);
+    boolean existsByEmail(String email);
+}

src/main/java/zw/qantra/tm/domain/services/UserService.java

@@ -0,0 +1,67 @@
+package zw.qantra.tm.domain.services;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import zw.qantra.tm.domain.dtos.AuthResponse;
+import zw.qantra.tm.domain.dtos.LoginRequest;
+import zw.qantra.tm.domain.dtos.RegisterRequest;
+import zw.qantra.tm.domain.models.User;
+import zw.qantra.tm.domain.repositories.UserRepository;
+import zw.qantra.tm.utils.JwtUtils;
+
+@Service
+@RequiredArgsConstructor
+public class UserService implements UserDetailsService {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final JwtUtils jwtUtils;
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        return userRepository.findByUsername(username)
+                .orElseThrow(() -> new UsernameNotFoundException("User not found with username: " + username));
+    }
+
+    public AuthResponse register(RegisterRequest request) {
+        if (userRepository.existsByUsername(request.getUsername())) {
+            throw new RuntimeException("Username already exists");
+        }
+        
+        if (userRepository.existsByEmail(request.getEmail())) {
+            throw new RuntimeException("Email already exists");
+        }
+
+        User user = new User();
+        user.setUsername(request.getUsername());
+        user.setPassword(passwordEncoder.encode(request.getPassword()));
+        user.setEmail(request.getEmail());
+        user.setFirstName(request.getFirstName());
+        user.setLastName(request.getLastName());
+        user.setPhone(request.getPhone());
+
+        User savedUser = userRepository.save(user);
+        String token = jwtUtils.generateToken(savedUser);
+
+        return new AuthResponse(token, "Bearer", savedUser.getUsername(), 
+                savedUser.getEmail(), savedUser.getPhone(), savedUser.getFirstName(), savedUser.getLastName());
+    }
+
+    public AuthResponse login(LoginRequest request) {
+        User user = userRepository.findByUsername(request.getUsername())
+                .orElseThrow(() -> new RuntimeException("Invalid username or password"));
+        
+        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
+            throw new RuntimeException("Invalid username or password");
+        }
+        
+        String token = jwtUtils.generateToken(user);
+        
+        return new AuthResponse(token, "Bearer", user.getUsername(), 
+                user.getEmail(), user.getPhone(), user.getFirstName(), user.getLastName());
+    }
+}