droboticflow-new/internal/api/workflow_runtime_policy.go

201 lines
7.6 KiB
Go

package api
import (
"context"
"net/http"
"strings"
"time"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
)
func acceptancePolicyAt(policy *domain.WorkflowRuntimePolicyRecord, submittedAt string) (float64, int) {
if policy == nil {
return domain.DefaultAcceptanceSampleProbability, 0
}
at, err := time.Parse(time.RFC3339Nano, submittedAt)
if err != nil {
return policy.AcceptanceSampleProbability, policy.Revision
}
if updated, err := time.Parse(time.RFC3339Nano, policy.UpdatedAt); err == nil && !updated.After(at) {
return policy.AcceptanceSampleProbability, policy.Revision
}
probability, revision := domain.DefaultAcceptanceSampleProbability, 0
for _, entry := range policy.History {
updated, err := time.Parse(time.RFC3339Nano, entry.UpdatedAt)
if err == nil && !updated.After(at) && entry.Revision > revision {
probability, revision = entry.AcceptanceSampleProbability, entry.Revision
}
}
return probability, revision
}
func (server *server) freezeSubmissionAcceptancePolicy(ctx context.Context, item *domain.HumanItemRecord) error {
if item.AcceptanceSampleValue != nil && item.AcceptanceSampleProbability != nil {
return nil
}
policy, err := server.store.GetWorkflowRuntimePolicy(ctx, item.WorkflowID)
if err != nil {
return err
}
probability, revision := acceptancePolicyAt(policy, item.SubmittedAt)
if item.AcceptanceSampleProbability != nil {
probability, revision = *item.AcceptanceSampleProbability, item.AcceptancePolicyRevision
}
value := 0.0
if probability <= 0 {
value = 1
} else if probability < 1 {
value, err = secureCaptureSamplingValue()
if err != nil {
return err
}
}
item.AcceptanceSampleProbability, item.AcceptancePolicyRevision = &probability, revision
item.AcceptanceSampleValue = &value
return nil
}
type workflowRuntimePolicyPatch struct {
Revision *int `json:"revision"`
MaxConcurrentCaptureRuns *int `json:"maxConcurrentCaptureRuns"`
AcceptanceSampleProbability *float64 `json:"acceptanceSampleProbability"`
}
func defaultWorkflowRuntimePolicy(workflow domain.WorkflowRecord) domain.WorkflowRuntimePolicyRecord {
return domain.WorkflowRuntimePolicyRecord{
ID: "workflow-runtime-policy-" + workflow.ID,
OrganizationID: workflow.OrganizationID,
ProjectID: workflow.ProjectID,
WorkflowID: workflow.ID,
Revision: 0,
MaxConcurrentCaptureRuns: domain.DefaultMaxConcurrentCaptureRuns,
AcceptanceSampleProbability: domain.DefaultAcceptanceSampleProbability,
}
}
func (server *server) workflowRuntimePolicy(writer http.ResponseWriter, request *http.Request) (*domain.WorkflowRecord, *domain.WorkflowRuntimePolicyRecord, bool) {
workflow, err := server.store.GetWorkflow(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return nil, nil, false
}
if workflow == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Workflow not found"})
return nil, nil, false
}
if !server.ensureTenantAccess(writer, request, workflow.OrganizationID, "Workflow") {
return nil, nil, false
}
principal, _ := currentPrincipal(request)
if principal == nil || (!annotationManager(principal) && principal.User.Role != domain.UserRoleSupplierManager) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "administrator or supplier manager role is required"})
return nil, nil, false
}
if !server.ensureProjectVisibility(writer, request, workflow.OrganizationID, workflow.ProjectID) {
return nil, nil, false
}
policy, err := server.store.GetWorkflowRuntimePolicy(request.Context(), workflow.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return nil, nil, false
}
if policy == nil {
fallback := defaultWorkflowRuntimePolicy(*workflow)
policy = &fallback
}
return workflow, policy, true
}
func (server *server) handleWorkflowRuntimePolicyGet(writer http.ResponseWriter, request *http.Request) {
_, policy, ok := server.workflowRuntimePolicy(writer, request)
if !ok {
return
}
response := *policy
response.History = nil
renderJSON(writer, http.StatusOK, response)
}
func (server *server) handleWorkflowRuntimePolicyHistory(writer http.ResponseWriter, request *http.Request) {
_, policy, ok := server.workflowRuntimePolicy(writer, request)
if !ok {
return
}
renderJSON(writer, http.StatusOK, map[string]any{"workflowId": policy.WorkflowID, "revisions": policy.History})
}
func (server *server) handleWorkflowRuntimePolicyPatch(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
if !annotationManager(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "organization administrator role is required"})
return
}
workflow, current, ok := server.workflowRuntimePolicy(writer, request)
if !ok {
return
}
var payload workflowRuntimePolicyPatch
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Revision != nil && *payload.Revision != current.Revision {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "运行设置已被其他管理员修改,请重新加载后再保存", "code": "runtime_policy_version_conflict"})
return
}
if payload.MaxConcurrentCaptureRuns == nil && payload.AcceptanceSampleProbability == nil {
renderValidationError(writer, validationIssue{Field: "runtimePolicy", Message: "至少修改一项运行策略"})
return
}
next := *current
if payload.MaxConcurrentCaptureRuns != nil {
if *payload.MaxConcurrentCaptureRuns <= 0 {
renderValidationError(writer, validationIssue{Field: "maxConcurrentCaptureRuns", Message: "Capture 并发数必须是正整数"})
return
}
next.MaxConcurrentCaptureRuns = *payload.MaxConcurrentCaptureRuns
}
if payload.AcceptanceSampleProbability != nil {
if *payload.AcceptanceSampleProbability < 0 || *payload.AcceptanceSampleProbability > 1 {
renderValidationError(writer, validationIssue{Field: "acceptanceSampleProbability", Message: "最终验收抽样概率必须在 0 到 1 之间"})
return
}
next.AcceptanceSampleProbability = *payload.AcceptanceSampleProbability
}
actorID := "system"
if principal != nil && strings.TrimSpace(principal.User.ID) != "" {
actorID = principal.User.ID
}
now := nowISO()
next.ID = "workflow-runtime-policy-" + workflow.ID
next.OrganizationID = workflow.OrganizationID
next.ProjectID = workflow.ProjectID
next.WorkflowID = workflow.ID
next.Revision = current.Revision + 1
next.UpdatedByUserID = actorID
next.UpdatedAt = now
next.History = append(append([]domain.WorkflowRuntimePolicyRevision(nil), current.History...), domain.WorkflowRuntimePolicyRevision{
PreviousAcceptanceSampleProbability: &current.AcceptanceSampleProbability,
UpdatedByUserName: principal.User.Name,
Revision: next.Revision, MaxConcurrentCaptureRuns: next.MaxConcurrentCaptureRuns,
AcceptanceSampleProbability: next.AcceptanceSampleProbability,
UpdatedByUserID: actorID, UpdatedAt: now,
})
if len(next.History) > 100 {
next.History = append([]domain.WorkflowRuntimePolicyRevision(nil), next.History[len(next.History)-100:]...)
}
updated, err := server.store.UpdateWorkflowRuntimePolicyVersioned(request.Context(), next, current.Revision)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !updated {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "运行策略已被其他管理员修改,请刷新后重试", "code": "runtime_policy_version_conflict"})
return
}
next.History = nil
renderJSON(writer, http.StatusOK, next)
}