package api import ( "context" "errors" "fmt" "net/http" "strconv" "strings" "time" "droboticflow/internal/domain" "droboticflow/internal/store" "droboticflow/internal/workforcestats" ) // Both reports and their drill-down use the same scope. Query parameters only // narrow this scope; a member cannot request another supplier's records. func (s *server) workforceQuery(r *http.Request, workload bool) (workforcestats.Query, error) { p, _ := currentPrincipal(r) q, _ := workforcePrincipalQuery(p) v := r.URL.Query() var err error q.From, q.To, err = dashboardWorkforceRange(time.Now(), v.Get("from"), v.Get("to")) if err != nil { return q, err } q.ProjectID = strings.TrimSpace(v.Get("projectId")) q.RelativeFrom = strings.TrimSpace(v.Get("from")) == "" q.RelativeTo = strings.TrimSpace(v.Get("to")) == "" q.GroupTemplate = workload q.Mode = domain.RunMode(v.Get("mode")) q.Role = strings.TrimSpace(v.Get("role")) q.GroupBy = strings.TrimSpace(v.Get("groupBy")) if q.GroupBy == "" { q.GroupBy = "member" } if q.GroupBy != "member" && q.GroupBy != "day" { return q, fmt.Errorf("不支持的工作记录分组") } if q.Role != "" && q.Role != string(domain.UserRoleAnnotator) && q.Role != string(domain.UserRoleQualityReviewer) && q.Role != string(domain.UserRoleAcceptanceReviewer) { return q, fmt.Errorf("不支持的工作角色") } if q.Mode != "" && q.Mode != domain.RunModeProduction && q.Mode != domain.RunModeDebug && q.Mode != domain.RunModeAll { return q, fmt.Errorf("不支持的统计模式") } if v.Has("userId") { user := strings.TrimSpace(v.Get("userId")) if q.MatchUser && q.UserID != user { q.AllowedProjects = map[string]bool{} } else { q.UserID, q.MatchUser = user, true } } if supplier := strings.TrimSpace(v.Get("supplierId")); supplier != "" { if q.SupplierID != "" && supplier != q.SupplierID { q.AllowedProjects = map[string]bool{} } else { q.SupplierID = supplier } } if v.Has("templateVersion") { n, parseErr := strconv.Atoi(v.Get("templateVersion")) if parseErr != nil || n < 0 { return q, fmt.Errorf("模板版本无效") } q.TemplateVersion = &n } if workload && p != nil && !annotationManager(p) { roles, err := s.annotationMembershipsForUser(r.Context(), s.requestOrganizationID(r), q.ProjectID, p.User.ID) if err != nil { return q, err } allowed := map[string]bool{} q.AllowedSuppliers = map[string]bool{} for _, role := range roles { if role.SupplierID != "" { q.AllowedSuppliers[role.SupplierID] = true } if (q.AllowedProjects == nil || q.AllowedProjects[role.ProjectID]) && s.projectVisibleToRequest(r, s.requestOrganizationID(r), role.ProjectID) { allowed[role.ProjectID] = true } } q.AllowedProjects = allowed } return q, nil } func (s *server) handleAnnotationWorkloadSummary(w http.ResponseWriter, r *http.Request) { q, err := s.workforceQuery(r, true) if err != nil { renderError(w, 400, err) return } q.GroupTemplate = true var report workforcestats.Report if prepared, ok := s.store.(interface { LoadWorkforceReport(context.Context, string, workforcestats.Query) (workforcestats.Report, error) }); ok { report, err = prepared.LoadWorkforceReport(r.Context(), s.requestOrganizationID(r), q) } else { var d workforcestats.Snapshot d, err = s.store.LoadWorkforceStats(r.Context(), s.requestOrganizationID(r), q) if err == nil { report = workforcestats.Build(d, q) } } if err != nil { if renderWorkforcePublicationPending(w, r, err) { return } renderError(w, 500, err) return } if report.WindowFrom != "" { q.From, _ = time.Parse(time.RFC3339Nano, report.WindowFrom) q.To, _ = time.Parse(time.RFC3339Nano, report.WindowTo) } items := make([]domain.AnnotationWorkloadAggregate, 0, len(report.Items)) for _, m := range report.Items { items = append(items, domain.AnnotationWorkloadAggregate{ WorkforceStatistics: m.WorkforceStatistics, UserID: m.UserID, UserName: m.UserName, Role: m.Role, SupplierID: m.SupplierID, SupplierName: m.SupplierName, TemplateVersion: m.TemplateVersion, AssignedCount: m.AssignedCount, SubmittedCount: m.SubmittedCount, ReworkCount: m.ReworkCount, QualityApproved: m.QualityApproved, QualityRejected: m.QualityRejected, AcceptanceApproved: m.AcceptanceApproved, AcceptanceRejected: m.AcceptanceRejected, OutputCount: m.OutputCount, DurationSeconds: m.DurationSeconds, }) } renderJSON(w, 200, domain.AnnotationWorkloadSummary{Items: items, Totals: report.Totals, EventCount: report.EventCount, From: q.From.Format(time.RFC3339Nano), To: q.To.Format(time.RFC3339Nano)}) } // handleDashboardWorkforce is the compact, on-demand work-record report used // by the dashboard. It keeps the existing workload endpoint compatible while // allowing the dashboard to defer member and daily data until expanded. func (s *server) handleDashboardWorkforce(w http.ResponseWriter, r *http.Request) { q, err := s.workforceQuery(r, false) if err != nil { renderError(w, http.StatusBadRequest, err) return } q.Details = false report, err := s.dashboardWorkforceReport(r.Context(), s.requestOrganizationID(r), q) if err != nil { if renderWorkforcePublicationPending(w, r, err) { return } renderError(w, http.StatusInternalServerError, err) return } if report.WindowFrom != "" { q.From, _ = time.Parse(time.RFC3339Nano, report.WindowFrom) q.To, _ = time.Parse(time.RFC3339Nano, report.WindowTo) } workforcestats.ApplyRates(&report.Totals) for i := range report.Items { workforcestats.ApplyRates(&report.Items[i]) } renderJSON(w, http.StatusOK, map[string]any{ "asOf": report.AsOf, "from": q.From.Format(time.RFC3339Nano), "to": q.To.Format(time.RFC3339Nano), "groupBy": q.GroupBy, "totals": report.Totals, "items": report.Items, "eventCount": report.EventCount, }) } func (s *server) handleWorkforceReturns(w http.ResponseWriter, r *http.Request) { q, err := s.workforceQuery(r, r.URL.Query().Get("surface") == "workload") if err != nil { renderError(w, 400, err) return } limit, offset := 20, 0 for name, dest := range map[string]*int{"limit": &limit, "offset": &offset} { if value := r.URL.Query().Get(name); value != "" { n, e := strconv.Atoi(value) if e != nil || n < 0 || (name == "limit" && (n < 1 || n > 50)) { renderError(w, 400, fmt.Errorf("分页参数无效")) return } *dest = n } } q.Details = true if paged, ok := s.store.(interface { LoadWorkforceReturnPage(context.Context, string, workforcestats.Query, int, int) ([]domain.WorkforceReturnDetail, int, error) }); ok { items, total, e := paged.LoadWorkforceReturnPage(r.Context(), s.requestOrganizationID(r), q, limit, offset) if e != nil { renderError(w, 500, e) return } renderJSON(w, 200, map[string]any{"items": items, "total": total, "from": q.From.Format(time.RFC3339Nano), "to": q.To.Format(time.RFC3339Nano)}) return } d, err := s.store.LoadWorkforceStats(r.Context(), s.requestOrganizationID(r), q) if err != nil { renderError(w, 500, err) return } items := workforcestats.Build(d, q).Details count := len(items) if offset > count { offset = count } end := offset + limit if end < offset || end > count { end = count } renderJSON(w, 200, map[string]any{"items": items[offset:end], "total": count, "from": q.From.Format(time.RFC3339Nano), "to": q.To.Format(time.RFC3339Nano)}) } func renderWorkforcePublicationPending(w http.ResponseWriter, r *http.Request, err error) bool { if !errors.Is(err, store.ErrWorkforcePublicationPending) { return false } w.Header().Set("Retry-After", "1") // Older clients must not decode a readiness envelope as an empty report. if !strings.Contains(r.Header.Get("Accept"), "application/vnd.droboticflow.prepared+json") { renderError(w, http.StatusServiceUnavailable, fmt.Errorf("看板正在准备,请稍后重试")) return true } renderJSON(w, http.StatusAccepted, map[string]any{"status": "building", "retryAfterMs": 1000}) return true }