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