566 lines
21 KiB
Go
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
|
|
}
|