forked from longtao.wu/droboticflow
1275 lines
42 KiB
Go
1275 lines
42 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/mail"
|
|
"strings"
|
|
"time"
|
|
|
|
"droboticflow/internal/ai"
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
type validationIssue struct {
|
|
Field string `json:"field"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
type server struct {
|
|
store store.Store
|
|
ai ai.Service
|
|
}
|
|
|
|
func maskedSecretPreview(value string) string {
|
|
compact := strings.Join(strings.Fields(strings.TrimSpace(value)), "")
|
|
if compact == "" {
|
|
compact = strings.TrimSpace(value)
|
|
}
|
|
if compact == "" {
|
|
return ""
|
|
}
|
|
|
|
runes := []rune(compact)
|
|
switch length := len(runes); {
|
|
case length <= 2:
|
|
return strings.Repeat("*", length)
|
|
case length <= 6:
|
|
return string(runes[:1]) + "****" + string(runes[length-1:])
|
|
case length <= 10:
|
|
return string(runes[:2]) + "****" + string(runes[length-2:])
|
|
default:
|
|
return string(runes[:4]) + "****" + string(runes[length-4:])
|
|
}
|
|
}
|
|
|
|
func NewHandler(dataStore store.Store, aiService ai.Service) http.Handler {
|
|
if aiService == nil {
|
|
aiService = ai.NewDisabledService("", "", "AI 服务未配置")
|
|
}
|
|
instance := &server{store: dataStore, ai: aiService}
|
|
router := chi.NewRouter()
|
|
|
|
router.Get("/api/health", instance.handleHealth)
|
|
router.Get("/api/ai/status", instance.handleAIStatus)
|
|
router.Post("/api/ai/operators/generate", instance.handleAIOperatorGenerate)
|
|
router.Post("/api/ai/workflows/generate", instance.handleAIWorkflowGenerate)
|
|
router.Get("/api/dashboard", instance.handleDashboard)
|
|
|
|
router.Get("/api/projects", instance.handleProjectsList)
|
|
router.Post("/api/projects", instance.handleProjectsCreate)
|
|
router.Get("/api/projects/{id}", instance.handleProjectsGet)
|
|
router.Put("/api/projects/{id}", instance.handleProjectsUpdate)
|
|
router.Delete("/api/projects/{id}", instance.handleProjectsDelete)
|
|
router.Get("/api/projects/{id}/workflows", instance.handleProjectWorkflowsList)
|
|
router.Post("/api/projects/{id}/workflows", instance.handleProjectWorkflowsCreate)
|
|
|
|
router.Get("/api/workflows/{id}", instance.handleWorkflowsGet)
|
|
router.Put("/api/workflows/{id}", instance.handleWorkflowsUpdate)
|
|
router.Delete("/api/workflows/{id}", instance.handleWorkflowsDelete)
|
|
router.Post("/api/workflows/{id}/run", instance.handleWorkflowRun)
|
|
|
|
router.Get("/api/templates", instance.handleTemplatesList)
|
|
router.Post("/api/templates", instance.handleTemplatesCreate)
|
|
router.Get("/api/templates/{id}", instance.handleTemplatesGet)
|
|
router.Put("/api/templates/{id}", instance.handleTemplatesUpdate)
|
|
router.Delete("/api/templates/{id}", instance.handleTemplatesDelete)
|
|
|
|
router.Get("/api/operators", instance.handleOperatorsList)
|
|
router.Post("/api/operators", instance.handleOperatorsCreate)
|
|
router.Get("/api/operators/{id}", instance.handleOperatorsGet)
|
|
router.Put("/api/operators/{id}", instance.handleOperatorsUpdate)
|
|
router.Delete("/api/operators/{id}", instance.handleOperatorsDelete)
|
|
|
|
router.Get("/api/runs", instance.handleRunsList)
|
|
router.Get("/api/runs/{id}", instance.handleRunsGet)
|
|
router.Get("/api/runs/{id}/logs", instance.handleRunsLogs)
|
|
router.Get("/api/runs/{id}/resources", instance.handleRunsResources)
|
|
router.Get("/api/runs/{id}/artifacts", instance.handleRunsArtifacts)
|
|
|
|
router.Get("/api/audit-tasks", instance.handleAuditTasksList)
|
|
router.Post("/api/audit-tasks/{id}/approve", instance.handleAuditTaskApprove)
|
|
router.Post("/api/audit-tasks/{id}/reject", instance.handleAuditTaskReject)
|
|
|
|
router.Get("/api/users", instance.handleUsersList)
|
|
router.Post("/api/users", instance.handleUsersCreate)
|
|
router.Put("/api/users/{id}", instance.handleUsersUpdate)
|
|
router.Delete("/api/users/{id}", instance.handleUsersDelete)
|
|
|
|
router.Get("/api/settings", instance.handleSettingsGet)
|
|
router.Put("/api/settings", instance.handleSettingsUpdate)
|
|
|
|
router.Get("/api/storage/buckets", instance.handleStorageBuckets)
|
|
router.Get("/api/storage/objects", instance.handleStorageObjects)
|
|
|
|
return router
|
|
}
|
|
|
|
func (server *server) handleHealth(writer http.ResponseWriter, _ *http.Request) {
|
|
renderJSON(writer, http.StatusOK, map[string]string{"status": "ok", "service": "droboticflow-api"})
|
|
}
|
|
|
|
func (server *server) handleAIStatus(writer http.ResponseWriter, _ *http.Request) {
|
|
renderJSON(writer, http.StatusOK, server.resolveAIService(context.Background()).Status())
|
|
}
|
|
|
|
type aiGenerateRequest struct {
|
|
Description string `json:"description"`
|
|
}
|
|
|
|
func (server *server) handleAIOperatorGenerate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload aiGenerateRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(payload.Description) == "" {
|
|
renderValidationError(writer, validationIssue{Field: "description", Message: "description is required"})
|
|
return
|
|
}
|
|
item, err := server.resolveAIService(request.Context()).GenerateOperator(request.Context(), payload.Description)
|
|
if err != nil {
|
|
renderAIError(writer, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleAIWorkflowGenerate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload aiGenerateRequest
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(payload.Description) == "" {
|
|
renderValidationError(writer, validationIssue{Field: "description", Message: "description is required"})
|
|
return
|
|
}
|
|
operators, err := server.store.ListOperators(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if len(operators) == 0 {
|
|
renderValidationError(writer, validationIssue{Field: "operators", Message: "at least one operator is required to generate a workflow"})
|
|
return
|
|
}
|
|
item, err := server.resolveAIService(request.Context()).GenerateWorkflow(request.Context(), payload.Description, operators)
|
|
if err != nil {
|
|
renderAIError(writer, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleDashboard(writer http.ResponseWriter, request *http.Request) {
|
|
summary, err := server.store.GetDashboardSummary(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, summary)
|
|
}
|
|
|
|
func (server *server) populateProjectWorkflowCounts(ctx context.Context, items []domain.ProjectRecord) ([]domain.ProjectRecord, error) {
|
|
if len(items) == 0 {
|
|
return items, nil
|
|
}
|
|
|
|
workflows, err := server.store.ListAllWorkflows(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
counts := make(map[string]int, len(items))
|
|
for _, workflow := range workflows {
|
|
if workflow.ProjectID == "" {
|
|
continue
|
|
}
|
|
counts[workflow.ProjectID]++
|
|
}
|
|
|
|
enriched := make([]domain.ProjectRecord, len(items))
|
|
for index, item := range items {
|
|
item.WorkflowCount = counts[item.ID]
|
|
enriched[index] = item
|
|
}
|
|
return enriched, nil
|
|
}
|
|
|
|
func (server *server) populateSingleProjectWorkflowCount(ctx context.Context, item *domain.ProjectRecord) (*domain.ProjectRecord, error) {
|
|
if item == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
workflows, err := server.store.ListWorkflowsByProject(ctx, item.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
enriched := *item
|
|
enriched.WorkflowCount = len(workflows)
|
|
return &enriched, nil
|
|
}
|
|
|
|
func (server *server) handleProjectsList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListProjects(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
items, err = server.populateProjectWorkflowCounts(request.Context(), items)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleProjectsCreate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload domain.CreateProjectInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(payload.Name) == "" {
|
|
renderValidationError(writer, validationIssue{Field: "name", Message: "name is required"})
|
|
return
|
|
}
|
|
project, err := server.store.CreateProject(request.Context(), payload)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, project)
|
|
}
|
|
|
|
func (server *server) handleProjectsGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetProject(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": "Project not found"})
|
|
return
|
|
}
|
|
item, err = server.populateSingleProjectWorkflowCount(request.Context(), item)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
type projectPatch struct {
|
|
Name *string `json:"name"`
|
|
Description *string `json:"description"`
|
|
Status *string `json:"status"`
|
|
}
|
|
|
|
func (server *server) handleProjectsUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetProject(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": "Project not found"})
|
|
return
|
|
}
|
|
|
|
var payload projectPatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Name != nil {
|
|
item.Name = strings.TrimSpace(*payload.Name)
|
|
}
|
|
if payload.Description != nil {
|
|
item.Description = *payload.Description
|
|
}
|
|
if payload.Status != nil {
|
|
item.Status = *payload.Status
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertProject(request.Context(), *item); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
item, err = server.populateSingleProjectWorkflowCount(request.Context(), item)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleProjectsDelete(writer http.ResponseWriter, request *http.Request) {
|
|
deleted, err := server.store.DeleteProject(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if !deleted {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (server *server) handleProjectWorkflowsList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListWorkflowsByProject(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func validWorkflowType(value domain.WorkflowType) bool {
|
|
return value == domain.WorkflowTypeBatch || value == domain.WorkflowTypeStreaming
|
|
}
|
|
|
|
func validateWorkflowExecutionConfig(maxConcurrentRuns int, nodeTimeoutSeconds int, runTimeoutSeconds int, maxRetryAttempts int, retryBackoffSeconds int) []validationIssue {
|
|
issues := make([]validationIssue, 0, 5)
|
|
if maxConcurrentRuns < 0 {
|
|
issues = append(issues, validationIssue{Field: "maxConcurrentRuns", Message: "maxConcurrentRuns must be zero or greater"})
|
|
}
|
|
if nodeTimeoutSeconds < 0 {
|
|
issues = append(issues, validationIssue{Field: "nodeTimeoutSeconds", Message: "nodeTimeoutSeconds must be zero or greater"})
|
|
}
|
|
if runTimeoutSeconds < 0 {
|
|
issues = append(issues, validationIssue{Field: "runTimeoutSeconds", Message: "runTimeoutSeconds must be zero or greater"})
|
|
}
|
|
if maxRetryAttempts < 0 {
|
|
issues = append(issues, validationIssue{Field: "maxRetryAttempts", Message: "maxRetryAttempts must be zero or greater"})
|
|
}
|
|
if retryBackoffSeconds < 0 {
|
|
issues = append(issues, validationIssue{Field: "retryBackoffSeconds", Message: "retryBackoffSeconds must be zero or greater"})
|
|
}
|
|
return issues
|
|
}
|
|
|
|
func (server *server) handleProjectWorkflowsCreate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload domain.CreateWorkflowInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
payload.ProjectID = chi.URLParam(request, "id")
|
|
if strings.TrimSpace(payload.Name) == "" || !validWorkflowType(payload.Type) {
|
|
renderValidationError(writer,
|
|
validationIssue{Field: "name", Message: "name is required"},
|
|
validationIssue{Field: "type", Message: "type must be batch or streaming"},
|
|
)
|
|
return
|
|
}
|
|
if issues := validateWorkflowExecutionConfig(payload.MaxConcurrentRuns, payload.NodeTimeoutSeconds, payload.RunTimeoutSeconds, payload.MaxRetryAttempts, payload.RetryBackoffSeconds); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item, err := server.store.CreateWorkflow(request.Context(), payload)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
func (server *server) handleWorkflowsGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetWorkflow(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": "Workflow not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
type workflowPatch struct {
|
|
Name *string `json:"name"`
|
|
Description *string `json:"description"`
|
|
Type *domain.WorkflowType `json:"type"`
|
|
MaxConcurrentRuns *int `json:"maxConcurrentRuns"`
|
|
NodeTimeoutSeconds *int `json:"nodeTimeoutSeconds"`
|
|
RunTimeoutSeconds *int `json:"runTimeoutSeconds"`
|
|
MaxRetryAttempts *int `json:"maxRetryAttempts"`
|
|
RetryBackoffSeconds *int `json:"retryBackoffSeconds"`
|
|
Schedule *domain.WorkflowSchedule `json:"schedule"`
|
|
Nodes *[]domain.WorkflowNode `json:"nodes"`
|
|
Edges *[]domain.WorkflowEdge `json:"edges"`
|
|
Status *domain.WorkflowStatus `json:"status"`
|
|
}
|
|
|
|
func (server *server) handleWorkflowsUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetWorkflow(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": "Workflow not found"})
|
|
return
|
|
}
|
|
|
|
var payload workflowPatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Name != nil {
|
|
item.Name = *payload.Name
|
|
}
|
|
if payload.Description != nil {
|
|
item.Description = *payload.Description
|
|
}
|
|
if payload.Type != nil {
|
|
item.Type = *payload.Type
|
|
}
|
|
if payload.MaxConcurrentRuns != nil {
|
|
if issues := validateWorkflowExecutionConfig(*payload.MaxConcurrentRuns, 0, 0, 0, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.MaxConcurrentRuns = *payload.MaxConcurrentRuns
|
|
}
|
|
if payload.NodeTimeoutSeconds != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, *payload.NodeTimeoutSeconds, 0, 0, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.NodeTimeoutSeconds = *payload.NodeTimeoutSeconds
|
|
}
|
|
if payload.RunTimeoutSeconds != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, 0, *payload.RunTimeoutSeconds, 0, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.RunTimeoutSeconds = *payload.RunTimeoutSeconds
|
|
}
|
|
if payload.MaxRetryAttempts != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, 0, 0, *payload.MaxRetryAttempts, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.MaxRetryAttempts = *payload.MaxRetryAttempts
|
|
}
|
|
if payload.RetryBackoffSeconds != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, 0, 0, 0, *payload.RetryBackoffSeconds); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.RetryBackoffSeconds = *payload.RetryBackoffSeconds
|
|
}
|
|
if payload.Schedule != nil {
|
|
item.Schedule = payload.Schedule
|
|
}
|
|
if payload.Nodes != nil {
|
|
item.Nodes = *payload.Nodes
|
|
}
|
|
if payload.Edges != nil {
|
|
item.Edges = *payload.Edges
|
|
}
|
|
if payload.Status != nil {
|
|
item.Status = *payload.Status
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertWorkflow(request.Context(), *item); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleWorkflowsDelete(writer http.ResponseWriter, request *http.Request) {
|
|
deleted, err := server.store.DeleteWorkflow(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if !deleted {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
type runRequest struct {
|
|
Trigger domain.RunTrigger `json:"trigger"`
|
|
}
|
|
|
|
func validRunTrigger(value domain.RunTrigger) bool {
|
|
return value == domain.RunTriggerManual || value == domain.RunTriggerScheduled || value == domain.RunTriggerRetry
|
|
}
|
|
|
|
func (server *server) handleWorkflowRun(writer http.ResponseWriter, request *http.Request) {
|
|
payload := runRequest{Trigger: domain.RunTriggerManual}
|
|
if request.ContentLength != 0 {
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
}
|
|
if !validRunTrigger(payload.Trigger) {
|
|
renderValidationError(writer, validationIssue{Field: "trigger", Message: "trigger must be manual, scheduled, or retry"})
|
|
return
|
|
}
|
|
run, err := server.store.CreateRun(request.Context(), chi.URLParam(request, "id"), payload.Trigger)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "not found") {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": err.Error()})
|
|
return
|
|
}
|
|
if errors.Is(err, store.ErrWorkflowAlreadyCompleted) {
|
|
renderJSON(writer, http.StatusConflict, map[string]string{"error": "工作流已成功执行,不支持再次手动运行"})
|
|
return
|
|
}
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusAccepted, run)
|
|
}
|
|
|
|
func (server *server) handleTemplatesList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListTemplates(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleTemplatesCreate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload domain.CreateTemplateInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Type == "" {
|
|
payload.Type = domain.WorkflowTypeBatch
|
|
}
|
|
issues := make([]validationIssue, 0)
|
|
if strings.TrimSpace(payload.Name) == "" {
|
|
issues = append(issues, validationIssue{Field: "name", Message: "name is required"})
|
|
}
|
|
if !validWorkflowType(payload.Type) {
|
|
issues = append(issues, validationIssue{Field: "type", Message: "type must be batch or streaming"})
|
|
}
|
|
if configIssues := validateWorkflowExecutionConfig(payload.MaxConcurrentRuns, payload.NodeTimeoutSeconds, payload.RunTimeoutSeconds, payload.MaxRetryAttempts, payload.RetryBackoffSeconds); len(configIssues) > 0 {
|
|
issues = append(issues, configIssues...)
|
|
}
|
|
if len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item, err := server.store.CreateTemplate(request.Context(), payload)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
func (server *server) handleTemplatesGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetTemplate(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": "Template not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
type templatePatch struct {
|
|
Name *string `json:"name"`
|
|
Description *string `json:"description"`
|
|
Type *domain.WorkflowType `json:"type"`
|
|
MaxConcurrentRuns *int `json:"maxConcurrentRuns"`
|
|
NodeTimeoutSeconds *int `json:"nodeTimeoutSeconds"`
|
|
RunTimeoutSeconds *int `json:"runTimeoutSeconds"`
|
|
MaxRetryAttempts *int `json:"maxRetryAttempts"`
|
|
RetryBackoffSeconds *int `json:"retryBackoffSeconds"`
|
|
Schedule *domain.WorkflowSchedule `json:"schedule"`
|
|
Nodes *[]domain.WorkflowNode `json:"nodes"`
|
|
Edges *[]domain.WorkflowEdge `json:"edges"`
|
|
}
|
|
|
|
func (server *server) handleTemplatesUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetTemplate(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": "Template not found"})
|
|
return
|
|
}
|
|
var payload templatePatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Name != nil {
|
|
item.Name = *payload.Name
|
|
}
|
|
if payload.Description != nil {
|
|
item.Description = *payload.Description
|
|
}
|
|
if payload.Type != nil {
|
|
if !validWorkflowType(*payload.Type) {
|
|
renderValidationError(writer, validationIssue{Field: "type", Message: "type must be batch or streaming"})
|
|
return
|
|
}
|
|
item.Type = *payload.Type
|
|
}
|
|
if payload.MaxConcurrentRuns != nil {
|
|
if issues := validateWorkflowExecutionConfig(*payload.MaxConcurrentRuns, 0, 0, 0, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.MaxConcurrentRuns = *payload.MaxConcurrentRuns
|
|
}
|
|
if payload.NodeTimeoutSeconds != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, *payload.NodeTimeoutSeconds, 0, 0, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.NodeTimeoutSeconds = *payload.NodeTimeoutSeconds
|
|
}
|
|
if payload.RunTimeoutSeconds != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, 0, *payload.RunTimeoutSeconds, 0, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.RunTimeoutSeconds = *payload.RunTimeoutSeconds
|
|
}
|
|
if payload.MaxRetryAttempts != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, 0, 0, *payload.MaxRetryAttempts, 0); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.MaxRetryAttempts = *payload.MaxRetryAttempts
|
|
}
|
|
if payload.RetryBackoffSeconds != nil {
|
|
if issues := validateWorkflowExecutionConfig(0, 0, 0, 0, *payload.RetryBackoffSeconds); len(issues) > 0 {
|
|
renderValidationError(writer, issues...)
|
|
return
|
|
}
|
|
item.RetryBackoffSeconds = *payload.RetryBackoffSeconds
|
|
}
|
|
if payload.Schedule != nil {
|
|
item.Schedule = payload.Schedule
|
|
}
|
|
if payload.Nodes != nil {
|
|
item.Nodes = *payload.Nodes
|
|
}
|
|
if payload.Edges != nil {
|
|
item.Edges = *payload.Edges
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertTemplate(request.Context(), *item); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleTemplatesDelete(writer http.ResponseWriter, request *http.Request) {
|
|
deleted, err := server.store.DeleteTemplate(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if !deleted {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (server *server) handleOperatorsList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListOperators(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleOperatorsCreate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload domain.CreateOperatorInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if strings.TrimSpace(payload.Name) == "" || strings.TrimSpace(payload.Category) == "" || strings.TrimSpace(payload.Description) == "" {
|
|
renderValidationError(writer,
|
|
validationIssue{Field: "name", Message: "name is required"},
|
|
validationIssue{Field: "category", Message: "category is required"},
|
|
validationIssue{Field: "description", Message: "description is required"},
|
|
)
|
|
return
|
|
}
|
|
item, err := server.store.CreateOperator(request.Context(), payload)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
func (server *server) handleOperatorsGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetOperator(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": "Operator not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
type operatorPatch struct {
|
|
Name *string `json:"name"`
|
|
Type *string `json:"type"`
|
|
Category *string `json:"category"`
|
|
Description *string `json:"description"`
|
|
Inputs *[]domain.PortDefinition `json:"inputs"`
|
|
Outputs *[]domain.PortDefinition `json:"outputs"`
|
|
ConfigSchema *map[string]any `json:"configSchema"`
|
|
Image *string `json:"image"`
|
|
SkillDefinition *string `json:"skillDefinition"`
|
|
Hyperparams *[]domain.HyperParam `json:"hyperparams"`
|
|
Resources *domain.OperatorResources `json:"resources"`
|
|
}
|
|
|
|
func (server *server) handleOperatorsUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetOperator(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": "Operator not found"})
|
|
return
|
|
}
|
|
var payload operatorPatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Name != nil {
|
|
item.Name = *payload.Name
|
|
}
|
|
if payload.Type != nil {
|
|
item.Type = *payload.Type
|
|
}
|
|
if payload.Category != nil {
|
|
item.Category = *payload.Category
|
|
}
|
|
if payload.Description != nil {
|
|
item.Description = *payload.Description
|
|
}
|
|
if payload.Inputs != nil {
|
|
item.Inputs = *payload.Inputs
|
|
}
|
|
if payload.Outputs != nil {
|
|
item.Outputs = *payload.Outputs
|
|
}
|
|
if payload.ConfigSchema != nil {
|
|
item.ConfigSchema = *payload.ConfigSchema
|
|
}
|
|
if payload.Image != nil {
|
|
item.Image = *payload.Image
|
|
}
|
|
if payload.SkillDefinition != nil {
|
|
item.SkillDefinition = *payload.SkillDefinition
|
|
}
|
|
if payload.Hyperparams != nil {
|
|
item.Hyperparams = *payload.Hyperparams
|
|
}
|
|
if payload.Resources != nil {
|
|
item.Resources = payload.Resources
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertOperator(request.Context(), *item); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleOperatorsDelete(writer http.ResponseWriter, request *http.Request) {
|
|
deleted, err := server.store.DeleteOperator(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if !deleted {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (server *server) handleRunsList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListRuns(request.Context(), request.URL.Query().Get("status"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) loadRun(ctx context.Context, id string) (*domain.RunRecord, error) {
|
|
item, err := server.store.GetRun(ctx, id)
|
|
if err != nil || item == nil {
|
|
return item, err
|
|
}
|
|
return item, nil
|
|
}
|
|
|
|
func (server *server) handleRunsGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.loadRun(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": "Run not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleRunsLogs(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.loadRun(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": "Run not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": item.Logs})
|
|
}
|
|
|
|
func (server *server) handleRunsResources(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.loadRun(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": "Run not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": item.ResourceSeries})
|
|
}
|
|
|
|
func (server *server) handleRunsArtifacts(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.loadRun(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": "Run not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": item.Artifacts})
|
|
}
|
|
|
|
func (server *server) handleAuditTasksList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListAuditTasks(request.Context(), request.URL.Query().Get("status"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) resolveAuditTask(ctx context.Context, id string, decision domain.AuditStatus) (*domain.AuditTaskRecord, error) {
|
|
task, err := server.store.GetAuditTask(ctx, id)
|
|
if err != nil || task == nil {
|
|
return task, err
|
|
}
|
|
task.Status = decision
|
|
task.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertAuditTask(ctx, *task); err != nil {
|
|
return nil, err
|
|
}
|
|
run, err := server.store.GetRun(ctx, task.RunID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if run != nil {
|
|
run.Status = domain.RunStatusQueued
|
|
run.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertRun(ctx, *run); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return task, nil
|
|
}
|
|
|
|
func (server *server) handleAuditTaskApprove(writer http.ResponseWriter, request *http.Request) {
|
|
task, err := server.resolveAuditTask(request.Context(), chi.URLParam(request, "id"), domain.AuditStatusApproved)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if task == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Audit task not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, task)
|
|
}
|
|
|
|
func (server *server) handleAuditTaskReject(writer http.ResponseWriter, request *http.Request) {
|
|
task, err := server.resolveAuditTask(request.Context(), chi.URLParam(request, "id"), domain.AuditStatusRejected)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if task == nil {
|
|
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Audit task not found"})
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, task)
|
|
}
|
|
|
|
func (server *server) handleUsersList(writer http.ResponseWriter, request *http.Request) {
|
|
items, err := server.store.ListUsers(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func normalizeUserInput(name string, email string) (string, string) {
|
|
return strings.TrimSpace(name), strings.TrimSpace(strings.ToLower(email))
|
|
}
|
|
|
|
func (server *server) handleUsersCreate(writer http.ResponseWriter, request *http.Request) {
|
|
var payload domain.CreateUserInput
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
|
|
payload.Name, payload.Email = normalizeUserInput(payload.Name, payload.Email)
|
|
if payload.Name == "" {
|
|
renderValidationError(writer, validationIssue{Field: "name", Message: "name is required"})
|
|
return
|
|
}
|
|
if _, err := mail.ParseAddress(payload.Email); err != nil {
|
|
renderValidationError(writer, validationIssue{Field: "email", Message: "email must be valid"})
|
|
return
|
|
}
|
|
if !validUserRole(payload.Role) {
|
|
renderValidationError(writer, validationIssue{Field: "role", Message: "role must be admin, auditor, or operator"})
|
|
return
|
|
}
|
|
|
|
item, err := server.store.CreateUser(request.Context(), payload)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusCreated, item)
|
|
}
|
|
|
|
type userPatch struct {
|
|
Name *string `json:"name"`
|
|
Email *string `json:"email"`
|
|
Role *domain.UserRole `json:"role"`
|
|
}
|
|
|
|
func validUserRole(value domain.UserRole) bool {
|
|
return value == domain.UserRoleAdmin || value == domain.UserRoleAuditor || value == domain.UserRoleOperator
|
|
}
|
|
|
|
func (server *server) handleUsersUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetUser(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": "User not found"})
|
|
return
|
|
}
|
|
var payload userPatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Name != nil {
|
|
item.Name = strings.TrimSpace(*payload.Name)
|
|
}
|
|
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
|
|
}
|
|
item.Email = normalizedEmail
|
|
}
|
|
if payload.Role != nil {
|
|
if !validUserRole(*payload.Role) {
|
|
renderValidationError(writer, validationIssue{Field: "role", Message: "role must be admin, auditor, or operator"})
|
|
return
|
|
}
|
|
item.Role = *payload.Role
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertUser(request.Context(), *item); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, item)
|
|
}
|
|
|
|
func (server *server) handleUsersDelete(writer http.ResponseWriter, request *http.Request) {
|
|
deleted, err := server.store.DeleteUser(request.Context(), chi.URLParam(request, "id"))
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
if !deleted {
|
|
writer.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
writer.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (server *server) handleSettingsGet(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetSettings(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, sanitizeSettings(item))
|
|
}
|
|
|
|
type settingsPatch struct {
|
|
K8s *struct {
|
|
Enabled *bool `json:"enabled"`
|
|
Endpoint *string `json:"endpoint"`
|
|
Namespace *string `json:"namespace"`
|
|
Kubeconfig *string `json:"kubeconfig"`
|
|
} `json:"k8s"`
|
|
Worker *struct {
|
|
PollIntervalMS *int `json:"pollIntervalMs"`
|
|
MaxConcurrentRuns *int `json:"maxConcurrentRuns"`
|
|
} `json:"worker"`
|
|
AI *struct {
|
|
Provider *string `json:"provider"`
|
|
BaseURL *string `json:"baseURL"`
|
|
Model *string `json:"model"`
|
|
APIKey *string `json:"apiKey"`
|
|
} `json:"ai"`
|
|
Defaults *struct {
|
|
CPURequest *string `json:"cpuRequest"`
|
|
CPULimit *string `json:"cpuLimit"`
|
|
MemoryRequest *string `json:"memoryRequest"`
|
|
MemoryLimit *string `json:"memoryLimit"`
|
|
} `json:"defaults"`
|
|
Timezone *string `json:"timezone"`
|
|
}
|
|
|
|
func (server *server) handleSettingsUpdate(writer http.ResponseWriter, request *http.Request) {
|
|
item, err := server.store.GetSettings(request.Context())
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
var payload settingsPatch
|
|
if !decodeJSON(writer, request, &payload) {
|
|
return
|
|
}
|
|
if payload.Timezone != nil {
|
|
timezone := strings.TrimSpace(*payload.Timezone)
|
|
if timezone == "" {
|
|
renderValidationError(writer, validationIssue{Field: "timezone", Message: "timezone is required"})
|
|
return
|
|
}
|
|
if _, err := time.LoadLocation(timezone); err != nil {
|
|
renderValidationError(writer, validationIssue{Field: "timezone", Message: "timezone must be a valid IANA timezone"})
|
|
return
|
|
}
|
|
item.Timezone = timezone
|
|
}
|
|
if payload.K8s != nil {
|
|
if payload.K8s.Enabled != nil {
|
|
item.K8s.Enabled = *payload.K8s.Enabled
|
|
}
|
|
if payload.K8s.Endpoint != nil {
|
|
item.K8s.Endpoint = *payload.K8s.Endpoint
|
|
}
|
|
if payload.K8s.Namespace != nil {
|
|
item.K8s.Namespace = *payload.K8s.Namespace
|
|
}
|
|
if payload.K8s.Kubeconfig != nil {
|
|
item.K8s.Kubeconfig = strings.TrimSpace(*payload.K8s.Kubeconfig)
|
|
}
|
|
}
|
|
if payload.Worker != nil {
|
|
if payload.Worker.PollIntervalMS != nil && *payload.Worker.PollIntervalMS > 0 {
|
|
item.Worker.PollIntervalMS = *payload.Worker.PollIntervalMS
|
|
}
|
|
if payload.Worker.MaxConcurrentRuns != nil && *payload.Worker.MaxConcurrentRuns > 0 {
|
|
item.Worker.MaxConcurrentRuns = *payload.Worker.MaxConcurrentRuns
|
|
}
|
|
}
|
|
if payload.AI != nil {
|
|
if payload.AI.Provider != nil {
|
|
item.AI.Provider = strings.TrimSpace(*payload.AI.Provider)
|
|
}
|
|
if payload.AI.BaseURL != nil {
|
|
item.AI.BaseURL = strings.TrimSpace(*payload.AI.BaseURL)
|
|
}
|
|
if payload.AI.Model != nil {
|
|
item.AI.Model = strings.TrimSpace(*payload.AI.Model)
|
|
}
|
|
if payload.AI.APIKey != nil {
|
|
item.AI.APIKey = strings.TrimSpace(*payload.AI.APIKey)
|
|
}
|
|
}
|
|
if payload.Defaults != nil {
|
|
if payload.Defaults.CPURequest != nil {
|
|
item.Defaults.CPURequest = *payload.Defaults.CPURequest
|
|
}
|
|
if payload.Defaults.CPULimit != nil {
|
|
item.Defaults.CPULimit = *payload.Defaults.CPULimit
|
|
}
|
|
if payload.Defaults.MemoryRequest != nil {
|
|
item.Defaults.MemoryRequest = *payload.Defaults.MemoryRequest
|
|
}
|
|
if payload.Defaults.MemoryLimit != nil {
|
|
item.Defaults.MemoryLimit = *payload.Defaults.MemoryLimit
|
|
}
|
|
}
|
|
item.UpdatedAt = nowISO()
|
|
if err := server.store.UpsertSettings(request.Context(), *item); err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, sanitizeSettings(item))
|
|
}
|
|
|
|
func (server *server) resolveAIService(ctx context.Context) ai.Service {
|
|
settings, err := server.store.GetSettings(ctx)
|
|
if err != nil || settings == nil {
|
|
return server.ai
|
|
}
|
|
if strings.TrimSpace(settings.AI.APIKey) != "" {
|
|
return ai.NewService(settings.AI.BaseURL, settings.AI.APIKey, settings.AI.Model)
|
|
}
|
|
if server.ai != nil && server.ai.Status().Enabled {
|
|
return server.ai
|
|
}
|
|
return ai.NewDisabledService(settings.AI.BaseURL, settings.AI.Model, "服务端未配置 AI_API_KEY")
|
|
}
|
|
|
|
func sanitizeSettings(item *domain.SettingsRecord) *domain.SettingsView {
|
|
if item == nil {
|
|
return nil
|
|
}
|
|
view := &domain.SettingsView{
|
|
ID: item.ID,
|
|
K8s: item.K8s,
|
|
Worker: item.Worker,
|
|
AI: item.AI,
|
|
Defaults: item.Defaults,
|
|
Timezone: item.Timezone,
|
|
UpdatedAt: item.UpdatedAt,
|
|
}
|
|
view.K8s.HasKubeconfig = strings.TrimSpace(view.K8s.Kubeconfig) != ""
|
|
view.K8s.KubeconfigPreview = maskedSecretPreview(view.K8s.Kubeconfig)
|
|
view.K8s.Kubeconfig = ""
|
|
view.AI.HasAPIKey = strings.TrimSpace(view.AI.APIKey) != ""
|
|
view.AI.APIKeyPreview = maskedSecretPreview(view.AI.APIKey)
|
|
view.AI.APIKey = ""
|
|
return view
|
|
}
|
|
|
|
func (server *server) handleStorageBuckets(writer http.ResponseWriter, request *http.Request) {
|
|
sourcePath := strings.TrimSpace(request.URL.Query().Get("sourcePath"))
|
|
if sourcePath == "" {
|
|
renderValidationError(writer, validationIssue{Field: "sourcePath", Message: "sourcePath is required"})
|
|
return
|
|
}
|
|
items, err := server.store.ListStorageBuckets(request.Context(), sourcePath)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func (server *server) handleStorageObjects(writer http.ResponseWriter, request *http.Request) {
|
|
sourcePath := strings.TrimSpace(request.URL.Query().Get("sourcePath"))
|
|
if sourcePath == "" {
|
|
renderValidationError(writer, validationIssue{Field: "sourcePath", Message: "sourcePath is required"})
|
|
return
|
|
}
|
|
items, err := server.store.ListStorageObjects(
|
|
request.Context(),
|
|
sourcePath,
|
|
request.URL.Query().Get("bucket"),
|
|
request.URL.Query().Get("prefix"),
|
|
)
|
|
if err != nil {
|
|
renderError(writer, http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
|
|
}
|
|
|
|
func decodeJSON(writer http.ResponseWriter, request *http.Request, target any) bool {
|
|
defer request.Body.Close()
|
|
decoder := json.NewDecoder(request.Body)
|
|
if err := decoder.Decode(target); err != nil {
|
|
renderJSON(writer, http.StatusBadRequest, map[string]any{"error": "Validation failed", "issues": []validationIssue{{Field: "body", Message: "invalid JSON payload"}}})
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func renderValidationError(writer http.ResponseWriter, issues ...validationIssue) {
|
|
renderJSON(writer, http.StatusBadRequest, map[string]any{"error": "Validation failed", "issues": issues})
|
|
}
|
|
|
|
func renderError(writer http.ResponseWriter, status int, err error) {
|
|
renderJSON(writer, status, map[string]string{"error": err.Error()})
|
|
}
|
|
|
|
func renderAIError(writer http.ResponseWriter, err error) {
|
|
switch {
|
|
case errors.Is(err, ai.ErrUnavailable):
|
|
renderJSON(writer, http.StatusServiceUnavailable, map[string]string{"error": "AI 服务未配置,请在服务端配置 AI_API_KEY 后再试"})
|
|
case strings.Contains(err.Error(), "AI 生成超时") || strings.Contains(err.Error(), "AI 服务响应超时"):
|
|
renderJSON(writer, http.StatusGatewayTimeout, map[string]string{"error": err.Error()})
|
|
case strings.Contains(strings.ToLower(err.Error()), "description is required"):
|
|
renderValidationError(writer, validationIssue{Field: "description", Message: "description is required"})
|
|
default:
|
|
renderJSON(writer, http.StatusBadGateway, map[string]string{"error": err.Error()})
|
|
}
|
|
}
|
|
|
|
func renderJSON(writer http.ResponseWriter, status int, payload any) {
|
|
writer.Header().Set("Content-Type", "application/json")
|
|
writer.WriteHeader(status)
|
|
_ = json.NewEncoder(writer).Encode(payload)
|
|
}
|
|
|
|
func nowISO() string {
|
|
return time.Now().UTC().Format(time.RFC3339Nano)
|
|
}
|