forked from longtao.wu/droboticflow
920 lines
30 KiB
Go
920 lines
30 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"net/http"
|
|
"net/mail"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"droboticflow/internal/domain"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"golang.org/x/crypto/bcrypt"
|
|
)
|
|
|
|
const sessionCookieName = "droboticflow_session"
|
|
const csrfCookieName = "droboticflow_csrf"
|
|
const csrfHeaderName = "X-Droboticflow-CSRF-Token"
|
|
const sessionTTL = 7 * 24 * time.Hour
|
|
|
|
var organizationSlugPattern = regexp.MustCompile(`^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$`)
|
|
|
|
type authContextKey struct{}
|
|
|
|
type authenticatedPrincipal struct {
|
|
User domain.UserRecord
|
|
Organization domain.OrganizationRecord
|
|
}
|
|
|
|
func hashPassword(password string) (string, error) {
|
|
hashed, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(hashed), nil
|
|
}
|
|
|
|
func verifyPassword(password string, passwordHash string) bool {
|
|
return bcrypt.CompareHashAndPassword([]byte(passwordHash), []byte(password)) == nil
|
|
}
|
|
|
|
func randomURLToken(size int) (string, error) {
|
|
buffer := make([]byte, size)
|
|
if _, err := rand.Read(buffer); err != nil {
|
|
return "", err
|
|
}
|
|
return base64.RawURLEncoding.EncodeToString(buffer), nil
|
|
}
|
|
|
|
func randomSessionToken() (string, error) {
|
|
return randomURLToken(32)
|
|
}
|
|
|
|
func randomCSRFToken() (string, error) {
|
|
return randomURLToken(32)
|
|
}
|
|
|
|
func sessionTokenHash(token string) string {
|
|
sum := sha256.Sum256([]byte(token))
|
|
return hex.EncodeToString(sum[:])
|
|
}
|
|
|
|
func setSessionCookie(writer http.ResponseWriter, token string, expiresAt time.Time, secure bool) {
|
|
http.SetCookie(writer, &http.Cookie{
|
|
Name: sessionCookieName,
|
|
Value: token,
|
|
Path: "/",
|
|
Expires: expiresAt,
|
|
HttpOnly: true,
|
|
Secure: secure,
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
}
|
|
|
|
func setCSRFCookie(writer http.ResponseWriter, token string, expiresAt time.Time, secure bool) {
|
|
http.SetCookie(writer, &http.Cookie{
|
|
Name: csrfCookieName,
|
|
Value: token,
|
|
Path: "/",
|
|
Expires: expiresAt,
|
|
Secure: secure,
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
}
|
|
|
|
func clearSessionCookie(writer http.ResponseWriter, secure bool) {
|
|
http.SetCookie(writer, &http.Cookie{
|
|
Name: sessionCookieName,
|
|
Value: "",
|
|
Path: "/",
|
|
MaxAge: -1,
|
|
Expires: time.Unix(0, 0),
|
|
HttpOnly: true,
|
|
Secure: secure,
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
http.SetCookie(writer, &http.Cookie{
|
|
Name: csrfCookieName,
|
|
Value: "",
|
|
Path: "/",
|
|
MaxAge: -1,
|
|
Expires: time.Unix(0, 0),
|
|
Secure: secure,
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
}
|
|
|
|
func isExternalBusinessWriteEndpoint(path string) bool {
|
|
return path == "/api/external/business-db/documents" ||
|
|
strings.HasPrefix(path, "/api/external/business-db/documents/") ||
|
|
path == "/api/external/business-db/upserts"
|
|
}
|
|
|
|
func isWorkerAPIHealthEndpoint(request *http.Request) bool {
|
|
return request.Method == http.MethodGet && (request.URL.Path == "/worker-api/health" || request.URL.Path == "/worker-api/ready")
|
|
}
|
|
|
|
func isSessionPublicEndpoint(request *http.Request) bool {
|
|
path := request.URL.Path
|
|
return path == "/api/health" ||
|
|
path == "/api/ready" ||
|
|
path == "/api/public/settings" ||
|
|
isWorkerAPIHealthEndpoint(request) ||
|
|
isExternalBusinessWriteEndpoint(path) ||
|
|
strings.HasPrefix(path, "/api/external/object-sync/") ||
|
|
strings.HasPrefix(path, "/api/auth/")
|
|
}
|
|
|
|
func isPocAcceptanceImportEndpoint(request *http.Request) bool {
|
|
return request.Method == http.MethodPost && request.URL.Path == "/api/acceptance/poc-operator-result"
|
|
}
|
|
|
|
func isPocGPUWorkflowAcceptanceEndpoint(request *http.Request) bool {
|
|
return request.Method == http.MethodPost && request.URL.Path == "/api/acceptance/poc-gpu-workflow"
|
|
}
|
|
|
|
func isPocOperatorWorkflowAcceptanceEndpoint(request *http.Request) bool {
|
|
return request.Method == http.MethodPost && request.URL.Path == "/api/acceptance/poc-operator-workflows"
|
|
}
|
|
|
|
func isPocAcceptanceReadinessEndpoint(request *http.Request) bool {
|
|
return request.Method == http.MethodGet && strings.TrimSuffix(request.URL.Path, "/") == "/api/acceptance/poc-readiness"
|
|
}
|
|
|
|
func isOperatorImageArchiveImportEndpoint(request *http.Request) bool {
|
|
return request.Method == http.MethodPost && request.URL.Path == "/api/operators/image-archives/import"
|
|
}
|
|
|
|
func isAPITokenSessionBypassEndpoint(request *http.Request) bool {
|
|
return isPocAcceptanceImportEndpoint(request) || isPocGPUWorkflowAcceptanceEndpoint(request) || isPocOperatorWorkflowAcceptanceEndpoint(request) || isPocAcceptanceReadinessEndpoint(request) || isOperatorImageArchiveImportEndpoint(request)
|
|
}
|
|
|
|
func isAPITokenRunReadEndpoint(request *http.Request) bool {
|
|
switch request.Method {
|
|
case http.MethodGet, http.MethodHead:
|
|
default:
|
|
return false
|
|
}
|
|
path := strings.TrimSuffix(request.URL.Path, "/")
|
|
if path == "/api/runs" {
|
|
return true
|
|
}
|
|
if strings.HasPrefix(path, "/api/runs/") {
|
|
parts := strings.Split(strings.TrimPrefix(path, "/api/runs/"), "/")
|
|
if len(parts) == 1 && strings.TrimSpace(parts[0]) != "" {
|
|
return true
|
|
}
|
|
if len(parts) == 2 && strings.TrimSpace(parts[0]) != "" {
|
|
switch parts[1] {
|
|
case "logs", "resources", "artifacts", "lineage":
|
|
return true
|
|
}
|
|
}
|
|
if len(parts) == 4 && strings.TrimSpace(parts[0]) != "" && strings.TrimSpace(parts[2]) != "" &&
|
|
parts[1] == "artifacts" && parts[3] == "content" {
|
|
return true
|
|
}
|
|
if len(parts) == 4 && strings.TrimSpace(parts[0]) != "" && strings.TrimSpace(parts[2]) != "" &&
|
|
parts[1] == "artifacts" && parts[3] == "members" {
|
|
return true
|
|
}
|
|
if len(parts) == 6 && strings.TrimSpace(parts[0]) != "" && strings.TrimSpace(parts[2]) != "" && strings.TrimSpace(parts[4]) != "" &&
|
|
parts[1] == "artifacts" && parts[3] == "members" && parts[5] == "content" {
|
|
return true
|
|
}
|
|
}
|
|
if strings.HasPrefix(path, "/api/artifacts/") {
|
|
parts := strings.Split(strings.TrimPrefix(path, "/api/artifacts/"), "/")
|
|
return len(parts) == 2 && strings.TrimSpace(parts[0]) != "" && parts[1] == "lineage"
|
|
}
|
|
if strings.HasPrefix(path, "/api/workflows/") {
|
|
parts := strings.Split(strings.TrimPrefix(path, "/api/workflows/"), "/")
|
|
return len(parts) == 2 && strings.TrimSpace(parts[0]) != "" && parts[1] == "runs"
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isAPITokenSessionBypassAllowed(request *http.Request) bool {
|
|
if !apiTokenAuthenticated(request) {
|
|
return false
|
|
}
|
|
return isAPITokenSessionBypassEndpoint(request) || isAPITokenRunReadEndpoint(request)
|
|
}
|
|
|
|
func isCSRFExemptEndpoint(request *http.Request) bool {
|
|
if request.URL.Path == "/api/auth/logout" {
|
|
return false
|
|
}
|
|
return isSessionPublicEndpoint(request)
|
|
}
|
|
|
|
func currentPrincipal(request *http.Request) (*authenticatedPrincipal, bool) {
|
|
value, ok := request.Context().Value(authContextKey{}).(*authenticatedPrincipal)
|
|
return value, ok && value != nil
|
|
}
|
|
|
|
func isCSRFProtectedMethod(method string) bool {
|
|
switch method {
|
|
case http.MethodGet, http.MethodHead, http.MethodOptions:
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
func (server *server) csrfProtection(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
if !isCSRFProtectedMethod(request.Method) || isCSRFExemptEndpoint(request) {
|
|
next.ServeHTTP(writer, request)
|
|
return
|
|
}
|
|
if _, ok := currentPrincipal(request); !ok {
|
|
next.ServeHTTP(writer, request)
|
|
return
|
|
}
|
|
cookie, err := request.Cookie(csrfCookieName)
|
|
if err != nil || strings.TrimSpace(cookie.Value) == "" {
|
|
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "CSRF token is required"})
|
|
return
|
|
}
|
|
headerToken := strings.TrimSpace(request.Header.Get(csrfHeaderName))
|
|
if !constantTimeEqual(cookie.Value, headerToken) {
|
|
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "invalid CSRF token"})
|
|
return
|
|
}
|
|
next.ServeHTTP(writer, request)
|
|
})
|
|
}
|
|
|
|
func (server *server) authenticateRequest(request *http.Request) (*authenticatedPrincipal, error) {
|
|
cookie, err := request.Cookie(sessionCookieName)
|
|
if err != nil || strings.TrimSpace(cookie.Value) == "" {
|
|
return nil, nil
|
|
}
|
|
session, err := server.store.GetSessionByTokenHash(request.Context(), sessionTokenHash(cookie.Value))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if session == nil {
|
|
return nil, nil
|
|
}
|
|
expiresAt, err := time.Parse(time.RFC3339, session.ExpiresAt)
|
|
if err != nil || time.Now().After(expiresAt) {
|
|
_, _ = server.store.DeleteSession(request.Context(), session.ID)
|
|
return nil, nil
|
|
}
|
|
user, err := server.store.GetUser(request.Context(), session.UserID)
|
|
if err != nil || user == nil {
|
|
return nil, err
|
|
}
|
|
if user.Status == domain.UserStatusDisabled {
|
|
return nil, nil
|
|
}
|
|
organizationID := user.OrganizationID
|
|
if organizationID == "" {
|
|
organizationID = domain.DefaultOrganizationID
|
|
}
|
|
organization, err := server.store.GetOrganization(request.Context(), organizationID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if organization == nil {
|
|
organization, err = server.store.EnsureDefaultOrganization(request.Context())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if organization.Status == domain.OrganizationStatusDisabled {
|
|
return nil, nil
|
|
}
|
|
return &authenticatedPrincipal{User: *user, Organization: *organization}, nil
|
|
}
|
|
|
|
func (server *server) publicPreviewPrincipal(ctx context.Context) (*authenticatedPrincipal, error) {
|
|
users, err := server.store.ListUsers(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, allowSuperAdmin := range []bool{false, true} {
|
|
for _, user := range users {
|
|
if user.Status == domain.UserStatusDisabled {
|
|
continue
|
|
}
|
|
if user.IsSuperAdmin && !allowSuperAdmin {
|
|
continue
|
|
}
|
|
organizationID := normalizedTenantID(user.OrganizationID)
|
|
organization, err := server.store.GetOrganization(ctx, organizationID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if organization == nil && organizationID == domain.DefaultOrganizationID {
|
|
organization, err = server.store.EnsureDefaultOrganization(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if organization == nil || organization.Status == domain.OrganizationStatusDisabled {
|
|
continue
|
|
}
|
|
return &authenticatedPrincipal{User: user, Organization: *organization}, nil
|
|
}
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func (server *server) sessionAuth(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
principal, ok := currentPrincipal(request)
|
|
if !ok {
|
|
var err error
|
|
principal, err = server.authenticateRequest(request)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if principal != nil {
|
|
request = request.WithContext(context.WithValue(request.Context(), authContextKey{}, principal))
|
|
}
|
|
}
|
|
if !server.requireSessionAuth || isSessionPublicEndpoint(request) || isAPITokenSessionBypassAllowed(request) {
|
|
next.ServeHTTP(writer, request)
|
|
return
|
|
}
|
|
if principal == nil {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
|
|
return
|
|
}
|
|
if principal.User.IsSuperAdmin && !strings.HasPrefix(request.URL.Path, "/api/admin/") {
|
|
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "super admin cannot access organization business APIs"})
|
|
return
|
|
}
|
|
next.ServeHTTP(writer, request)
|
|
})
|
|
}
|
|
|
|
func (server *server) requireSuperAdmin(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
|
|
principal, err := server.authenticateRequest(request)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if principal == nil || !principal.User.IsSuperAdmin {
|
|
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "super admin is required"})
|
|
return
|
|
}
|
|
next.ServeHTTP(writer, request.WithContext(context.WithValue(request.Context(), authContextKey{}, principal)))
|
|
})
|
|
}
|
|
|
|
func (server *server) superAdminExists(ctx context.Context) (bool, error) {
|
|
users, err := server.store.ListUsers(ctx)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
for _, user := range users {
|
|
if user.IsSuperAdmin {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
func (server *server) handleAuthBootstrapStatus(writer http.ResponseWriter, request *http.Request) {
|
|
exists, err := server.superAdminExists(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]bool{"bootstrapRequired": !exists})
|
|
}
|
|
|
|
type authCredentialsRequest struct {
|
|
Name string `json:"name"`
|
|
Email string `json:"email"`
|
|
Password string `json:"password"`
|
|
}
|
|
|
|
func (server *server) handleAuthBootstrapSuperAdmin(writer http.ResponseWriter, request *http.Request) {
|
|
if !server.authLimiter.allow(server.clientRateLimitKey(request, "bootstrap")) {
|
|
renderJSON(writer, http.StatusTooManyRequests, map[string]string{"error": "too many authentication attempts"})
|
|
return
|
|
}
|
|
var payload authCredentialsRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
payload.Name = strings.TrimSpace(payload.Name)
|
|
payload.Email = strings.TrimSpace(strings.ToLower(payload.Email))
|
|
if payload.Name == "" || strings.TrimSpace(payload.Password) == "" {
|
|
renderValidationError(writer, validationIssue{Field: "name", Message: "name and password are required"})
|
|
return
|
|
}
|
|
if _, err := mail.ParseAddress(payload.Email); err != nil {
|
|
renderValidationError(writer, validationIssue{Field: "email", Message: "email must be valid"})
|
|
return
|
|
}
|
|
if issue, err := server.validateUserEmailAvailable(request.Context(), payload.Email, ""); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
} else if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
exists, err := server.superAdminExists(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if exists {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "super admin already exists"})
|
|
return
|
|
}
|
|
organization, err := server.store.EnsureDefaultOrganization(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
passwordHash, err := hashPassword(payload.Password)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
user, err := server.store.CreateUser(request.Context(), domain.CreateUserInput{
|
|
OrganizationID: organization.ID,
|
|
Name: payload.Name,
|
|
Email: payload.Email,
|
|
Role: domain.UserRoleAdmin,
|
|
PasswordHash: passwordHash,
|
|
IsSuperAdmin: true,
|
|
Status: domain.UserStatusActive,
|
|
})
|
|
if err != nil {
|
|
renderUserMutationError(writer, err)
|
|
return
|
|
}
|
|
if err := server.createSessionCookie(request.Context(), writer, user, organization); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, map[string]any{"user": sanitizeUser(user), "organization": organization})
|
|
}
|
|
|
|
func (server *server) createSessionCookie(ctx context.Context, writer http.ResponseWriter, user *domain.UserRecord, organization *domain.OrganizationRecord) error {
|
|
if user == nil || organization == nil {
|
|
return nil
|
|
}
|
|
token, err := randomSessionToken()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
expiresAt := now.Add(sessionTTL)
|
|
if _, err := server.store.CreateSession(ctx, domain.SessionRecord{
|
|
UserID: user.ID,
|
|
OrganizationID: organization.ID,
|
|
TokenHash: sessionTokenHash(token),
|
|
ExpiresAt: expiresAt.Format(time.RFC3339),
|
|
ExpiresAtTime: expiresAt,
|
|
CreatedAt: now.Format(time.RFC3339),
|
|
LastSeenAt: now.Format(time.RFC3339),
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
csrfToken, err := randomCSRFToken()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
setSessionCookie(writer, token, expiresAt, server.sessionCookieSecure)
|
|
setCSRFCookie(writer, csrfToken, expiresAt, server.sessionCookieSecure)
|
|
return nil
|
|
}
|
|
|
|
func (server *server) handleAuthLogin(writer http.ResponseWriter, request *http.Request) {
|
|
if !server.authLimiter.allow(server.clientRateLimitKey(request, "login")) {
|
|
renderJSON(writer, http.StatusTooManyRequests, map[string]string{"error": "too many authentication attempts"})
|
|
return
|
|
}
|
|
var payload authCredentialsRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
user, err := server.store.FindUserByEmail(request.Context(), payload.Email)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if user == nil || user.PasswordHash == "" || !verifyPassword(payload.Password, user.PasswordHash) || user.Status == domain.UserStatusDisabled {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "invalid email or password"})
|
|
return
|
|
}
|
|
organizationID := user.OrganizationID
|
|
if organizationID == "" {
|
|
organizationID = domain.DefaultOrganizationID
|
|
}
|
|
organization, err := server.store.GetOrganization(request.Context(), organizationID)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if organization == nil {
|
|
organization, err = server.store.EnsureDefaultOrganization(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
}
|
|
if organization.Status == domain.OrganizationStatusDisabled {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "invalid email or password"})
|
|
return
|
|
}
|
|
if err := server.createSessionCookie(request.Context(), writer, user, organization); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"user": sanitizeUser(user), "organization": organization})
|
|
}
|
|
|
|
func (server *server) handleAuthLogout(writer http.ResponseWriter, request *http.Request) {
|
|
if cookie, err := request.Cookie(sessionCookieName); err == nil {
|
|
if session, err := server.store.GetSessionByTokenHash(request.Context(), sessionTokenHash(cookie.Value)); err == nil && session != nil {
|
|
_, _ = server.store.DeleteSession(request.Context(), session.ID)
|
|
}
|
|
}
|
|
clearSessionCookie(writer, server.sessionCookieSecure)
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (server *server) handleAuthMe(writer http.ResponseWriter, request *http.Request) {
|
|
principal, err := server.authenticateRequest(request)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if principal == nil && !server.requireSessionAuth {
|
|
principal, err = server.publicPreviewPrincipal(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
}
|
|
if principal == nil {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"user": sanitizeUser(&principal.User), "organization": principal.Organization})
|
|
}
|
|
|
|
type currentUserProfilePatch struct {
|
|
Name *string `json:"name"`
|
|
Email *string `json:"email"`
|
|
}
|
|
|
|
func (server *server) handleCurrentUserProfileUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
principal, ok := currentPrincipal(request)
|
|
if !ok || principal == nil {
|
|
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
|
|
return
|
|
}
|
|
item, err := server.store.GetUser(request.Context(), principal.User.ID)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if item == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "User not found"})
|
|
return
|
|
}
|
|
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "User") {
|
|
return
|
|
}
|
|
var payload currentUserProfilePatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Name != nil {
|
|
item.Name = strings.TrimSpace(*payload.Name)
|
|
if item.Name == "" {
|
|
renderValidationError(writer, validationIssue{Field: "name", Message: "name is required"})
|
|
return
|
|
}
|
|
}
|
|
if payload.Email != nil {
|
|
normalizedEmail := strings.TrimSpace(strings.ToLower(*payload.Email))
|
|
if _, err := mail.ParseAddress(normalizedEmail); err != nil {
|
|
renderValidationError(writer, validationIssue{Field: "email", Message: "email must be valid"})
|
|
return
|
|
}
|
|
if issue, err := server.validateUserEmailAvailable(request.Context(), normalizedEmail, item.ID); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
} else if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
item.Email = normalizedEmail
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertUser(request.Context(), *item); err != nil {
|
|
renderUserMutationError(writer, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, sanitizeUser(item))
|
|
}
|
|
|
|
type organizationMutationRequest struct {
|
|
Name string `json:"name"`
|
|
Slug string `json:"slug"`
|
|
Status domain.OrganizationStatus `json:"status"`
|
|
}
|
|
|
|
func normalizeOrganizationSlug(value string) string {
|
|
return strings.TrimSpace(strings.ToLower(value))
|
|
}
|
|
|
|
func validateOrganizationSlug(value string) *validationIssue {
|
|
if !organizationSlugPattern.MatchString(value) {
|
|
return &validationIssue{
|
|
Field: "slug",
|
|
Message: "slug must use letters, numbers, and hyphens, start and end with a letter or number, and be at most 63 characters",
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (server *server) validateOrganizationSlugAvailable(ctx context.Context, slug string, currentID string) (*validationIssue, error) {
|
|
items, err := server.store.ListOrganizations(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
normalizedSlug := normalizeOrganizationSlug(slug)
|
|
normalizedCurrentID := strings.TrimSpace(currentID)
|
|
for _, item := range items {
|
|
if normalizeOrganizationSlug(item.Slug) != normalizedSlug {
|
|
continue
|
|
}
|
|
if normalizedCurrentID != "" && strings.TrimSpace(item.ID) == normalizedCurrentID {
|
|
continue
|
|
}
|
|
return &validationIssue{Field: "slug", Message: "slug must be unique"}, nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func (server *server) handleAdminOrganizationsList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListOrganizations(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleAdminOrganizationsCreate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload organizationMutationRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
name := strings.TrimSpace(payload.Name)
|
|
slug := normalizeOrganizationSlug(payload.Slug)
|
|
if name == "" || slug == "" {
|
|
renderValidationError(writer, validationIssue{Field: "name", Message: "name and slug are required"})
|
|
return
|
|
}
|
|
if issue := validateOrganizationSlug(slug); issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
if issue, err := server.validateOrganizationSlugAvailable(request.Context(), slug, ""); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
} else if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
now := nowISO()
|
|
item := domain.OrganizationRecord{
|
|
ID: domain.NewID("org"),
|
|
Name: name,
|
|
Slug: slug,
|
|
Status: payload.Status,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if item.Status == "" {
|
|
item.Status = domain.OrganizationStatusActive
|
|
}
|
|
if item.Status != domain.OrganizationStatusActive && item.Status != domain.OrganizationStatusDisabled {
|
|
renderValidationError(writer, validationIssue{Field: "status", Message: "status must be active or disabled"})
|
|
return
|
|
}
|
|
if err := server.store.UpsertOrganization(request.Context(), item); err != nil {
|
|
renderOrganizationMutationError(writer, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
func (server *server) handleAdminOrganizationsUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetOrganization(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if item == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Organization not found"})
|
|
return
|
|
}
|
|
var payload organizationMutationRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(payload.Name) != "" {
|
|
item.Name = strings.TrimSpace(payload.Name)
|
|
}
|
|
if strings.TrimSpace(payload.Slug) != "" {
|
|
slug := normalizeOrganizationSlug(payload.Slug)
|
|
if issue := validateOrganizationSlug(slug); issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
if issue, err := server.validateOrganizationSlugAvailable(request.Context(), slug, item.ID); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
} else if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
item.Slug = slug
|
|
}
|
|
if payload.Status != "" {
|
|
if payload.Status != domain.OrganizationStatusActive && payload.Status != domain.OrganizationStatusDisabled {
|
|
renderValidationError(writer, validationIssue{Field: "status", Message: "status must be active or disabled"})
|
|
return
|
|
}
|
|
item.Status = payload.Status
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertOrganization(request.Context(), *item); err != nil {
|
|
renderOrganizationMutationError(writer, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleAdminOrganizationsDelete(writer http.ResponseWriter, request *http.Request) {
|
|
deleted, err := server.store.DeleteOrganizationCascade(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusBadRequest, err)
|
|
return
|
|
}
|
|
if !deleted {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (server *server) handleAdminOrganizationUsersList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListUsersByOrganization(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
suppliers, err := server.store.ListSuppliers(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": sanitizeUsers(items), "suppliers": suppliers})
|
|
}
|
|
|
|
type adminUserMutationRequest struct {
|
|
SupplierID string `json:"supplierId"`
|
|
Name string `json:"name"`
|
|
Email string `json:"email"`
|
|
Role domain.UserRole `json:"role"`
|
|
Password string `json:"password,omitempty"`
|
|
Status domain.UserStatus `json:"status,omitempty"`
|
|
}
|
|
|
|
func (server *server) handleAdminOrganizationUsersCreate(writer http.ResponseWriter, request *http.Request) {
|
|
organization, err := server.store.GetOrganization(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if organization == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Organization not found"})
|
|
return
|
|
}
|
|
var payload adminUserMutationRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
name, email := normalizeUserInput(payload.Name, payload.Email)
|
|
if name == "" || strings.TrimSpace(payload.Password) == "" {
|
|
renderValidationError(writer, validationIssue{Field: "name", Message: "name and password are required"})
|
|
return
|
|
}
|
|
if _, err := mail.ParseAddress(email); err != nil {
|
|
renderValidationError(writer, validationIssue{Field: "email", Message: "email must be valid"})
|
|
return
|
|
}
|
|
if issue, err := server.validateUserEmailAvailable(request.Context(), email, ""); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
} else if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
if !validUserRole(payload.Role) {
|
|
renderValidationError(writer, validationIssue{Field: "role", Message: "role must be admin, annotator, quality_reviewer, acceptance_reviewer, or supplier_manager"})
|
|
return
|
|
}
|
|
passwordHash, err := hashPassword(payload.Password)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if payload.Status != "" && !validUserStatus(payload.Status) {
|
|
renderValidationError(writer, validationIssue{Field: "status", Message: "status must be active or disabled"})
|
|
return
|
|
}
|
|
if issue, err := server.validateUserSupplier(request.Context(), organization.ID, payload.SupplierID); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
} else if issue != nil {
|
|
renderValidationError(writer, *issue)
|
|
return
|
|
}
|
|
user, err := server.store.CreateUser(request.Context(), domain.CreateUserInput{
|
|
SupplierID: strings.TrimSpace(payload.SupplierID),
|
|
OrganizationID: organization.ID,
|
|
Name: name,
|
|
Email: email,
|
|
Role: payload.Role,
|
|
PasswordHash: passwordHash,
|
|
Status: payload.Status,
|
|
})
|
|
if err != nil {
|
|
renderUserMutationError(writer, err)
|
|
return
|
|
}
|
|
if err := server.store.SyncDefaultSupplierProjectMembers(request.Context(), user.OrganizationID, "", user.ID); err != nil {
|
|
renderJSON(writer, http.StatusInternalServerError, map[string]string{"error": "账号已创建,自动加入项目失败,请刷新账号后重试", "userId": user.ID})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, sanitizeUser(user))
|
|
}
|
|
|
|
func (server *server) handleAdminUserUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
server.handleUsersUpdate(writer, request)
|
|
}
|
|
|
|
func (server *server) handleAdminUserDelete(writer http.ResponseWriter, request *http.Request) {
|
|
server.handleUsersDelete(writer, request)
|
|
}
|
|
|
|
func (server *server) handleAdminUserResetPassword(writer http.ResponseWriter, request *http.Request) {
|
|
var payload struct {
|
|
Password string `json:"password"`
|
|
}
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(payload.Password) == "" {
|
|
renderValidationError(writer, validationIssue{Field: "password", Message: "password is required"})
|
|
return
|
|
}
|
|
user, err := server.store.GetUser(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if user == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "User not found"})
|
|
return
|
|
}
|
|
passwordHash, err := hashPassword(payload.Password)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
user.PasswordHash = passwordHash
|
|
user.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertUser(request.Context(), *user); err != nil {
|
|
renderUserMutationError(writer, err)
|
|
return
|
|
}
|
|
_ = server.store.DeleteSessionsByUser(request.Context(), user.ID)
|
|
renderJSON(writer, http.StatusOK, sanitizeUser(user))
|
|
}
|