797 lines
33 KiB
Go
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)})
|
|
}
|