2026-08-22 14:12:04 +08:00

902 lines
29 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
}
renderJSON(writer, http.StatusOK, map[string]any{"items": sanitizeUsers(items)})
}
type adminUserMutationRequest struct {
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
}
user, err := server.store.CreateUser(request.Context(), domain.CreateUserInput{
OrganizationID: organization.ID,
Name: name,
Email: email,
Role: payload.Role,
PasswordHash: passwordHash,
Status: payload.Status,
})
if err != nil {
renderUserMutationError(writer, err)
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))
}