forked from longtao.wu/droboticflow
329 lines
10 KiB
Go
329 lines
10 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/go-chi/chi/v5"
|
|
"net/http"
|
|
"slices"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
func priorityActive(v domain.AcceptancePriority, project string) bool {
|
|
expires, err := time.Parse(time.RFC3339, v.ExpiresAt)
|
|
return v.Enabled && err == nil && time.Now().Before(expires) && (project == "" || len(v.ProjectIDs) == 0 || slices.Contains(v.ProjectIDs, project))
|
|
}
|
|
|
|
// Request-local source resolution. Missing/conflicting historical evidence stays unknown;
|
|
// never join through current employees or write production ownership onto acceptance.
|
|
type acceptancePriorityResolver struct {
|
|
server *server
|
|
ctx context.Context
|
|
rules []domain.AcceptancePriority
|
|
suppliers map[string]string
|
|
}
|
|
|
|
func (s *server) newAcceptancePriorityResolver(ctx context.Context, org string) (*acceptancePriorityResolver, error) {
|
|
rules, err := s.store.ListAcceptancePriorities(ctx, org)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &acceptancePriorityResolver{server: s, ctx: ctx, rules: rules, suppliers: map[string]string{}}, nil
|
|
}
|
|
func (p *acceptancePriorityResolver) active(project string) bool {
|
|
for _, v := range p.rules {
|
|
if priorityActive(v, project) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
func (p *acceptancePriorityResolver) prime(items []domain.HumanItemRecord) error {
|
|
ids := []string{}
|
|
seen := map[string]bool{}
|
|
org := ""
|
|
for _, item := range items {
|
|
org = item.OrganizationID
|
|
if _, ok := p.suppliers[item.BatchID]; !ok && !seen[item.BatchID] {
|
|
ids = append(ids, item.BatchID)
|
|
seen[item.BatchID] = true
|
|
}
|
|
}
|
|
if len(ids) == 0 {
|
|
return nil
|
|
}
|
|
values, err := p.server.store.ResolveAcceptanceSourceSuppliers(p.ctx, org, ids)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, id := range ids {
|
|
p.suppliers[id] = values[id]
|
|
}
|
|
return nil
|
|
}
|
|
func (p *acceptancePriorityResolver) supplier(item domain.HumanItemRecord) (string, error) {
|
|
if err := p.prime([]domain.HumanItemRecord{item}); err != nil {
|
|
return "", err
|
|
}
|
|
return p.suppliers[item.BatchID], nil
|
|
}
|
|
func (p *acceptancePriorityResolver) matches(item domain.HumanItemRecord) (bool, error) {
|
|
if !p.active(item.ProjectID) {
|
|
return false, nil
|
|
}
|
|
supplier, err := p.supplier(item)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if supplier == "" {
|
|
return false, nil
|
|
}
|
|
for _, v := range p.rules {
|
|
if v.SupplierID == supplier && priorityActive(v, item.ProjectID) {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
func (s *server) handleAcceptancePriority(w http.ResponseWriter, r *http.Request) {
|
|
principal, ok := currentPrincipal(r)
|
|
if !ok || !isOrganizationAdmin(principal) {
|
|
renderJSON(w, 403, map[string]string{"error": "仅管理员可设置验收优先级"})
|
|
return
|
|
}
|
|
org := s.requestOrganizationID(r)
|
|
id := chi.URLParam(r, "supplierId")
|
|
supplier, err := s.store.GetSupplier(r.Context(), id)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return
|
|
}
|
|
if supplier == nil || supplier.OrganizationID != org {
|
|
renderJSON(w, 404, map[string]string{"error": "供应商不存在"})
|
|
return
|
|
}
|
|
resolver, err := s.newAcceptancePriorityResolver(r.Context(), org)
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return
|
|
}
|
|
value := domain.AcceptancePriority{OrganizationID: org, SupplierID: id, ProjectIDs: []string{}}
|
|
for _, v := range resolver.rules {
|
|
if v.SupplierID == id {
|
|
value = v
|
|
}
|
|
}
|
|
if r.Method == http.MethodPut {
|
|
var input struct {
|
|
Enabled bool `json:"enabled"`
|
|
ProjectIDs []string `json:"projectIds"`
|
|
ExpiresAt string `json:"expiresAt"`
|
|
Version int `json:"version"`
|
|
}
|
|
if !decodeJSON(w, r, &input) {
|
|
return
|
|
}
|
|
if input.Version < 0 || len(input.ProjectIDs) > 100 {
|
|
renderValidationError(w, validationIssue{Field: "priority", Message: "验收优先设置无效"})
|
|
return
|
|
}
|
|
if input.Enabled {
|
|
expiry, e := time.Parse(time.RFC3339, input.ExpiresAt)
|
|
if e != nil || !time.Now().Before(expiry) || supplier.Status != "active" {
|
|
renderValidationError(w, validationIssue{Field: "expiresAt", Message: "请选择未来的到期时间及有效供应商"})
|
|
return
|
|
}
|
|
input.ExpiresAt = expiry.UTC().Format(time.RFC3339)
|
|
for _, pid := range input.ProjectIDs {
|
|
project, e := s.store.GetProject(r.Context(), pid)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
if project == nil || project.OrganizationID != org || project.DeletionTaskID != "" || project.Status == domain.ProjectStatusArchived {
|
|
renderValidationError(w, validationIssue{Field: "projectIds", Message: "项目不可用"})
|
|
return
|
|
}
|
|
}
|
|
}
|
|
value.Enabled = input.Enabled
|
|
value.ProjectIDs = slices.Clone(input.ProjectIDs)
|
|
value.ExpiresAt = input.ExpiresAt
|
|
value.UpdatedBy = principal.User.ID
|
|
saved, e := s.store.SaveAcceptancePriority(r.Context(), value, input.Version)
|
|
if errors.Is(e, store.ErrAcceptancePriorityConflict) {
|
|
renderError(w, 409, e)
|
|
return
|
|
}
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
value = *saved
|
|
}
|
|
renderJSON(w, 200, map[string]any{"policy": value, "active": priorityActive(value, ""), "remainingCount": nil, "unresolvedCount": nil, "statisticsStatus": "not_requested"})
|
|
}
|
|
|
|
// Statistics are optional display data. Neither reading nor saving a policy
|
|
// waits for this work; no partial count is ever serialized as an exact zero.
|
|
const acceptancePriorityStatisticsBudget = 2 * time.Second
|
|
|
|
func (s *server) handleAcceptancePriorityStatistics(w http.ResponseWriter, r *http.Request) {
|
|
principal, ok := currentPrincipal(r)
|
|
if !ok || !isOrganizationAdmin(principal) {
|
|
renderJSON(w, 403, map[string]string{"error": "仅管理员可查看验收优先统计"})
|
|
return
|
|
}
|
|
expected, err := strconv.Atoi(r.URL.Query().Get("version"))
|
|
if err != nil || expected < 0 {
|
|
renderJSON(w, 400, map[string]string{"error": "统计版本无效"})
|
|
return
|
|
}
|
|
ctx, cancel := context.WithTimeout(r.Context(), acceptancePriorityStatisticsBudget)
|
|
defer cancel()
|
|
r = r.WithContext(ctx)
|
|
incomplete := func() {
|
|
renderJSON(w, 200, map[string]any{"status": "incomplete", "policyVersion": expected, "remainingCount": nil, "unresolvedCount": nil})
|
|
}
|
|
org := s.requestOrganizationID(r)
|
|
id := chi.URLParam(r, "supplierId")
|
|
supplier, err := s.store.GetSupplier(ctx, id)
|
|
if err != nil {
|
|
incomplete()
|
|
return
|
|
}
|
|
if supplier == nil || supplier.OrganizationID != org {
|
|
renderJSON(w, 404, map[string]string{"error": "供应商不存在"})
|
|
return
|
|
}
|
|
snapshot, err := s.store.ReadAcceptanceSnapshot(ctx, org)
|
|
if err != nil {
|
|
incomplete()
|
|
return
|
|
}
|
|
rules, err := s.store.ListAcceptancePriorities(ctx, org)
|
|
if err != nil {
|
|
incomplete()
|
|
return
|
|
}
|
|
var policy domain.AcceptancePriority
|
|
for _, rule := range rules {
|
|
if rule.SupplierID == id {
|
|
policy = rule
|
|
break
|
|
}
|
|
}
|
|
if policy.Version != expected {
|
|
incomplete()
|
|
return
|
|
}
|
|
if snapshot == nil {
|
|
renderJSON(w, 200, map[string]any{"status": "pending", "policyVersion": expected, "remainingCount": nil, "unresolvedCount": nil})
|
|
return
|
|
}
|
|
remaining, unresolved := 0, 0
|
|
for _, group := range snapshot.Counts {
|
|
if len(policy.ProjectIDs) > 0 && !slices.Contains(policy.ProjectIDs, group.ProjectID) {
|
|
continue
|
|
}
|
|
switch group.SupplierID {
|
|
case "":
|
|
unresolved += group.Count
|
|
case id:
|
|
remaining += group.Count
|
|
}
|
|
}
|
|
renderJSON(w, 200, map[string]any{"status": "completed", "policyVersion": expected, "remainingCount": remaining, "unresolvedCount": unresolved, "completedAt": snapshot.CompletedAt})
|
|
}
|
|
|
|
// Preserve the existing first-eligible-page random semantics inside each group.
|
|
// Search all pages for a legal priority group before returning the ordinary page.
|
|
func (s *server) handleAcceptanceClaimCandidates(w http.ResponseWriter, r *http.Request) {
|
|
principal, ok := currentPrincipal(r)
|
|
if !ok || principal.User.Role != domain.UserRoleAcceptanceReviewer {
|
|
renderJSON(w, 403, map[string]string{"error": "仅验收员可领取验收任务"})
|
|
return
|
|
}
|
|
resolver, err := s.newAcceptancePriorityResolver(r.Context(), s.requestOrganizationID(r))
|
|
if err != nil {
|
|
renderError(w, 500, err)
|
|
return
|
|
}
|
|
next := r.Clone(context.WithValue(r.Context(), humanPoolReadModeKey{}, humanPoolReadClaimCandidates))
|
|
url := *r.URL
|
|
next.URL = &url
|
|
q := url.Query()
|
|
q.Set("pluginId", "annotation-qa")
|
|
q.Set("pool", "available")
|
|
q.Set("stageIds", fanyuV5PrePackageAcceptanceStageID)
|
|
q.Del("stageId")
|
|
q.Set("limit", "200")
|
|
q.Del("cursor")
|
|
var fallback []domain.HumanItemRecord
|
|
seen := map[string]bool{}
|
|
for round := 0; round < 200; round++ {
|
|
next.URL.RawQuery = q.Encode()
|
|
page, _ := s.readHumanItemsList(w, next)
|
|
if page == nil {
|
|
return
|
|
}
|
|
if resolver.active(q.Get("projectId")) {
|
|
if e := resolver.prime(page.Items); e != nil {
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
}
|
|
ordinary, priority := []domain.HumanItemRecord{}, []domain.HumanItemRecord{}
|
|
for _, item := range page.Items {
|
|
if item.CanClaim == nil || !*item.CanClaim {
|
|
continue
|
|
}
|
|
ordinary = append(ordinary, item)
|
|
if resolver.active(item.ProjectID) {
|
|
matches, e := resolver.matches(item)
|
|
if e != nil {
|
|
renderError(w, 500, e)
|
|
return
|
|
}
|
|
if matches {
|
|
priority = append(priority, item)
|
|
}
|
|
}
|
|
}
|
|
if len(priority) > 0 {
|
|
renderJSON(w, 200, map[string]any{"items": anonymousAcceptanceCandidates(priority)})
|
|
return
|
|
}
|
|
if fallback == nil && len(ordinary) > 0 {
|
|
fallback = ordinary
|
|
}
|
|
if !resolver.active(q.Get("projectId")) && len(fallback) > 0 || !page.HasMore {
|
|
if fallback == nil {
|
|
fallback = []domain.HumanItemRecord{}
|
|
}
|
|
renderJSON(w, 200, map[string]any{"items": anonymousAcceptanceCandidates(fallback)})
|
|
return
|
|
}
|
|
if page.NextCursor == "" || seen[page.NextCursor] {
|
|
break
|
|
}
|
|
seen[page.NextCursor] = true
|
|
q.Set("cursor", page.NextCursor)
|
|
}
|
|
renderError(w, 503, fmt.Errorf("可领取任务加载未完成,请缩小项目范围后重试"))
|
|
}
|
|
|
|
// Never serialize raw candidate records: legacy records may carry production
|
|
// identities even though current three-role acceptance creation omits them.
|
|
func anonymousAcceptanceCandidates(items []domain.HumanItemRecord) []map[string]any {
|
|
out := make([]map[string]any, 0, len(items))
|
|
for _, item := range items {
|
|
out = append(out, map[string]any{"id": item.ID, "projectId": item.ProjectID, "version": item.Version, "reviewRound": item.ReviewRound, "currentStageId": item.CurrentStageID, "status": item.Status, "canClaim": item.CanClaim != nil && *item.CanClaim})
|
|
}
|
|
return out
|
|
}
|