Files
moyi-model-intelligence-hub/control-plane-java/src/main/java/com/moyi/controlplane/auth/AuthController.java
T

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));
}
}