droboticflow/internal/api/annotation_operations.go
2026-08-17 20:44:16 +08:00

797 lines
33 KiB
Go

package api
import (
"context"
"fmt"
"math"
"net/http"
"sort"
"strconv"
"strings"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
)
func annotationManager(principal *authenticatedPrincipal) bool {
if principal == nil {
return false
}
switch principal.User.Role {
case domain.UserRoleAdmin, domain.UserRolePipelineEngineer, domain.UserRoleOperator:
return true
default:
return false
}
}
func annotationPrincipalUserID(principal *authenticatedPrincipal) string {
if principal == nil {
return ""
}
return principal.User.ID
}
func annotationRoleValid(role domain.AnnotationAssignmentRole) bool {
switch role {
case domain.AnnotationRoleAnnotator, domain.AnnotationRoleQualityReviewer, domain.AnnotationRoleAcceptanceReviewer:
return true
default:
return false
}
}
func annotationTaskStatusValid(status domain.AnnotationTaskStatus) bool {
switch status {
case domain.AnnotationTaskStatusPendingAnnotation, domain.AnnotationTaskStatusPendingQuality,
domain.AnnotationTaskStatusPendingAcceptance, domain.AnnotationTaskStatusRework,
domain.AnnotationTaskStatusAccepted, domain.AnnotationTaskStatusRejected:
return true
default:
return false
}
}
func (server *server) annotationMembershipsForUser(ctx context.Context, organizationID string, projectID string, userID string) ([]domain.ProjectAnnotationMembershipRecord, error) {
items, err := server.store.ListProjectAnnotationMemberships(ctx, organizationID, projectID)
if err != nil {
return nil, err
}
filtered := make([]domain.ProjectAnnotationMembershipRecord, 0)
for _, item := range items {
if item.UserID == userID {
filtered = append(filtered, item)
}
}
return filtered, nil
}
func membershipAllowsTask(memberships []domain.ProjectAnnotationMembershipRecord, task domain.AnnotationTaskRecord) bool {
for _, membership := range memberships {
if membership.ProjectID != task.ProjectID || membership.WorkgroupID != task.WorkgroupID {
continue
}
if membership.VendorID != "" && task.VendorID != "" && membership.VendorID != task.VendorID {
continue
}
return true
}
return false
}
func membershipHasRole(memberships []domain.ProjectAnnotationMembershipRecord, task domain.AnnotationTaskRecord, role domain.AnnotationAssignmentRole) bool {
for _, membership := range memberships {
if membership.AssignmentRole == role && membershipAllowsTask([]domain.ProjectAnnotationMembershipRecord{membership}, task) {
return true
}
}
return false
}
func (server *server) ensureAnnotationTaskAccess(writer http.ResponseWriter, request *http.Request, task domain.AnnotationTaskRecord) (*authenticatedPrincipal, []domain.ProjectAnnotationMembershipRecord, bool) {
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
renderJSON(writer, http.StatusUnauthorized, map[string]string{"error": "login is required"})
return nil, nil, false
}
if !server.ensureTenantAccess(writer, request, task.OrganizationID, "Annotation task") {
return nil, nil, false
}
if annotationManager(principal) {
return principal, nil, true
}
memberships, err := server.annotationMembershipsForUser(request.Context(), task.OrganizationID, task.ProjectID, principal.User.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return nil, nil, false
}
if !membershipAllowsTask(memberships, task) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "annotation workgroup access is required"})
return nil, nil, false
}
return principal, memberships, true
}
type annotationWorkgroupInput struct {
Name string `json:"name"`
VendorID string `json:"vendorId"`
Description string `json:"description,omitempty"`
}
func (server *server) handleAnnotationWorkgroupsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListAnnotationWorkgroups(request.Context(), server.requestOrganizationID(request))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
if !annotationManager(principal) && principal != nil {
memberships, loadErr := server.annotationMembershipsForUser(request.Context(), server.requestOrganizationID(request), "", principal.User.ID)
if loadErr != nil {
renderError(writer, http.StatusInternalServerError, loadErr)
return
}
allowed := map[string]struct{}{}
for _, membership := range memberships {
allowed[membership.WorkgroupID] = struct{}{}
}
filtered := items[:0]
for _, item := range items {
if _, ok := allowed[item.ID]; ok {
filtered = append(filtered, item)
}
}
items = filtered
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleAnnotationWorkgroupCreate(writer http.ResponseWriter, request *http.Request) {
var payload annotationWorkgroupInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.Name = strings.TrimSpace(payload.Name)
payload.VendorID = strings.TrimSpace(payload.VendorID)
if payload.Name == "" || payload.VendorID == "" {
renderValidationError(writer,
validationIssue{Field: "name", Message: "name is required"},
validationIssue{Field: "vendorId", Message: "vendorId is required"},
)
return
}
item := domain.AnnotationWorkgroupRecord{
ID: domain.NewID("annotation-workgroup"),
OrganizationID: server.requestOrganizationID(request),
Name: payload.Name,
VendorID: payload.VendorID,
Description: strings.TrimSpace(payload.Description),
Status: "active",
CreatedAt: nowISO(),
}
if err := server.store.UpsertAnnotationWorkgroup(request.Context(), item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
saved, err := server.store.GetAnnotationWorkgroup(request.Context(), item.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, saved)
}
type annotationMembershipInput struct {
ProjectID string `json:"projectId"`
UserID string `json:"userId"`
WorkgroupID string `json:"workgroupId"`
AssignmentRole domain.AnnotationAssignmentRole `json:"assignmentRole"`
}
func (server *server) handleAnnotationMembershipsList(writer http.ResponseWriter, request *http.Request) {
projectID := strings.TrimSpace(request.URL.Query().Get("projectId"))
items, err := server.store.ListProjectAnnotationMemberships(request.Context(), server.requestOrganizationID(request), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
if !annotationManager(principal) && principal != nil {
filtered := items[:0]
for _, item := range items {
if item.UserID == principal.User.ID {
filtered = append(filtered, item)
}
}
items = filtered
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleAnnotationMembershipCreate(writer http.ResponseWriter, request *http.Request) {
var payload annotationMembershipInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.ProjectID = strings.TrimSpace(payload.ProjectID)
payload.UserID = strings.TrimSpace(payload.UserID)
payload.WorkgroupID = strings.TrimSpace(payload.WorkgroupID)
if payload.ProjectID == "" || payload.UserID == "" || payload.WorkgroupID == "" || !annotationRoleValid(payload.AssignmentRole) {
renderValidationError(writer, validationIssue{Field: "membership", Message: "projectId, userId, workgroupId and a valid assignmentRole are required"})
return
}
project, err := server.store.GetProject(request.Context(), payload.ProjectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
user, userErr := server.store.GetUser(request.Context(), payload.UserID)
group, groupErr := server.store.GetAnnotationWorkgroup(request.Context(), payload.WorkgroupID)
if userErr != nil || groupErr != nil {
renderError(writer, http.StatusInternalServerError, fmt.Errorf("load membership references: user=%v workgroup=%v", userErr, groupErr))
return
}
organizationID := server.requestOrganizationID(request)
if project == nil || user == nil || group == nil || !annotationOrganizationEqual(project.OrganizationID, organizationID) || !annotationOrganizationEqual(user.OrganizationID, organizationID) || !annotationOrganizationEqual(group.OrganizationID, organizationID) {
renderValidationError(writer, validationIssue{Field: "membership", Message: "project, user and workgroup must exist in the current organization"})
return
}
item := domain.ProjectAnnotationMembershipRecord{
ID: domain.NewID("annotation-membership"),
OrganizationID: organizationID,
ProjectID: project.ID,
UserID: user.ID,
WorkgroupID: group.ID,
VendorID: group.VendorID,
AssignmentRole: payload.AssignmentRole,
CreatedAt: nowISO(),
}
if err := server.store.UpsertProjectAnnotationMembership(request.Context(), item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, item)
}
func annotationOrganizationEqual(left string, right string) bool {
return normalizedTenantID(left) == normalizedTenantID(right)
}
type annotationTemplateInput struct {
ProjectID string `json:"projectId"`
Name string `json:"name"`
Version int `json:"version"`
Labels []domain.SemanticLabelDefinition `json:"labels"`
Phrases []string `json:"phrases,omitempty"`
Prelabel domain.AnnotationPrelabelSettings `json:"prelabel"`
}
func validateAnnotationLabels(labels []domain.SemanticLabelDefinition) []validationIssue {
issues := make([]validationIssue, 0)
seenIDs := map[string]struct{}{}
seenNames := map[string]struct{}{}
for index := range labels {
labels[index].ID = strings.TrimSpace(labels[index].ID)
labels[index].Name = strings.TrimSpace(labels[index].Name)
if labels[index].ID == "" || labels[index].Name == "" {
issues = append(issues, validationIssue{Field: fmt.Sprintf("labels.%d", index), Message: "id and name are required"})
continue
}
idKey := strings.ToLower(labels[index].ID)
nameKey := strings.ToLower(labels[index].Name)
if _, ok := seenIDs[idKey]; ok {
issues = append(issues, validationIssue{Field: fmt.Sprintf("labels.%d.id", index), Message: "label id must be unique"})
}
if _, ok := seenNames[nameKey]; ok {
issues = append(issues, validationIssue{Field: fmt.Sprintf("labels.%d.name", index), Message: "label name must be unique"})
}
seenIDs[idKey] = struct{}{}
seenNames[nameKey] = struct{}{}
}
return issues
}
func (server *server) handleAnnotationTemplatesList(writer http.ResponseWriter, request *http.Request) {
projectID := strings.TrimSpace(request.URL.Query().Get("projectId"))
items, err := server.store.ListAnnotationTemplates(request.Context(), server.requestOrganizationID(request), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
if !annotationManager(principal) && principal != nil {
memberships, loadErr := server.annotationMembershipsForUser(request.Context(), server.requestOrganizationID(request), projectID, principal.User.ID)
if loadErr != nil {
renderError(writer, http.StatusInternalServerError, loadErr)
return
}
projects := map[string]struct{}{}
for _, membership := range memberships {
projects[membership.ProjectID] = struct{}{}
}
filtered := items[:0]
for _, item := range items {
if _, ok := projects[item.ProjectID]; ok {
filtered = append(filtered, item)
}
}
items = filtered
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleAnnotationTemplateCreate(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
var payload annotationTemplateInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.ProjectID = strings.TrimSpace(payload.ProjectID)
payload.Name = strings.TrimSpace(payload.Name)
issues := validateAnnotationLabels(payload.Labels)
if payload.ProjectID == "" {
issues = append(issues, validationIssue{Field: "projectId", Message: "projectId is required"})
}
if payload.Name == "" {
issues = append(issues, validationIssue{Field: "name", Message: "name is required"})
}
if payload.Version <= 0 {
issues = append(issues, validationIssue{Field: "version", Message: "version must be positive"})
}
if payload.Prelabel.MinimumConfidence < 0 || payload.Prelabel.MinimumConfidence > 1 || math.IsNaN(payload.Prelabel.MinimumConfidence) {
issues = append(issues, validationIssue{Field: "prelabel.minimumConfidence", Message: "minimumConfidence must be between 0 and 1"})
}
if len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
project, err := server.store.GetProject(request.Context(), payload.ProjectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if project == nil || !server.filterByTenant(request, project.OrganizationID) {
renderValidationError(writer, validationIssue{Field: "projectId", Message: "project not found"})
return
}
item := domain.AnnotationTemplateRecord{
ID: domain.NewID("annotation-template"),
OrganizationID: project.OrganizationID,
ProjectID: project.ID,
Name: payload.Name,
Version: payload.Version,
Status: domain.AnnotationTemplateDraft,
Labels: payload.Labels,
Phrases: payload.Phrases,
Prelabel: payload.Prelabel,
CreatedByUserID: annotationPrincipalUserID(principal),
CreatedAt: nowISO(),
}
if err := server.store.UpsertAnnotationTemplate(request.Context(), item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
saved, err := server.store.GetAnnotationTemplate(request.Context(), item.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusCreated, saved)
}
func (server *server) handleAnnotationTemplatePublish(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetAnnotationTemplate(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil || !server.ensureTenantAccess(writer, request, item.OrganizationID, "Annotation template") {
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Annotation template not found"})
}
return
}
principal, _ := currentPrincipal(request)
item.Status = domain.AnnotationTemplatePublished
item.PublishedByUserID = annotationPrincipalUserID(principal)
item.PublishedAt = nowISO()
if err := server.store.UpsertAnnotationTemplate(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
type annotationTaskInput struct {
ProjectID string `json:"projectId"`
WorkflowID string `json:"workflowId,omitempty"`
RunID string `json:"runId,omitempty"`
ArtifactID string `json:"artifactId,omitempty"`
SourceVideo string `json:"sourceVideo"`
ClipStart float64 `json:"clipStart"`
ClipEnd float64 `json:"clipEnd"`
TemplateID string `json:"templateId"`
WorkgroupID string `json:"workgroupId"`
AssignedUserID string `json:"assignedUserId,omitempty"`
}
func (server *server) handleAnnotationTasksList(writer http.ResponseWriter, request *http.Request) {
projectID := strings.TrimSpace(request.URL.Query().Get("projectId"))
status := domain.AnnotationTaskStatus(strings.TrimSpace(request.URL.Query().Get("status")))
workgroupID := strings.TrimSpace(request.URL.Query().Get("workgroupId"))
vendorID := strings.TrimSpace(request.URL.Query().Get("vendorId"))
items, err := server.store.ListAnnotationTasks(request.Context(), server.requestOrganizationID(request), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
var memberships []domain.ProjectAnnotationMembershipRecord
if !annotationManager(principal) && principal != nil {
memberships, err = server.annotationMembershipsForUser(request.Context(), server.requestOrganizationID(request), projectID, principal.User.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
filtered := make([]domain.AnnotationTaskRecord, 0, len(items))
for _, item := range items {
if status != "" && item.Status != status {
continue
}
if workgroupID != "" && item.WorkgroupID != workgroupID {
continue
}
if vendorID != "" && item.VendorID != vendorID {
continue
}
if !annotationManager(principal) && !membershipAllowsTask(memberships, item) {
continue
}
filtered = append(filtered, item)
}
renderJSON(writer, http.StatusOK, map[string]any{"items": filtered})
}
func (server *server) handleAnnotationTaskGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetAnnotationTask(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": "Annotation task not found"})
return
}
if _, _, ok := server.ensureAnnotationTaskAccess(writer, request, *item); !ok {
return
}
revisions, revisionsErr := server.store.ListAnnotationRevisions(request.Context(), item.OrganizationID, item.ID)
reviews, reviewsErr := server.store.ListAnnotationReviews(request.Context(), item.OrganizationID, item.ID)
if revisionsErr != nil || reviewsErr != nil {
renderError(writer, http.StatusInternalServerError, fmt.Errorf("load annotation task history: revisions=%v reviews=%v", revisionsErr, reviewsErr))
return
}
renderJSON(writer, http.StatusOK, map[string]any{"task": item, "revisions": revisions, "reviews": reviews})
}
func (server *server) handleAnnotationTaskCreate(writer http.ResponseWriter, request *http.Request) {
var payload annotationTaskInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.ProjectID = strings.TrimSpace(payload.ProjectID)
payload.SourceVideo = strings.TrimSpace(payload.SourceVideo)
payload.TemplateID = strings.TrimSpace(payload.TemplateID)
payload.WorkgroupID = strings.TrimSpace(payload.WorkgroupID)
if payload.ProjectID == "" || payload.SourceVideo == "" || payload.TemplateID == "" || payload.WorkgroupID == "" || payload.ClipStart < 0 || payload.ClipEnd <= payload.ClipStart {
renderValidationError(writer, validationIssue{Field: "task", Message: "projectId, sourceVideo, templateId, workgroupId and a valid clip range are required"})
return
}
project, projectErr := server.store.GetProject(request.Context(), payload.ProjectID)
template, templateErr := server.store.GetAnnotationTemplate(request.Context(), payload.TemplateID)
group, groupErr := server.store.GetAnnotationWorkgroup(request.Context(), payload.WorkgroupID)
if projectErr != nil || templateErr != nil || groupErr != nil {
renderError(writer, http.StatusInternalServerError, fmt.Errorf("load annotation task references: project=%v template=%v workgroup=%v", projectErr, templateErr, groupErr))
return
}
if project == nil || template == nil || group == nil || template.ProjectID != project.ID || !annotationOrganizationEqual(project.OrganizationID, template.OrganizationID) || !annotationOrganizationEqual(project.OrganizationID, group.OrganizationID) {
renderValidationError(writer, validationIssue{Field: "task", Message: "project, template and workgroup are incompatible"})
return
}
if template.Status != domain.AnnotationTemplatePublished {
renderValidationError(writer, validationIssue{Field: "templateId", Message: "template must be published before task assignment"})
return
}
item := domain.AnnotationTaskRecord{
ID: domain.NewID("annotation-task"),
OrganizationID: project.OrganizationID,
ProjectID: project.ID,
WorkflowID: strings.TrimSpace(payload.WorkflowID),
RunID: strings.TrimSpace(payload.RunID),
ArtifactID: strings.TrimSpace(payload.ArtifactID),
SourceVideo: payload.SourceVideo,
ClipStart: payload.ClipStart,
ClipEnd: payload.ClipEnd,
TemplateID: template.ID,
TemplateVersion: template.Version,
WorkgroupID: group.ID,
VendorID: group.VendorID,
AssignedUserID: strings.TrimSpace(payload.AssignedUserID),
Status: domain.AnnotationTaskStatusPendingAnnotation,
CreatedAt: nowISO(),
}
if item.AssignedUserID != "" {
memberships, membershipErr := server.annotationMembershipsForUser(request.Context(), project.OrganizationID, project.ID, item.AssignedUserID)
if membershipErr != nil {
renderError(writer, http.StatusInternalServerError, membershipErr)
return
}
if !membershipHasRole(memberships, item, domain.AnnotationRoleAnnotator) {
renderValidationError(writer, validationIssue{Field: "assignedUserId", Message: "assigned user must be an annotator in the selected workgroup"})
return
}
}
if err := server.store.UpsertAnnotationTask(request.Context(), item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
_ = server.store.UpsertAnnotationWorklogEvent(request.Context(), domain.AnnotationWorklogEventRecord{
ID: domain.NewID("annotation-worklog"), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID,
TaskID: item.ID, UserID: annotationPrincipalUserID(principal), WorkgroupID: item.WorkgroupID, VendorID: item.VendorID,
EventType: "assigned", TemplateVersion: item.TemplateVersion, OutputDelta: 0, CreatedAt: nowISO(),
})
renderJSON(writer, http.StatusCreated, item)
}
type annotationRevisionInput struct {
Segments []domain.AnnotationSegment `json:"segments"`
ChangeReason string `json:"changeReason,omitempty"`
DurationSeconds int64 `json:"durationSeconds,omitempty"`
}
func validateAnnotationSegments(segments []domain.AnnotationSegment, task domain.AnnotationTaskRecord) []validationIssue {
issues := make([]validationIssue, 0)
sorted := append([]domain.AnnotationSegment(nil), segments...)
sort.Slice(sorted, func(left int, right int) bool { return sorted[left].Start < sorted[right].Start })
for index, segment := range sorted {
if strings.TrimSpace(segment.LabelID) == "" || strings.TrimSpace(segment.Label) == "" {
issues = append(issues, validationIssue{Field: fmt.Sprintf("segments.%d", index), Message: "labelId and label are required"})
}
if segment.Start < task.ClipStart || segment.End > task.ClipEnd || segment.End <= segment.Start || math.IsNaN(segment.Start) || math.IsNaN(segment.End) {
issues = append(issues, validationIssue{Field: fmt.Sprintf("segments.%d", index), Message: "segment must be finite and inside the clip range"})
}
if segment.Confidence < 0 || segment.Confidence > 1 || math.IsNaN(segment.Confidence) {
issues = append(issues, validationIssue{Field: fmt.Sprintf("segments.%d.confidence", index), Message: "confidence must be between 0 and 1"})
}
if index > 0 && segment.Start < sorted[index-1].End {
issues = append(issues, validationIssue{Field: fmt.Sprintf("segments.%d", index), Message: "segments must not overlap"})
}
}
return issues
}
func (server *server) handleAnnotationRevisionCreate(writer http.ResponseWriter, request *http.Request) {
task, err := server.store.GetAnnotationTask(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if task == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Annotation task not found"})
return
}
principal, memberships, ok := server.ensureAnnotationTaskAccess(writer, request, *task)
if !ok {
return
}
if !annotationManager(principal) && !membershipHasRole(memberships, *task, domain.AnnotationRoleAnnotator) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "annotator assignment is required"})
return
}
if task.AssignedUserID != "" && task.AssignedUserID != principal.User.ID && !annotationManager(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "task is assigned to another annotator"})
return
}
var payload annotationRevisionInput
if !decodeJSON(writer, request, &payload) {
return
}
if issues := validateAnnotationSegments(payload.Segments, *task); len(issues) > 0 {
renderValidationError(writer, issues...)
return
}
isRework := task.CurrentRevision > 0 || task.Status == domain.AnnotationTaskStatusRework
revisionNumber := task.CurrentRevision + 1
revision := domain.AnnotationRevisionRecord{
ID: domain.NewID("annotation-revision"), OrganizationID: task.OrganizationID, TaskID: task.ID,
Revision: revisionNumber, TemplateVersion: task.TemplateVersion, Segments: payload.Segments,
AuthorUserID: principal.User.ID, ChangeReason: strings.TrimSpace(payload.ChangeReason),
IsRework: isRework, CountsAsOutput: !isRework, DurationSeconds: payload.DurationSeconds, CreatedAt: nowISO(),
}
if err := server.store.UpsertAnnotationRevision(request.Context(), revision); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
task.CurrentRevision = revisionNumber
task.Status = domain.AnnotationTaskStatusPendingQuality
task.AssignedUserID = principal.User.ID
if err := server.store.UpsertAnnotationTask(request.Context(), *task); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
eventType := "annotation_submitted"
if isRework {
eventType = "rework_submitted"
}
outputDelta := int64(0)
if revision.CountsAsOutput {
outputDelta = 1
}
_ = server.store.UpsertAnnotationWorklogEvent(request.Context(), domain.AnnotationWorklogEventRecord{
ID: domain.NewID("annotation-worklog"), OrganizationID: task.OrganizationID, ProjectID: task.ProjectID,
TaskID: task.ID, UserID: principal.User.ID, WorkgroupID: task.WorkgroupID, VendorID: task.VendorID,
EventType: eventType, Revision: revisionNumber, TemplateVersion: task.TemplateVersion,
DurationSeconds: payload.DurationSeconds, OutputDelta: outputDelta, CreatedAt: nowISO(),
})
renderJSON(writer, http.StatusCreated, map[string]any{"task": task, "revision": revision})
}
type annotationReviewInput struct {
Stage domain.AnnotationReviewStage `json:"stage"`
Decision domain.AnnotationReviewDecision `json:"decision"`
Comment string `json:"comment,omitempty"`
DurationSeconds int64 `json:"durationSeconds,omitempty"`
}
func (server *server) handleAnnotationReviewCreate(writer http.ResponseWriter, request *http.Request) {
task, err := server.store.GetAnnotationTask(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if task == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Annotation task not found"})
return
}
principal, memberships, ok := server.ensureAnnotationTaskAccess(writer, request, *task)
if !ok {
return
}
var payload annotationReviewInput
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Stage != domain.AnnotationReviewStageQuality && payload.Stage != domain.AnnotationReviewStageAcceptance {
renderValidationError(writer, validationIssue{Field: "stage", Message: "stage must be quality or acceptance"})
return
}
if payload.Decision != domain.AnnotationReviewApproved && payload.Decision != domain.AnnotationReviewRejected {
renderValidationError(writer, validationIssue{Field: "decision", Message: "decision must be approved or rejected"})
return
}
requiredRole := domain.AnnotationRoleQualityReviewer
if payload.Stage == domain.AnnotationReviewStageAcceptance {
requiredRole = domain.AnnotationRoleAcceptanceReviewer
}
if !annotationManager(principal) && !membershipHasRole(memberships, *task, requiredRole) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": string(requiredRole) + " assignment is required"})
return
}
if task.CurrentRevision <= 0 {
renderValidationError(writer, validationIssue{Field: "revision", Message: "an annotation revision is required before review"})
return
}
existing, existingErr := server.store.ListAnnotationReviews(request.Context(), task.OrganizationID, task.ID)
if existingErr != nil {
renderError(writer, http.StatusInternalServerError, existingErr)
return
}
for _, review := range existing {
if review.Revision == task.CurrentRevision && review.Stage == payload.Stage {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "review already exists for this revision and stage"})
return
}
}
review := domain.AnnotationReviewRecord{
ID: domain.NewID("annotation-review"), OrganizationID: task.OrganizationID, TaskID: task.ID,
Revision: task.CurrentRevision, Stage: payload.Stage, Decision: payload.Decision,
ReviewerUserID: principal.User.ID, Comment: strings.TrimSpace(payload.Comment), CreatedAt: nowISO(),
}
if payload.Decision == domain.AnnotationReviewRejected {
review.NextRevision = task.CurrentRevision + 1
task.Status = domain.AnnotationTaskStatusRework
} else if payload.Stage == domain.AnnotationReviewStageQuality {
task.Status = domain.AnnotationTaskStatusPendingAcceptance
} else {
task.Status = domain.AnnotationTaskStatusAccepted
}
if err := server.store.UpsertAnnotationReview(request.Context(), review); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if err := server.store.UpsertAnnotationTask(request.Context(), *task); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
eventType := string(payload.Stage) + "_" + string(payload.Decision)
_ = server.store.UpsertAnnotationWorklogEvent(request.Context(), domain.AnnotationWorklogEventRecord{
ID: domain.NewID("annotation-worklog"), OrganizationID: task.OrganizationID, ProjectID: task.ProjectID,
TaskID: task.ID, UserID: principal.User.ID, WorkgroupID: task.WorkgroupID, VendorID: task.VendorID,
EventType: eventType, Revision: task.CurrentRevision, TemplateVersion: task.TemplateVersion,
DurationSeconds: payload.DurationSeconds, OutputDelta: 0, CreatedAt: nowISO(),
})
renderJSON(writer, http.StatusCreated, map[string]any{"task": task, "review": review})
}
func (server *server) handleAnnotationWorkloadSummary(writer http.ResponseWriter, request *http.Request) {
projectID := strings.TrimSpace(request.URL.Query().Get("projectId"))
events, err := server.store.ListAnnotationWorklogEvents(request.Context(), server.requestOrganizationID(request), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
if !annotationManager(principal) && principal != nil {
memberships, loadErr := server.annotationMembershipsForUser(request.Context(), server.requestOrganizationID(request), projectID, principal.User.ID)
if loadErr != nil {
renderError(writer, http.StatusInternalServerError, loadErr)
return
}
allowed := map[string]struct{}{}
for _, membership := range memberships {
allowed[membership.WorkgroupID] = struct{}{}
}
filtered := events[:0]
for _, event := range events {
if _, ok := allowed[event.WorkgroupID]; ok {
filtered = append(filtered, event)
}
}
events = filtered
}
type key struct {
userID, workgroupID, vendorID string
templateVersion int
}
aggregates := map[key]*domain.AnnotationWorkloadAggregate{}
for _, event := range events {
groupKey := key{event.UserID, event.WorkgroupID, event.VendorID, event.TemplateVersion}
item := aggregates[groupKey]
if item == nil {
item = &domain.AnnotationWorkloadAggregate{UserID: event.UserID, WorkgroupID: event.WorkgroupID, VendorID: event.VendorID, TemplateVersion: event.TemplateVersion}
aggregates[groupKey] = item
}
item.DurationSeconds += event.DurationSeconds
item.OutputCount += event.OutputDelta
switch event.EventType {
case "assigned":
item.AssignedCount++
case "annotation_submitted":
item.SubmittedCount++
case "rework_submitted":
item.ReworkCount++
case "quality_approved":
item.QualityApproved++
case "quality_rejected":
item.QualityRejected++
case "acceptance_approved":
item.AcceptanceApproved++
case "acceptance_rejected":
item.AcceptanceRejected++
}
}
items := make([]domain.AnnotationWorkloadAggregate, 0, len(aggregates))
for _, item := range aggregates {
items = append(items, *item)
}
sort.Slice(items, func(left int, right int) bool {
leftKey := items[left].VendorID + "\x00" + items[left].WorkgroupID + "\x00" + items[left].UserID + "\x00" + strconv.Itoa(items[left].TemplateVersion)
rightKey := items[right].VendorID + "\x00" + items[right].WorkgroupID + "\x00" + items[right].UserID + "\x00" + strconv.Itoa(items[right].TemplateVersion)
return leftKey < rightKey
})
renderJSON(writer, http.StatusOK, domain.AnnotationWorkloadSummary{Items: items, EventCount: len(events)})
}