d-robotics da446d13b5 ⚡ Fix slow page loading: static gzip, list pagination, auth cache, dashboard aggregation, video direct link
- C1/S3: build-time precompressed .gz served by spaHandler (writeBundle plugin), motion-vendor chunk rule fix
- C3/S1: /api/runs default cursor pagination (byte-compatible), /api/human-items limit/cursor + Mongo projection + filter pushdown
- C2/S5: in-process principal TTL cache (45s) with full invalidation paths; /api/users limit+q with org isolation
- C4/S2: dashboard counter pushdown ($group/CountDocuments), 45s response/snapshot caches, production stats snapshot cache
- C5: BOS presigned direct-link video preview (307) with background pre-transcode, /tmp cache TTL+LRU, gzip bypass, sync=1 rollback
- S4/S6: POC readiness point queries, human-batches GET no longer writes (60s sweeper), admin ops page N+1 fan-out removed
- Fixes found en route: BSON cursor self-reference recursion, backfill loop cursor advance, supplier cascade session flush
- Frontend: nextCursor passthrough (human-loop/users), acceptance pool no longer truncated at 500

Co-authored-by: AgentTeams slow-page-fix
2026-10-09 17:45:27 -07:00

1122 lines
38 KiB
Go

package api
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"net/http"
"os"
"regexp"
"strings"
"sync"
"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])?$`)
// chinaMobilePhonePattern matches China mainland mobile numbers only: 11
// digits, starting with 1, second digit 3-9. No SMS verification, no
// international numbers, no landlines (see account-phone-login spec decision 3).
var chinaMobilePhonePattern = regexp.MustCompile(`^1[3-9]\d{9}$`)
// isValidChinaMobilePhone reports whether phone matches the required format.
// It backs account create/edit and login — phone is the account identifier.
func isValidChinaMobilePhone(phone string) bool {
return chinaMobilePhonePattern.MatchString(strings.TrimSpace(phone))
}
type authContextKey struct{}
type authenticatedPrincipal struct {
User domain.UserRecord
Organization domain.OrganizationRecord
}
// Legacy tenant maintenance is opt-in for migration/testing only. It is not a
// business role and is closed in normal deployments, including Fanyu.
func legacyOrganizationAdminEnabled() bool {
return strings.EqualFold(strings.TrimSpace(os.Getenv("DROBOTICFLOW_ENABLE_LEGACY_ORGANIZATION_ADMIN")), "true")
}
func legacyOrganizationAdminGone(w http.ResponseWriter) {
renderJSON(w, http.StatusGone, map[string]string{"error": "旧平台管理员和组织管理入口已停用,请使用账号管理", "code": "legacy_organization_admin_retired"})
}
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
}
tokenHash := sessionTokenHash(cookie.Value)
// C2: the auth chain costs 3-5 serial Mongo round trips per request.
// Warm requests are served from the process-local TTL cache; write paths
// that change sessions, passwords, roles, suppliers or organizations call
// the invalidateAuthCache* helpers below.
if principal := lookupCachedPrincipal(tokenHash); principal != nil {
return principal, nil
}
session, err := server.store.GetSessionByTokenHash(request.Context(), tokenHash)
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.DeletedAt != "" || user.Status == domain.UserStatusDisabled || (user.IsSuperAdmin && !legacyOrganizationAdminEnabled()) {
return nil, nil
}
if user.SupplierID != "" {
supplier, e := server.store.GetSupplier(request.Context(), user.SupplierID)
if e != nil {
return nil, e
}
if supplier != nil && (supplier.Status == "deleting" || supplier.Status == "deleted") {
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
}
principal := &authenticatedPrincipal{User: *user, Organization: *organization}
cachePrincipal(tokenHash, principal, session.ExpiresAt)
return principal, nil
}
// principalCacheEntry caches a resolved authenticatedPrincipal keyed by the
// session token hash. Entries carry the owning user so user-wide
// invalidation (role/supplier/org changes) can find every live session.
type principalCacheEntry struct {
principal authenticatedPrincipal
userID string
expiresAt time.Time
}
const (
principalCacheTTL = 45 * time.Second
principalCacheMaxEntries = 4096
)
var (
principalCacheMu sync.Mutex
principalCache = map[string]principalCacheEntry{}
)
// cachePrincipal stores a resolved principal with a TTL capped by the session
// expiry so a stale entry never outlives its session.
func cachePrincipal(tokenHash string, principal *authenticatedPrincipal, sessionExpiresAt string) {
if principal == nil {
return
}
expiresAt := time.Now().Add(principalCacheTTL)
if parsed, err := time.Parse(time.RFC3339, sessionExpiresAt); err == nil && parsed.Before(expiresAt) {
expiresAt = parsed
}
principalCacheMu.Lock()
defer principalCacheMu.Unlock()
if len(principalCache) >= principalCacheMaxEntries {
// Cheap full sweep instead of an LRU: the map is small and bounded.
now := time.Now()
for key, entry := range principalCache {
if now.After(entry.expiresAt) {
delete(principalCache, key)
}
}
if len(principalCache) >= principalCacheMaxEntries {
principalCache = map[string]principalCacheEntry{}
}
}
principalCache[tokenHash] = principalCacheEntry{
principal: authenticatedPrincipal{User: principal.User, Organization: principal.Organization},
userID: principal.User.ID,
expiresAt: expiresAt,
}
}
func lookupCachedPrincipal(tokenHash string) *authenticatedPrincipal {
principalCacheMu.Lock()
entry, ok := principalCache[tokenHash]
principalCacheMu.Unlock()
if !ok || time.Now().After(entry.expiresAt) {
return nil
}
principal := entry.principal
return &principal
}
// invalidateAuthCacheForToken drops a single session's cached principal
// (logout, session deletion).
func invalidateAuthCacheForToken(tokenHash string) {
principalCacheMu.Lock()
delete(principalCache, tokenHash)
principalCacheMu.Unlock()
}
// invalidateAuthCacheForUser drops every cached principal owned by the user
// (password resets, role/supplier/status changes, forced session revocation).
func invalidateAuthCacheForUser(userID string) {
if userID == "" {
return
}
principalCacheMu.Lock()
for key, entry := range principalCache {
if entry.userID == userID {
delete(principalCache, key)
}
}
principalCacheMu.Unlock()
}
// invalidateAuthCache drops all cached principals. Used when an organization
// record itself changes (name/slug/status) because the cached principal embeds
// the organization snapshot.
func invalidateAuthCache() {
principalCacheMu.Lock()
principalCache = map[string]principalCacheEntry{}
principalCacheMu.Unlock()
}
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.DeletedAt != "" || user.Status == domain.UserStatusDisabled {
continue
}
if user.IsSuperAdmin && (!allowSuperAdmin || !legacyOrganizationAdminEnabled()) {
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) {
if !legacyOrganizationAdminEnabled() {
legacyOrganizationAdminGone(writer)
return
}
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) {
if !legacyOrganizationAdminEnabled() {
renderJSON(writer, http.StatusOK, map[string]bool{"bootstrapRequired": false})
return
}
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"`
Phone string `json:"phone"`
Email string `json:"email"`
Password string `json:"password"`
}
func (server *server) handleAuthBootstrapSuperAdmin(writer http.ResponseWriter, request *http.Request) {
if !legacyOrganizationAdminEnabled() {
legacyOrganizationAdminGone(writer)
return
}
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.Phone = strings.TrimSpace(payload.Phone)
if payload.Name == "" || strings.TrimSpace(payload.Password) == "" {
renderValidationError(writer, validationIssue{Field: "name", Message: "name and password are required"})
return
}
if !isValidChinaMobilePhone(payload.Phone) {
renderValidationError(writer, validationIssue{Field: "phone", Message: "手机号格式不正确,应为以 1 开头的 11 位中国大陆手机号"})
return
}
if issue, err := server.validateUserPhoneAvailable(request.Context(), payload.Phone, ""); 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,
Phone: payload.Phone,
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
}
identifier := strings.TrimSpace(payload.Phone)
if identifier == "" {
identifier = strings.TrimSpace(payload.Email)
}
user, err := server.store.FindUserByPhone(request.Context(), identifier)
if err == nil && user == nil && strings.Contains(identifier, "@") {
// Accounts created before the phone-only migration still have their
// email in Mongo and no phone. Keep them login-capable while an admin
// updates the account; phone remains the preferred identifier.
user, err = server.store.FindUserByLegacyEmail(request.Context(), identifier)
}
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if user == nil || user.PasswordHash == "" || !verifyPassword(payload.Password, user.PasswordHash) || (user.DeletedAt != "" || user.Status == domain.UserStatusDisabled || (user.IsSuperAdmin && !legacyOrganizationAdminEnabled())) {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "invalid phone 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 phone 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 {
tokenHash := sessionTokenHash(cookie.Value)
if session, err := server.store.GetSessionByTokenHash(request.Context(), tokenHash); err == nil && session != nil {
_, _ = server.store.DeleteSession(request.Context(), session.ID)
}
// Logout must take effect immediately, not after the TTL.
invalidateAuthCacheForToken(tokenHash)
}
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 {
CurrentPassword string `json:"currentPassword"`
NewPassword *string `json:"newPassword"`
Name *string `json:"name"`
Phone *string `json:"phone"`
}
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
}
expected := *item
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.Phone != nil {
normalizedPhone := strings.TrimSpace(*payload.Phone)
if !isValidChinaMobilePhone(normalizedPhone) {
renderValidationError(writer, validationIssue{Field: "phone", Message: "手机号格式不正确,应为以 1 开头的 11 位中国大陆手机号"})
return
}
if issue, err := server.validateUserPhoneAvailable(request.Context(), normalizedPhone, item.ID); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
} else if issue != nil {
renderValidationError(writer, *issue)
return
}
item.Phone = normalizedPhone
}
if payload.NewPassword != nil {
if !verifyPassword(payload.CurrentPassword, item.PasswordHash) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "当前密码不正确"})
return
}
if strings.TrimSpace(*payload.NewPassword) == "" {
renderValidationError(writer, validationIssue{Field: "newPassword", Message: "新密码不能为空"})
return
}
hash, err := hashPassword(*payload.NewPassword)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
item.PasswordHash = hash
}
item.UpdatedAt = nowISO()
if err := server.store.UpdateUser(request.Context(), *item, expected); err != nil {
renderUserMutationError(writer, err)
return
}
// Profile edits (including self password change) refresh cached principals.
invalidateAuthCacheForUser(item.ID)
if payload.NewPassword != nil {
if err := server.store.DeleteSessionsByUser(request.Context(), item.ID); err != nil {
renderError(writer, http.StatusInternalServerError, 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
}
// Cached principals embed the organization snapshot; any org change
// flushes them so status/name changes apply immediately.
invalidateAuthCache()
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
}
// Org deletion invalidates every cached principal in that org.
invalidateAuthCache()
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"`
Phone string `json:"phone"`
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 := strings.TrimSpace(payload.Name)
phone := strings.TrimSpace(payload.Phone)
if name == "" || strings.TrimSpace(payload.Password) == "" {
renderValidationError(writer, validationIssue{Field: "name", Message: "name and password are required"})
return
}
if !isValidChinaMobilePhone(phone) {
renderValidationError(writer, validationIssue{Field: "phone", Message: "手机号格式不正确,应为以 1 开头的 11 位中国大陆手机号"})
return
}
if issue, err := server.validateUserPhoneAvailable(request.Context(), phone, ""); 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 payload.Role == domain.UserRoleAdmin {
payload.SupplierID = ""
}
if issue, err := server.validateAccountSupplier(request.Context(), organization.ID, payload.SupplierID, payload.Role); 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,
Phone: phone,
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
}
expected := *user
passwordHash, err := hashPassword(payload.Password)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
user.PasswordHash = passwordHash
user.UpdatedAt = nowISO()
if err := server.store.UpdateUser(request.Context(), *user, expected); err != nil {
renderUserMutationError(writer, err)
return
}
if err := server.store.DeleteSessionsByUser(request.Context(), user.ID); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
// The admin-forced password reset must evict any cached principal at once.
invalidateAuthCacheForUser(user.ID)
renderJSON(writer, http.StatusOK, sanitizeUser(user))
}