2026-10-08 00:21:55 -07:00

566 lines
21 KiB
Go

package api
import (
"context"
"net/http"
"strings"
"droboticflow/internal/domain"
)
func normalizedTenantID(value string) string {
trimmed := strings.TrimSpace(value)
if trimmed == "" {
return domain.DefaultOrganizationID
}
return trimmed
}
func tenantMatches(recordOrganizationID string, targetOrganizationID string) bool {
record := normalizedTenantID(recordOrganizationID)
target := normalizedTenantID(targetOrganizationID)
if target == domain.DefaultOrganizationID {
return record == domain.DefaultOrganizationID
}
return record == target
}
func (server *server) tenantEnforced(request *http.Request) bool {
if server.requireSessionAuth {
return true
}
_, ok := currentPrincipal(request)
return ok
}
func currentPrincipalFromContext(ctx context.Context) (*authenticatedPrincipal, bool) {
value, ok := ctx.Value(authContextKey{}).(*authenticatedPrincipal)
return value, ok && value != nil
}
func (server *server) tenantEnforcedContext(ctx context.Context) bool {
_, ok := currentPrincipalFromContext(ctx)
return ok
}
func (server *server) requestOrganizationID(request *http.Request) string {
if principal, ok := currentPrincipal(request); ok && principal.Organization.ID != "" {
return principal.Organization.ID
}
return domain.DefaultOrganizationID
}
func (server *server) contextOrganizationID(ctx context.Context) string {
if principal, ok := currentPrincipalFromContext(ctx); ok && principal.Organization.ID != "" {
return principal.Organization.ID
}
return domain.DefaultOrganizationID
}
func (server *server) ensureTenantAccess(writer http.ResponseWriter, request *http.Request, recordOrganizationID string, label string) bool {
if strings.HasPrefix(request.URL.Path, "/api/admin/") {
return true
}
if !server.tenantEnforced(request) {
return true
}
if tenantMatches(recordOrganizationID, server.requestOrganizationID(request)) {
return true
}
if strings.TrimSpace(label) == "" {
label = "Resource"
}
renderJSON(writer, http.StatusNotFound, map[string]string{"error": label + " not found"})
return false
}
func (server *server) assignTenant(request *http.Request, organizationID *string) {
if organizationID == nil {
return
}
if server.tenantEnforced(request) || strings.TrimSpace(*organizationID) == "" {
*organizationID = server.requestOrganizationID(request)
}
}
func (server *server) filterByTenant(request *http.Request, organizationID string) bool {
if !server.tenantEnforced(request) {
return true
}
return tenantMatches(organizationID, server.requestOrganizationID(request))
}
func (server *server) filterByTenantContext(ctx context.Context, organizationID string) bool {
if !server.tenantEnforcedContext(ctx) {
return true
}
return tenantMatches(organizationID, server.contextOrganizationID(ctx))
}
func filterTenantRecords[T any](items []T, include func(T) bool) []T {
if len(items) == 0 {
return items
}
filtered := make([]T, 0, len(items))
for _, item := range items {
if include(item) {
filtered = append(filtered, item)
}
}
return filtered
}
func (server *server) listProjectsForRequest(ctx context.Context, request *http.Request) ([]domain.ProjectRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListProjectsByOrganization(ctx, server.requestOrganizationID(request))
}
return server.store.ListProjects(ctx)
}
func (server *server) listOperatorsForRequest(ctx context.Context, request *http.Request) ([]domain.OperatorRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListOperatorsByOrganization(ctx, server.requestOrganizationID(request))
}
return server.store.ListOperators(ctx)
}
func (server *server) listOperatorsForContext(ctx context.Context) ([]domain.OperatorRecord, error) {
if server.tenantEnforcedContext(ctx) {
return server.store.ListOperatorsByOrganization(ctx, server.contextOrganizationID(ctx))
}
return server.store.ListOperators(ctx)
}
func (server *server) listAllWorkflowsForRequest(ctx context.Context, request *http.Request) ([]domain.WorkflowRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListAllWorkflowsByOrganization(ctx, server.requestOrganizationID(request))
}
return server.store.ListAllWorkflows(ctx)
}
func (server *server) listAllWorkflowsForContext(ctx context.Context) ([]domain.WorkflowRecord, error) {
if server.tenantEnforcedContext(ctx) {
return server.store.ListAllWorkflowsByOrganization(ctx, server.contextOrganizationID(ctx))
}
return server.store.ListAllWorkflows(ctx)
}
func (server *server) listTemplatesForRequest(ctx context.Context, request *http.Request) ([]domain.TemplateRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListTemplatesByOrganization(ctx, server.requestOrganizationID(request))
}
return server.store.ListTemplates(ctx)
}
func (server *server) listRunsForRequest(ctx context.Context, request *http.Request, status string) ([]domain.RunRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListRunsByOrganization(ctx, server.requestOrganizationID(request), status)
}
return server.store.ListRuns(ctx, status)
}
func (server *server) listRunsForContext(ctx context.Context, status string) ([]domain.RunRecord, error) {
if server.tenantEnforcedContext(ctx) {
return server.store.ListRunsByOrganization(ctx, server.contextOrganizationID(ctx), status)
}
return server.store.ListRuns(ctx, status)
}
func (server *server) listRunArtifactsForRequest(ctx context.Context, request *http.Request, status string) ([]domain.RunRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListRunArtifactsByOrganization(ctx, server.requestOrganizationID(request), status)
}
return server.store.ListRunArtifacts(ctx, status)
}
func (server *server) listRunArtifactsForContext(ctx context.Context, status string) ([]domain.RunRecord, error) {
if server.tenantEnforcedContext(ctx) {
return server.store.ListRunArtifactsByOrganization(ctx, server.contextOrganizationID(ctx), status)
}
return server.store.ListRunArtifacts(ctx, status)
}
func (server *server) listRunSummariesForRequest(ctx context.Context, request *http.Request, status string) ([]domain.RunSummary, error) {
if server.tenantEnforced(request) {
return server.store.ListRunSummariesByOrganization(ctx, server.requestOrganizationID(request), status)
}
return server.store.ListRunSummaries(ctx, status)
}
func (server *server) listRunSummaryPageForRequest(ctx context.Context, request *http.Request, query domain.RunSummaryQuery) (domain.RunSummaryPage, error) {
if server.tenantEnforced(request) {
return server.store.ListRunSummariesPageByOrganization(ctx, server.requestOrganizationID(request), query)
}
return server.store.ListRunSummariesPage(ctx, query)
}
func (server *server) listAuditTasksForRequest(ctx context.Context, request *http.Request, status string) ([]domain.AuditTaskRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListAuditTasksByOrganization(ctx, server.requestOrganizationID(request), status)
}
return server.store.ListAuditTasks(ctx, status)
}
func (server *server) listSamplingTasksForRequest(ctx context.Context, request *http.Request, status string) ([]domain.SamplingTaskRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListSamplingTasksByOrganization(ctx, server.requestOrganizationID(request), status)
}
return server.store.ListSamplingTasks(ctx, status)
}
func (server *server) listSamplingTasksForContext(ctx context.Context, status string) ([]domain.SamplingTaskRecord, error) {
if server.tenantEnforcedContext(ctx) {
return server.store.ListSamplingTasksByOrganization(ctx, server.contextOrganizationID(ctx), status)
}
return server.store.ListSamplingTasks(ctx, status)
}
func (server *server) listStorageConnectionsForRequest(ctx context.Context, request *http.Request) ([]domain.StorageConnectionRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListStorageConnectionsByOrganization(ctx, server.requestOrganizationID(request))
}
return server.store.ListStorageConnections(ctx)
}
func (server *server) listMongoConnectionsForRequest(ctx context.Context, request *http.Request) ([]domain.MongoConnectionRecord, error) {
if server.tenantEnforced(request) {
return server.store.ListMongoConnectionsByOrganization(ctx, server.requestOrganizationID(request))
}
return server.store.ListMongoConnections(ctx)
}
func (server *server) filterProjectsForRequest(request *http.Request, items []domain.ProjectRecord) []domain.ProjectRecord {
return filterTenantRecords(items, func(item domain.ProjectRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && (server.projectVisibleToRequest(request, item.OrganizationID, item.ID) || server.acceptanceProjectVisible(request, item.OrganizationID, item.ID))
})
}
func (server *server) projectVisibleToRequest(request *http.Request, organizationID string, projectID string) bool {
if !server.tenantEnforced(request) {
return true
}
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
// Organization-scoped API tokens do not carry a human project role.
return true
}
switch principal.User.Role {
case domain.UserRoleAdmin:
return true
case domain.UserRoleSupplierManager:
// The grant below is supplier-wide, including future employees.
case domain.UserRoleAnnotator, domain.UserRoleQualityReviewer, domain.UserRoleAcceptanceReviewer:
// Production duties remain controlled by the account role.
default:
return false
}
if principal.User.Status == domain.UserStatusDisabled || strings.TrimSpace(principal.User.SupplierID) == "" {
return false
}
supplier, err := server.store.GetSupplier(request.Context(), principal.User.SupplierID)
if err != nil {
return false
}
supplierActive := supplier != nil && tenantMatches(supplier.OrganizationID, organizationID) && strings.EqualFold(supplier.Status, "active")
grants, err := server.store.ListSupplierProjectAuthorizations(request.Context(), organizationID, projectID)
if err != nil {
return false
}
revokedSupplierGrant := false
for _, grant := range grants {
if grant.SupplierID != principal.User.SupplierID {
continue
}
if !supplierActive {
return false
}
if grant.Status == "active" {
return true
}
if len(grant.DrainTaskIDs) != 0 {
open, err := server.store.HasOpenSupplierDrainTask(request.Context(), organizationID, projectID, grant.SupplierID, grant.DrainTaskIDs)
if err != nil || open {
return err == nil && open
}
}
// A revoked public-pool grant must not revive public-pool access,
// but it also must not hide an independent legacy workflow for the
// same project. That distinction is resolved after membership checks.
revokedSupplierGrant = true
break
}
memberships, err := server.store.ListProjectMembers(request.Context(), organizationID, projectID)
if err != nil {
return false
}
// A production account gains project access only through explicit membership,
// including projects that currently have no members.
memberOfProject := false
for _, membership := range memberships {
if principal.User.Role == domain.UserRoleSupplierManager && strings.TrimSpace(membership.SupplierID) == strings.TrimSpace(principal.User.SupplierID) {
memberOfProject = true
break
}
if membership.UserID == principal.User.ID {
memberOfProject = true
break
}
}
if !memberOfProject {
return false
}
if !revokedSupplierGrant {
return true
}
legacyWorkflow, err := server.projectHasIndependentWorkflow(request.Context(), organizationID, projectID)
return err == nil && legacyWorkflow
}
// projectHasIndependentWorkflow keeps project-level navigation available for
// explicit members when a public Fanyu grant is revoked. Task-level access
// still enforces the public-pool grant, so this cannot reopen those tasks.
func (server *server) projectHasIndependentWorkflow(ctx context.Context, organizationID, projectID string) (bool, error) {
instances, err := server.store.ListProjectWorkflowInstances(ctx, organizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: projectID, Status: domain.ProjectWorkflowInstanceActive})
if err != nil {
return false, err
}
for _, instance := range instances {
release, err := server.store.GetWorkflowRelease(ctx, instance.ReleaseID)
if err != nil {
return false, err
}
// A missing release is a legacy instance; preserve its existing
// member-scoped visibility rather than hiding the project.
if release == nil {
return true, nil
}
publicPool, err := server.releaseUsesFanyuSupplierPool(ctx, *release)
if err != nil {
return false, err
}
if !publicPool {
return true, nil
}
}
return false, nil
}
func (server *server) ensureProjectVisibility(writer http.ResponseWriter, request *http.Request, organizationID string, projectID string) bool {
if server.projectVisibleToRequest(request, organizationID, projectID) {
return true
}
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "project membership is required", "code": "project_access_required"})
return false
}
func (server *server) filterOperatorsForRequest(request *http.Request, items []domain.OperatorRecord) []domain.OperatorRecord {
return filterTenantRecords(items, func(item domain.OperatorRecord) bool {
return server.operatorVisibleToRequest(request, item)
})
}
func isBuiltinOperatorRecord(item domain.OperatorRecord) bool {
return strings.EqualFold(strings.TrimSpace(item.Type), "builtin")
}
func (server *server) operatorVisibleToRequest(request *http.Request, item domain.OperatorRecord) bool {
if isBuiltinOperatorRecord(item) {
return true
}
return server.filterByTenant(request, item.OrganizationID)
}
func (server *server) ensureOperatorAccess(writer http.ResponseWriter, request *http.Request, item domain.OperatorRecord) bool {
if isBuiltinOperatorRecord(item) {
return true
}
return server.ensureTenantAccess(writer, request, item.OrganizationID, "Operator")
}
func (server *server) filterWorkflowsForRequest(request *http.Request, items []domain.WorkflowRecord) []domain.WorkflowRecord {
return filterTenantRecords(items, func(item domain.WorkflowRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && (server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID) || server.acceptanceProjectVisible(request, item.OrganizationID, item.ProjectID))
})
}
func (server *server) filterTemplatesForRequest(request *http.Request, items []domain.TemplateRecord) []domain.TemplateRecord {
return filterTenantRecords(items, func(item domain.TemplateRecord) bool {
return server.filterByTenant(request, item.OrganizationID)
})
}
func (server *server) filterRunsForRequest(request *http.Request, items []domain.RunRecord) []domain.RunRecord {
return filterTenantRecords(items, func(item domain.RunRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID)
})
}
func (server *server) filterRunSummariesForRequest(request *http.Request, items []domain.RunSummary) []domain.RunSummary {
return filterTenantRecords(items, func(item domain.RunSummary) bool {
return server.filterByTenant(request, item.OrganizationID) && server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID)
})
}
func (server *server) filterAuditTasksForRequest(request *http.Request, items []domain.AuditTaskRecord) []domain.AuditTaskRecord {
return filterTenantRecords(items, func(item domain.AuditTaskRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID)
})
}
func (server *server) filterSamplingTasksForRequest(request *http.Request, items []domain.SamplingTaskRecord) []domain.SamplingTaskRecord {
return filterTenantRecords(items, func(item domain.SamplingTaskRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID)
})
}
func (server *server) filterUsersForRequest(request *http.Request, items []domain.UserRecord) []domain.UserRecord {
return filterTenantRecords(items, func(item domain.UserRecord) bool {
if item.DeletedAt != "" {
return false
}
if !server.filterByTenant(request, item.OrganizationID) {
return false
}
principal, ok := currentPrincipal(request)
if item.IsSuperAdmin && ok && principal != nil && !principal.User.IsSuperAdmin {
return false
}
if !ok || principal == nil || principal.User.Role != domain.UserRoleSupplierManager {
return true
}
return !item.IsSuperAdmin && isAllowedSupplierEmployeeRole(item.Role) && strings.TrimSpace(principal.User.SupplierID) != "" && strings.TrimSpace(item.SupplierID) == strings.TrimSpace(principal.User.SupplierID)
})
}
func (server *server) filterStorageConnectionsForRequest(request *http.Request, items []domain.StorageConnectionRecord) []domain.StorageConnectionRecord {
return filterTenantRecords(items, func(item domain.StorageConnectionRecord) bool {
return server.filterByTenant(request, item.OrganizationID)
})
}
func (server *server) filterMongoConnectionsForRequest(request *http.Request, items []domain.MongoConnectionRecord) []domain.MongoConnectionRecord {
return filterTenantRecords(items, func(item domain.MongoConnectionRecord) bool {
return server.filterByTenant(request, item.OrganizationID)
})
}
func (server *server) filterExternalBusinessWriteTokensForRequest(request *http.Request, items []domain.ExternalBusinessWriteTokenRecord) []domain.ExternalBusinessWriteTokenRecord {
return filterTenantRecords(items, func(item domain.ExternalBusinessWriteTokenRecord) bool {
return server.filterByTenant(request, item.OrganizationID)
})
}
func (server *server) requireBusinessRole(roles ...domain.UserRole) func(http.Handler) http.Handler {
allowed := map[domain.UserRole]struct{}{}
for _, role := range roles {
allowed[role] = struct{}{}
}
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if !server.requireSessionAuth {
next.ServeHTTP(writer, request)
return
}
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
return
}
_, permitted := allowed[principal.User.Role]
if !permitted {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "insufficient role permissions"})
return
}
next.ServeHTTP(writer, request)
})
}
}
func (server *server) requireAdminMonitoringAccess(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if !server.requireSessionAuth || apiTokenAuthenticated(request) {
next.ServeHTTP(writer, request)
return
}
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
return
}
if principal.User.Role != domain.UserRoleAdmin {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "run monitoring is restricted to administrators"})
return
}
next.ServeHTTP(writer, request)
})
}
func (server *server) requirePocAcceptanceImportAccess(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if !server.requireSessionAuth {
next.ServeHTTP(writer, request)
return
}
if apiTokenAuthenticated(request) {
next.ServeHTTP(writer, request)
return
}
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login or API token is required"})
return
}
if principal.User.Role == domain.UserRoleAdmin {
next.ServeHTTP(writer, request)
} else {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "insufficient role permissions"})
}
})
}
func (server *server) requireWorkerAPIRole(roles ...domain.UserRole) func(http.Handler) http.Handler {
allowed := map[domain.UserRole]struct{}{}
for _, role := range roles {
allowed[role] = struct{}{}
}
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if !server.requireSessionAuth && apiTokenAuthenticated(request) {
next.ServeHTTP(writer, request)
return
}
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "worker API requires an authenticated admin, pipeline engineer, or data operator session"})
return
}
if principal.User.IsSuperAdmin {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "super admin cannot control organization worker APIs"})
return
}
if _, ok := allowed[principal.User.Role]; !ok {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "insufficient role permissions"})
return
}
next.ServeHTTP(writer, request)
})
}
}
func (server *server) ensureSelfOrAdmin(writer http.ResponseWriter, request *http.Request, user domain.UserRecord) bool {
if !server.requireSessionAuth {
return true
}
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
return false
}
if principal.User.Role == domain.UserRoleAdmin || principal.User.ID == user.ID {
return true
}
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "user self or admin permission is required"})
return false
}