droboticflow/internal/api/workflow_releases.go

582 lines
25 KiB
Go

package api
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"net/http"
"strings"
"droboticflow/internal/domain"
pluginregistry "droboticflow/internal/plugins"
"github.com/go-chi/chi/v5"
)
type workflowPublishRequest struct {
ReleaseNotes string `json:"releaseNotes"`
}
type projectWorkflowInstanceRequest struct {
ReleaseID string `json:"releaseId"`
SupplierID string `json:"supplierId,omitempty"`
}
var productionHumanRoles = []domain.AnnotationAssignmentRole{
domain.AnnotationRoleAnnotator,
domain.AnnotationRoleQualityReviewer,
domain.AnnotationRoleAcceptanceReviewer,
}
func releaseUsesAnnotationGate(release domain.WorkflowReleaseRecord) bool {
for _, node := range release.Nodes {
if strings.TrimSpace(node.Data.OperatorID) == "operator-builtin-annotation-gate" {
return true
}
}
return false
}
func (server *server) releaseUsesFanyuSupplierPool(ctx context.Context, release domain.WorkflowReleaseRecord) (bool, error) {
if domain.WorkflowProcessingProfile(release.Nodes) != domain.ProcessingProfileRawHuman {
return false, nil
}
for _, node := range release.Nodes {
if strings.TrimSpace(node.Data.OperatorID) != "operator-builtin-annotation-gate" {
continue
}
for _, param := range node.Data.Hyperparams {
if param.Key != "ANNOTATION_TEMPLATE_ID" || strings.TrimSpace(param.Value) == "" {
continue
}
template, err := server.store.GetAnnotationTemplate(ctx, strings.TrimSpace(param.Value))
if err != nil {
return false, err
}
return template != nil && domain.IsFanyuV58ThreeRoleHumanLoop(template.HumanStages), nil
}
}
return false, nil
}
func supplierHasProductionHumanRoles(members []domain.ProjectMemberRecord, supplierID string) bool {
covered := map[domain.AnnotationAssignmentRole]bool{}
for _, member := range members {
if strings.TrimSpace(member.SupplierID) != supplierID {
continue
}
for _, role := range member.Roles {
covered[role] = true
}
}
for _, role := range productionHumanRoles {
if !covered[role] {
return false
}
}
return true
}
func bindAnnotationSupplier(nodes []domain.WorkflowNode, supplierID string) []domain.WorkflowNode {
cloned := make([]domain.WorkflowNode, len(nodes))
copy(cloned, nodes)
for index := range cloned {
cloned[index].Data.Hyperparams = append([]domain.HyperParam(nil), cloned[index].Data.Hyperparams...)
if strings.TrimSpace(cloned[index].Data.OperatorID) != "operator-builtin-annotation-gate" {
continue
}
bound := false
for paramIndex := range cloned[index].Data.Hyperparams {
if strings.TrimSpace(cloned[index].Data.Hyperparams[paramIndex].Key) != "ANNOTATION_SUPPLIER_ID" {
continue
}
cloned[index].Data.Hyperparams[paramIndex].Value = supplierID
cloned[index].Data.Hyperparams[paramIndex].Type = "string"
cloned[index].Data.Hyperparams[paramIndex].Description = "当前项目绑定的供应商 ID"
bound = true
}
if !bound {
cloned[index].Data.Hyperparams = append(cloned[index].Data.Hyperparams, domain.HyperParam{
Key: "ANNOTATION_SUPPLIER_ID", Value: supplierID, Type: "string", Description: "当前项目绑定的供应商 ID",
})
}
}
return cloned
}
func (server *server) resolveProjectWorkflowSupplier(ctx context.Context, project domain.ProjectRecord, release domain.WorkflowReleaseRecord, requested string) (string, []validationIssue, error) {
if !releaseUsesAnnotationGate(release) {
return "", nil, nil
}
publicPool, err := server.releaseUsesFanyuSupplierPool(ctx, release)
if err != nil {
return "", nil, err
}
if publicPool {
return "", nil, nil
}
members, err := server.store.ListProjectMembers(ctx, project.OrganizationID, project.ID)
if err != nil {
return "", nil, err
}
ids := []string{}
for _, member := range members {
ids = append(ids, member.UserID)
}
users, e := server.store.ListProjectMemberUsers(ctx, project.OrganizationID, ids)
if e != nil {
return "", nil, e
}
directory := map[string]domain.UserRecord{}
for _, user := range users {
directory[user.ID] = user
}
for i := range members {
user, ok := directory[members[i].UserID]
members[i].Roles = nil
if ok && user.Status != domain.UserStatusDisabled && user.SupplierID == members[i].SupplierID {
members[i].Roles = domain.AccountProductionRoles(user)
}
}
requested = strings.TrimSpace(requested)
if requested != "" {
supplier, supplierErr := server.store.GetSupplier(ctx, requested)
if supplierErr != nil {
return "", nil, supplierErr
}
if supplier == nil || normalizedOrganizationID(supplier.OrganizationID) != normalizedOrganizationID(project.OrganizationID) || !strings.EqualFold(strings.TrimSpace(supplier.Status), "active") {
return "", []validationIssue{{Field: "supplierId", Message: "an active supplier in the same organization is required"}}, nil
}
if !supplierHasProductionHumanRoles(members, requested) {
return "", []validationIssue{{Field: "supplierId", Message: "supplier project members must cover annotator, quality reviewer and acceptance reviewer"}}, nil
}
return requested, nil, nil
}
candidates := map[string]struct{}{}
for _, member := range members {
supplierID := strings.TrimSpace(member.SupplierID)
if supplierID != "" && supplierHasProductionHumanRoles(members, supplierID) {
candidates[supplierID] = struct{}{}
}
}
if len(candidates) != 1 {
return "", []validationIssue{{Field: "supplierId", Message: "select exactly one supplier whose project members cover all three production roles"}}, nil
}
for supplierID := range candidates {
return server.resolveProjectWorkflowSupplier(ctx, project, release, supplierID)
}
return "", []validationIssue{{Field: "supplierId", Message: "supplier is required"}}, nil
}
func templateSnapshotFromWorkflow(item domain.WorkflowRecord) domain.TemplateRecord {
return domain.TemplateRecord{ID: "legacy-workflow:" + item.ID, OrganizationID: item.OrganizationID, Name: item.Name, Description: item.Description, Type: item.Type, Kind: item.Kind, ExecutionScope: item.ExecutionScope, ScanConfig: item.ScanConfig, Hyperparams: item.Hyperparams, MaxConcurrentRuns: item.MaxConcurrentRuns, NodeTimeoutSeconds: item.NodeTimeoutSeconds, RunTimeoutSeconds: item.RunTimeoutSeconds, MaxRetryAttempts: item.MaxRetryAttempts, RetryBackoffSeconds: item.RetryBackoffSeconds, Schedule: item.Schedule, Nodes: item.Nodes, Edges: item.Edges}
}
func (server *server) migrateLegacyProjectWorkflowInstances(ctx context.Context, project *domain.ProjectRecord) error {
if project == nil {
return nil
}
workflows, err := server.store.ListWorkflowsByProject(ctx, project.ID)
if err != nil {
return err
}
instances, err := server.store.ListProjectWorkflowInstances(ctx, project.OrganizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: project.ID})
if err != nil {
return err
}
byWorkflow := map[string]struct{}{}
for _, instance := range instances {
byWorkflow[instance.WorkflowID] = struct{}{}
}
for _, workflow := range workflows {
if _, exists := byWorkflow[workflow.ID]; exists {
continue
}
template := templateSnapshotFromWorkflow(workflow)
capabilities, requiredPlugins := workflowReleaseRequirements(template)
now := nowISO()
release := domain.WorkflowReleaseRecord{ID: "workflow-release-legacy-" + workflow.ID, OrganizationID: project.OrganizationID, TemplateID: template.ID, Version: 1, Name: workflow.Name, Description: workflow.Description, Type: workflow.Type, Kind: workflow.Kind, ExecutionScope: workflow.ExecutionScope, ScanConfig: workflow.ScanConfig, Hyperparams: workflow.Hyperparams, MaxConcurrentRuns: workflow.MaxConcurrentRuns, NodeTimeoutSeconds: workflow.NodeTimeoutSeconds, RunTimeoutSeconds: workflow.RunTimeoutSeconds, MaxRetryAttempts: workflow.MaxRetryAttempts, RetryBackoffSeconds: workflow.RetryBackoffSeconds, Schedule: workflow.Schedule, Nodes: workflow.Nodes, Edges: workflow.Edges, Capabilities: capabilities, RequiredPluginIDs: requiredPlugins, ContentDigest: workflowReleaseDigest(template), ReleaseNotes: "Historical workflow migration", PublishedByUserID: "system-migration", PublishedAt: now, CreatedAt: now}
if err := server.store.UpsertWorkflowRelease(ctx, release); err != nil {
return err
}
instance := domain.ProjectWorkflowInstanceRecord{ID: "project-workflow-instance-legacy-" + workflow.ID, OrganizationID: project.OrganizationID, ProjectID: project.ID, ReleaseID: release.ID, ReleaseVersion: 1, SourceTemplateID: release.TemplateID, WorkflowID: workflow.ID, Status: domain.ProjectWorkflowInstanceActive, CreatedByUserID: "system-migration", CreatedAt: now, UpdatedAt: now}
if err := server.store.UpsertProjectWorkflowInstance(ctx, instance); err != nil {
return err
}
if project.WorkflowInstanceID == "" {
project.WorkflowInstanceID = instance.ID
project.UpdatedAt = now
}
}
if project.WorkflowInstanceID != "" {
return server.store.UpsertProject(ctx, *project)
}
return nil
}
func workflowReleaseDigest(item domain.TemplateRecord) string {
item.CreatedAt = ""
item.UpdatedAt = ""
payload, _ := json.Marshal(item)
digest := sha256.Sum256(payload)
return hex.EncodeToString(digest[:])
}
func workflowReleaseRequirements(item domain.TemplateRecord) ([]string, []string) {
workflow := domain.WorkflowRecord{ID: item.ID, Nodes: item.Nodes, Edges: item.Edges}
if !pluginregistry.RequiredByWorkflow(workflow, pluginregistry.AnnotationQAID) {
return nil, nil
}
return []string{"human_annotation", "human_quality_review", "human_acceptance"}, []string{pluginregistry.HumanLoopCoreID, pluginregistry.AnnotationQAID}
}
func (server *server) handleTemplateReleasesList(writer http.ResponseWriter, request *http.Request) {
template, err := server.store.GetTemplate(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if template == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Template not found"})
return
}
if !server.ensureTenantAccess(writer, request, template.OrganizationID, "Template") {
return
}
items, err := server.store.ListWorkflowReleases(request.Context(), template.OrganizationID, domain.WorkflowReleaseQuery{TemplateID: template.ID})
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if len(items) == 0 && len(template.Nodes) > 0 && len(validateWorkflowTopology(template.Nodes, template.Edges)) == 0 {
capabilities, requiredPlugins := workflowReleaseRequirements(*template)
now := nowISO()
release := domain.WorkflowReleaseRecord{ID: "workflow-release-legacy-template-" + template.ID, OrganizationID: template.OrganizationID, TemplateID: template.ID, Version: 1, Name: template.Name, Description: template.Description, Type: template.Type, Kind: template.Kind, ExecutionScope: template.ExecutionScope, ScanConfig: template.ScanConfig, Hyperparams: template.Hyperparams, MaxConcurrentRuns: template.MaxConcurrentRuns, NodeTimeoutSeconds: template.NodeTimeoutSeconds, RunTimeoutSeconds: template.RunTimeoutSeconds, MaxRetryAttempts: template.MaxRetryAttempts, RetryBackoffSeconds: template.RetryBackoffSeconds, Schedule: template.Schedule, WorkflowInputs: template.WorkflowInputs, ArtifactStorage: template.ArtifactStorage, Nodes: template.Nodes, Edges: template.Edges, Capabilities: capabilities, RequiredPluginIDs: requiredPlugins, ContentDigest: workflowReleaseDigest(*template), ReleaseNotes: "Historical template migration", PublishedByUserID: "system-migration", PublishedAt: now, CreatedAt: now}
if err := server.store.UpsertWorkflowRelease(request.Context(), release); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
items = []domain.WorkflowReleaseRecord{release}
}
for index := range items {
publicPool, err := server.releaseUsesFanyuSupplierPool(request.Context(), items[index])
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
items[index].UsesPublicSupplierPool = publicPool
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleTemplatePublish(writer http.ResponseWriter, request *http.Request) {
template, err := server.store.GetTemplate(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if template == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Template not found"})
return
}
if !server.ensureTenantAccess(writer, request, template.OrganizationID, "Template") {
return
}
if template.Type != domain.WorkflowTypeStreaming || template.ExecutionScope == domain.WorkflowExecutionScopeSandbox || domain.WorkflowScheduleEnabled(template.Schedule) {
renderValidationError(writer, validationIssue{Field: "type", Code: "continuous_capture_only", Message: "仅支持发布持续 Capture 正式处理模板"})
return
}
var payload workflowPublishRequest
if !decodeJSON(writer, request, &payload) {
return
}
if issues := validateWorkflowTopology(template.Nodes, template.Edges); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
if issues := server.validateWorkflowOperatorPublication(request.Context(), template.Nodes, template.ExecutionScope); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
capabilities, requiredPlugins := workflowReleaseRequirements(*template)
if workflowReleaseContainsString(requiredPlugins, pluginregistry.AnnotationQAID) {
enabled, pluginErr := server.annotationPluginEnabled(request.Context(), template.OrganizationID)
if pluginErr != nil {
renderError(writer, http.StatusInternalServerError, pluginErr)
return
}
if !enabled {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Annotation QA plugin is disabled", "code": "plugin_disabled"})
return
}
}
digest := workflowReleaseDigest(*template)
existing, err := server.store.ListWorkflowReleases(request.Context(), template.OrganizationID, domain.WorkflowReleaseQuery{TemplateID: template.ID})
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if len(existing) > 0 && existing[0].ContentDigest == digest {
renderJSON(writer, http.StatusOK, existing[0])
return
}
version := 1
if len(existing) > 0 {
version = existing[0].Version + 1
}
principal, _ := currentPrincipal(request)
now := nowISO()
release := domain.WorkflowReleaseRecord{
ID: domain.NewID("workflow-release"), OrganizationID: template.OrganizationID, TemplateID: template.ID, Version: version,
Name: template.Name, Description: template.Description, Type: template.Type, Kind: template.Kind,
ExecutionScope: template.ExecutionScope, ScanConfig: template.ScanConfig, Hyperparams: template.Hyperparams,
MaxConcurrentRuns: template.MaxConcurrentRuns, NodeTimeoutSeconds: template.NodeTimeoutSeconds,
RunTimeoutSeconds: template.RunTimeoutSeconds, MaxRetryAttempts: template.MaxRetryAttempts,
RetryBackoffSeconds: template.RetryBackoffSeconds, Schedule: template.Schedule, Nodes: template.Nodes, Edges: template.Edges,
WorkflowInputs: template.WorkflowInputs, ArtifactStorage: template.ArtifactStorage,
Capabilities: capabilities, RequiredPluginIDs: requiredPlugins, ContentDigest: digest,
ReleaseNotes: strings.TrimSpace(payload.ReleaseNotes), PublishedByUserID: principal.User.ID, PublishedAt: now, CreatedAt: now,
}
if err := server.store.UpsertWorkflowRelease(request.Context(), release); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, release)
}
func workflowReleaseContainsString(items []string, target string) bool {
for _, item := range items {
if item == target {
return true
}
}
return false
}
func (server *server) handleWorkflowReleaseGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetWorkflowRelease(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 release not found"})
return
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Workflow release") {
return
}
publicPool, err := server.releaseUsesFanyuSupplierPool(request.Context(), *item)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
item.UsesPublicSupplierPool = publicPool
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleProjectWorkflowInstancesList(writer http.ResponseWriter, request *http.Request) {
project, err := server.store.GetProject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if project == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Project not found"})
return
}
if !server.ensureTenantAccess(writer, request, project.OrganizationID, "Project") {
return
}
items, err := server.store.ListProjectWorkflowInstances(request.Context(), project.OrganizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: project.ID})
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleProjectWorkflowInstanceCreate(writer http.ResponseWriter, request *http.Request) {
project, err := server.store.GetProject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if project == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Project not found"})
return
}
if !server.ensureTenantAccess(writer, request, project.OrganizationID, "Project") {
return
}
var payload projectWorkflowInstanceRequest
if !decodeJSON(writer, request, &payload) {
return
}
release, err := server.store.GetWorkflowRelease(request.Context(), strings.TrimSpace(payload.ReleaseID))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if release == nil || normalizedOrganizationID(release.OrganizationID) != normalizedOrganizationID(project.OrganizationID) {
renderValidationError(writer, validationIssue{Field: "releaseId", Message: "published workflow release is required"})
return
}
if release.Type != domain.WorkflowTypeStreaming || release.ExecutionScope == domain.WorkflowExecutionScopeSandbox || domain.WorkflowScheduleEnabled(release.Schedule) {
renderValidationError(writer, validationIssue{Field: "releaseId", Code: "continuous_capture_only", Message: "仅支持引用持续 Capture 正式处理模板,历史单次模板只读"})
return
}
supplierID, supplierIssues, supplierErr := server.resolveProjectWorkflowSupplier(request.Context(), *project, *release, payload.SupplierID)
if supplierErr != nil {
renderError(writer, http.StatusInternalServerError, supplierErr)
return
}
if len(supplierIssues) > 0 {
renderValidationError(writer, supplierIssues[0])
return
}
for _, pluginID := range release.RequiredPluginIDs {
if pluginID != pluginregistry.AnnotationQAID {
continue
}
enabled, pluginErr := server.annotationPluginEnabled(request.Context(), project.OrganizationID)
if pluginErr != nil {
renderError(writer, http.StatusInternalServerError, pluginErr)
return
}
if !enabled {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Annotation QA plugin is disabled", "code": "plugin_disabled"})
return
}
}
instanceStorage := release.ArtifactStorage
if domain.InitialCaptureAutomation(release.Type, release.Schedule) != nil {
instanceStorage = nil
if issues := applyProjectWorkflowArtifactStorage(project, &instanceStorage); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
}
workflow, err := server.store.CreateWorkflow(request.Context(), domain.CreateWorkflowInput{
OrganizationID: project.OrganizationID, ProjectID: project.ID, Name: release.Name, Description: release.Description,
Type: release.Type, Kind: release.Kind, ExecutionScope: release.ExecutionScope, ScanConfig: release.ScanConfig,
CaptureAutomation: domain.InitialCaptureAutomation(release.Type, release.Schedule),
Hyperparams: release.Hyperparams, MaxConcurrentRuns: release.MaxConcurrentRuns, NodeTimeoutSeconds: release.NodeTimeoutSeconds,
RunTimeoutSeconds: release.RunTimeoutSeconds, MaxRetryAttempts: release.MaxRetryAttempts,
RetryBackoffSeconds: release.RetryBackoffSeconds, Schedule: release.Schedule, Nodes: bindAnnotationSupplier(release.Nodes, supplierID), Edges: release.Edges,
WorkflowInputs: release.WorkflowInputs, ArtifactStorage: instanceStorage,
})
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
// A project workflow instance is an immutable release binding, not a new
// editable draft. Persist that distinction on the backing workflow so the
// normal project workflow run endpoint keeps project/workgroup isolation.
workflow.DefinitionState = domain.WorkflowDefinitionStateReleased
workflow.DefinitionVersion = release.Version
workflow.DefinitionFamilyID = release.TemplateID
workflow.UpdatedAt = nowISO()
if err := server.store.UpsertWorkflow(request.Context(), *workflow); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
existing, err := server.store.ListProjectWorkflowInstances(request.Context(), project.OrganizationID, domain.ProjectWorkflowInstanceQuery{ProjectID: project.ID, Status: domain.ProjectWorkflowInstanceActive})
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
var supersedes string
for index := range existing {
existing[index].Status = domain.ProjectWorkflowInstanceSuperseded
existing[index].UpdatedAt = nowISO()
if supersedes == "" {
supersedes = existing[index].ID
}
if err := server.store.UpsertProjectWorkflowInstance(request.Context(), existing[index]); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
principal, _ := currentPrincipal(request)
now := nowISO()
instance := domain.ProjectWorkflowInstanceRecord{
ID: domain.NewID("project-workflow-instance"), OrganizationID: project.OrganizationID, ProjectID: project.ID,
ReleaseID: release.ID, ReleaseVersion: release.Version, SourceTemplateID: release.TemplateID, WorkflowID: workflow.ID,
SupplierID: supplierID,
Status: domain.ProjectWorkflowInstanceActive, SupersedesInstanceID: supersedes, CreatedByUserID: principal.User.ID,
CreatedAt: now, UpdatedAt: now,
}
if err := server.store.UpsertProjectWorkflowInstance(request.Context(), instance); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
project.WorkflowInstanceID = instance.ID
project.UpdatedAt = now
if err := server.store.UpsertProject(request.Context(), *project); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, map[string]any{"instance": instance, "workflow": workflow})
}
// ----------------------------------------------------------------------------
// Production Run Request & Security Gate Types
// ----------------------------------------------------------------------------
const maxInlinePayloadBytes = 65536
type productionRunRequest struct {
Trigger domain.RunTrigger `json:"trigger"`
Inputs map[string]domain.ArtifactPayload `json:"inputs,omitempty"`
NodeOverrides map[string]any `json:"nodeOverrides,omitempty"`
DebugTarget any `json:"debugTarget,omitempty"`
Nodes any `json:"nodes,omitempty"`
Edges any `json:"edges,omitempty"`
}
func renderProductionSecurityGateError(writer http.ResponseWriter, code string, message string, issues ...validationIssue) {
resp := map[string]any{
"error": message,
"code": code,
}
if len(issues) > 0 {
resp["issues"] = issues
}
renderJSON(writer, http.StatusUnprocessableEntity, resp)
}
func workflowSnapshotFromRelease(release domain.WorkflowReleaseRecord) domain.WorkflowRecord {
return domain.WorkflowRecord{
ID: release.ID,
OrganizationID: release.OrganizationID,
Name: release.Name,
Description: release.Description,
Type: release.Type,
Kind: release.Kind,
ExecutionScope: release.ExecutionScope,
ScanConfig: release.ScanConfig,
Hyperparams: release.Hyperparams,
MaxConcurrentRuns: release.MaxConcurrentRuns,
NodeTimeoutSeconds: release.NodeTimeoutSeconds,
RunTimeoutSeconds: release.RunTimeoutSeconds,
MaxRetryAttempts: release.MaxRetryAttempts,
RetryBackoffSeconds: release.RetryBackoffSeconds,
Schedule: release.Schedule,
DefinitionState: domain.WorkflowDefinitionStateReleased,
DefinitionVersion: release.Version,
DefinitionFamilyID: release.TemplateID,
WorkflowInputs: release.WorkflowInputs,
ArtifactStorage: release.ArtifactStorage,
Nodes: release.Nodes,
Edges: release.Edges,
CreatedAt: release.CreatedAt,
UpdatedAt: release.PublishedAt,
}
}
// ----------------------------------------------------------------------------
// POST /api/workflow-releases/{id}/runs Handler
// ----------------------------------------------------------------------------