201 lines
8.9 KiB
Java
201 lines
8.9 KiB
Java
package com.moyi.controlplane.auth;
|
|
|
|
import jakarta.servlet.http.Cookie;
|
|
import jakarta.servlet.http.HttpServletRequest;
|
|
import jakarta.servlet.http.HttpServletResponse;
|
|
import java.time.Duration;
|
|
import java.time.OffsetDateTime;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import org.springframework.beans.factory.annotation.Value;
|
|
import org.springframework.http.HttpHeaders;
|
|
import org.springframework.http.HttpStatus;
|
|
import org.springframework.http.ResponseCookie;
|
|
import org.springframework.http.ResponseEntity;
|
|
import org.springframework.web.bind.annotation.GetMapping;
|
|
import org.springframework.web.bind.annotation.PathVariable;
|
|
import org.springframework.web.bind.annotation.PostMapping;
|
|
import org.springframework.web.bind.annotation.PatchMapping;
|
|
import org.springframework.web.bind.annotation.RequestBody;
|
|
import org.springframework.web.bind.annotation.RequestMapping;
|
|
import org.springframework.web.bind.annotation.RequestParam;
|
|
import org.springframework.web.bind.annotation.RestController;
|
|
|
|
@RestController
|
|
@RequestMapping("/api")
|
|
public class AuthController {
|
|
private static final String SESSION_COOKIE = "moyi_session";
|
|
private final AuthService authService;
|
|
private final VerificationService verification;
|
|
private final VerifiedAccountService verifiedAccounts;
|
|
private final int sessionTtlHours;
|
|
private final boolean secureCookie;
|
|
|
|
public AuthController(
|
|
AuthService authService,
|
|
VerificationService verification,
|
|
VerifiedAccountService verifiedAccounts,
|
|
@Value("${moyi.auth.session-ttl-hours}") int sessionTtlHours,
|
|
@Value("${moyi.auth.secure-cookie}") boolean secureCookie
|
|
) {
|
|
this.authService = authService;
|
|
this.verification = verification;
|
|
this.verifiedAccounts = verifiedAccounts;
|
|
this.sessionTtlHours = sessionTtlHours;
|
|
this.secureCookie = secureCookie;
|
|
}
|
|
|
|
public record LoginRequest(String account, String password,String otp) {
|
|
public LoginRequest(String account,String password) {this(account,password,null);}
|
|
}
|
|
|
|
public record RegisterRequest(String invitationCode, String account, String password, String displayName, String verificationCode) {}
|
|
public record CodeRequest(String account, String invitationCode) {}
|
|
public record PasswordResetCodeRequest(String account) {}
|
|
public record PasswordResetRequest(String account, String verificationCode, String newPassword) {}
|
|
|
|
@GetMapping("/auth/verification")
|
|
public Map<String,Boolean> verificationStatus() { return verification.capabilities(); }
|
|
|
|
@PostMapping("/auth/verification")
|
|
public Map<String,Object> sendCode(@RequestBody CodeRequest input,HttpServletRequest request) {
|
|
return verification.send(input.account(),input.invitationCode(),request.getRemoteAddr());
|
|
}
|
|
|
|
@PostMapping("/auth/password-reset/code")
|
|
public Map<String,Object> sendPasswordResetCode(@RequestBody PasswordResetCodeRequest input,HttpServletRequest request) {
|
|
return verification.sendReset(input.account(), request.getRemoteAddr());
|
|
}
|
|
|
|
@PostMapping("/auth/password-reset")
|
|
public ResponseEntity<Void> resetPassword(@RequestBody PasswordResetRequest input,HttpServletRequest request) {
|
|
verifiedAccounts.resetPassword(input.account(), input.verificationCode(), input.newPassword(), meta(request));
|
|
return ResponseEntity.noContent().header(HttpHeaders.SET_COOKIE, sessionCookie("", Duration.ZERO).toString()).build();
|
|
}
|
|
|
|
public record InvitationRequest(String label, Integer maxUses, OffsetDateTime expiresAt) {}
|
|
|
|
public record RoleRequest(String role) {}
|
|
public record CreateUserRequest(String account, String password, String displayName) {}
|
|
public record AccountSettingsRequest(String displayName, String currentPassword, String newPassword) {}
|
|
|
|
@PostMapping("/admin/users")
|
|
public ResponseEntity<Map<String,Object>> createUser(@RequestBody CreateUserRequest input, HttpServletRequest request) {
|
|
return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("user",authService.createUser(sessionToken(request),input.account(),input.password(),input.displayName(),meta(request))));
|
|
}
|
|
|
|
@PostMapping("/auth/login")
|
|
public Map<String, Object> login(
|
|
@RequestBody LoginRequest input,
|
|
HttpServletRequest request,
|
|
HttpServletResponse response
|
|
) {
|
|
AuthService.AuthResult result = authService.login(input.account(), input.password(), input.otp(), meta(request));
|
|
// Keep the browser session cookie ephemeral. The server-side session still
|
|
// has its normal TTL, but a closed browser must require a fresh login.
|
|
response.addHeader(HttpHeaders.SET_COOKIE, sessionCookie(result.token(), null).toString());
|
|
return Map.of("user", result.user());
|
|
}
|
|
|
|
@PostMapping("/auth/register")
|
|
public ResponseEntity<Map<String, Object>> register(
|
|
@RequestBody RegisterRequest input,
|
|
HttpServletRequest request,
|
|
HttpServletResponse response
|
|
) {
|
|
AuthService.AuthResult result = verifiedAccounts.register(
|
|
input.invitationCode(), input.account(), input.password(), input.displayName(), input.verificationCode(), meta(request)
|
|
);
|
|
response.addHeader(HttpHeaders.SET_COOKIE, sessionCookie(result.token(), null).toString());
|
|
return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("user", result.user()));
|
|
}
|
|
|
|
@PostMapping("/auth/logout")
|
|
public ResponseEntity<Void> logout(HttpServletRequest request, HttpServletResponse response) {
|
|
authService.logout(sessionToken(request), meta(request));
|
|
response.addHeader(HttpHeaders.SET_COOKIE, sessionCookie("", Duration.ZERO).toString());
|
|
return ResponseEntity.noContent().build();
|
|
}
|
|
|
|
@GetMapping("/auth/me")
|
|
public Map<String, Object> currentUser(HttpServletRequest request) {
|
|
return Map.of("user", authService.requireUser(sessionToken(request)));
|
|
}
|
|
|
|
@PatchMapping("/auth/account")
|
|
public Map<String, Object> updateAccount(@RequestBody AccountSettingsRequest input, HttpServletRequest request, HttpServletResponse response) {
|
|
var user = authService.updateAccount(
|
|
sessionToken(request), input.displayName(), input.currentPassword(), input.newPassword(), meta(request)
|
|
);
|
|
if (input.newPassword() != null) response.addHeader(HttpHeaders.SET_COOKIE, sessionCookie("", Duration.ZERO).toString());
|
|
return Map.of("user", user);
|
|
}
|
|
|
|
@GetMapping("/admin/users")
|
|
public Map<String, Object> users(HttpServletRequest request) {
|
|
return Map.of("users", authService.listUsers(sessionToken(request)));
|
|
}
|
|
|
|
@PostMapping("/admin/users/{id}/role")
|
|
public Map<String, Object> changeRole(
|
|
@PathVariable UUID id,
|
|
@RequestBody RoleRequest input,
|
|
HttpServletRequest request
|
|
) {
|
|
return Map.of("user", authService.changeRole(sessionToken(request), id, input.role(), meta(request)));
|
|
}
|
|
|
|
@GetMapping("/admin/invitations")
|
|
public Map<String, Object> invitations(HttpServletRequest request) {
|
|
return Map.of("invitations", authService.listInvitations(sessionToken(request)));
|
|
}
|
|
|
|
@PostMapping("/admin/invitations")
|
|
public ResponseEntity<Map<String, Object>> createInvitation(
|
|
@RequestBody InvitationRequest input,
|
|
HttpServletRequest request
|
|
) {
|
|
return ResponseEntity.status(HttpStatus.CREATED).body(authService.createInvitation(
|
|
sessionToken(request), input.label(), input.maxUses(), input.expiresAt(), meta(request)
|
|
));
|
|
}
|
|
|
|
@PostMapping("/admin/invitations/{id}/revoke")
|
|
public ResponseEntity<Void> revokeInvitation(@PathVariable UUID id, HttpServletRequest request) {
|
|
authService.revokeInvitation(sessionToken(request), id, meta(request));
|
|
return ResponseEntity.noContent().build();
|
|
}
|
|
|
|
@GetMapping("/admin/audit")
|
|
public Map<String, Object> audit(
|
|
@RequestParam(defaultValue = "100") int limit,
|
|
HttpServletRequest request
|
|
) {
|
|
return Map.of("events", authService.listAudit(sessionToken(request), limit));
|
|
}
|
|
|
|
private ResponseCookie sessionCookie(String value, Duration maxAge) {
|
|
var builder = ResponseCookie.from(SESSION_COOKIE, value)
|
|
.httpOnly(true)
|
|
.secure(secureCookie)
|
|
.sameSite("Lax")
|
|
.path("/");
|
|
if (maxAge != null) builder.maxAge(maxAge);
|
|
return builder.build();
|
|
}
|
|
|
|
public static String sessionToken(HttpServletRequest request) {
|
|
Cookie[] cookies = request.getCookies();
|
|
if (cookies == null) return null;
|
|
for (Cookie cookie : cookies) {
|
|
if (SESSION_COOKIE.equals(cookie.getName())) return cookie.getValue();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static AuthService.RequestMeta meta(HttpServletRequest request) {
|
|
return new AuthService.RequestMeta(request.getRemoteAddr(), request.getHeader(HttpHeaders.USER_AGENT));
|
|
}
|
|
}
|