droboticflow/internal/api/workforce_statistics.go
d-robotics fc7786190f
Some checks are pending
web-ci / checks (push) Waiting to run
web-ci / pool-search-mongo (push) Waiting to run
web-ci / work-availability (push) Blocked by required conditions
web-ci / query-serving (push) Blocked by required conditions
⚡ Publish query reports and coalesce task pool reads
2026-11-13 22:31:44 -08:00

229 lines
7.9 KiB
Go

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
}