droboticflow/internal/store/acceptance_priority.go

227 lines
7.5 KiB
Go

package store
import (
"context"
"droboticflow/internal/domain"
"errors"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
"sort"
)
var ErrAcceptancePriorityConflict = errors.New("验收优先设置已更新,请刷新后重试")
func cloneAcceptancePriority(v domain.AcceptancePriority) domain.AcceptancePriority {
v.ProjectIDs = append([]string(nil), v.ProjectIDs...)
v.History = append([]domain.AcceptancePriorityChange(nil), v.History...)
for i := range v.History {
v.History[i].ProjectIDs = append([]string(nil), v.History[i].ProjectIDs...)
}
return v
}
func nextAcceptancePriority(v, old domain.AcceptancePriority) domain.AcceptancePriority {
v.ID = normalizedOrganizationID(v.OrganizationID) + ":" + v.SupplierID
v.OrganizationID = normalizedOrganizationID(v.OrganizationID)
v.Version = old.Version + 1
v.UpdatedAt = nowISO()
v.History = append(old.History, domain.AcceptancePriorityChange{Enabled: v.Enabled, ProjectIDs: append([]string(nil), v.ProjectIDs...), ExpiresAt: v.ExpiresAt, ActorID: v.UpdatedBy, At: v.UpdatedAt})
return v
}
func (s *MemoryStore) ListAcceptancePriorities(_ context.Context, org string) ([]domain.AcceptancePriority, error) {
s.mu.Lock()
defer s.mu.Unlock()
out := []domain.AcceptancePriority{}
for _, v := range s.acceptancePriorities {
if v.OrganizationID == normalizedOrganizationID(org) {
out = append(out, cloneAcceptancePriority(v))
}
}
sort.Slice(out, func(i, j int) bool { return out[i].SupplierID < out[j].SupplierID })
return out, nil
}
func (s *MemoryStore) SaveAcceptancePriority(_ context.Context, v domain.AcceptancePriority, version int) (*domain.AcceptancePriority, error) {
s.mu.Lock()
defer s.mu.Unlock()
id := normalizedOrganizationID(v.OrganizationID) + ":" + v.SupplierID
old := s.acceptancePriorities[id]
if old.Version != version {
return nil, ErrAcceptancePriorityConflict
}
v = nextAcceptancePriority(v, old)
if s.acceptancePriorities == nil {
s.acceptancePriorities = map[string]domain.AcceptancePriority{}
}
s.acceptancePriorities[id] = cloneAcceptancePriority(v)
return &v, nil
}
func (s *MongoStore) ListAcceptancePriorities(ctx context.Context, org string) ([]domain.AcceptancePriority, error) {
// Authoritative config reads: never query-replica cached.
cur, err := s.queryCollection("acceptancePriorities").Find(ctx, bson.M{"organizationId": normalizedOrganizationID(org)})
if err != nil {
return nil, err
}
return decodeMany[domain.AcceptancePriority](ctx, cur)
}
func (s *MongoStore) SaveAcceptancePriority(ctx context.Context, v domain.AcceptancePriority, version int) (*domain.AcceptancePriority, error) {
c := s.queryCollection("acceptancePriorities")
var old domain.AcceptancePriority
err := c.FindOne(ctx, bson.M{"_id": normalizedOrganizationID(v.OrganizationID) + ":" + v.SupplierID}).Decode(&old)
if err != nil && !errors.Is(err, mongo.ErrNoDocuments) {
return nil, err
}
if old.Version != version {
return nil, ErrAcceptancePriorityConflict
}
v = nextAcceptancePriority(v, old)
if version == 0 {
_, err = c.InsertOne(ctx, v)
} else {
r, e := c.ReplaceOne(ctx, bson.M{"_id": v.ID, "version": version}, v)
err = e
if err == nil && r.MatchedCount == 0 {
err = ErrAcceptancePriorityConflict
}
}
if mongo.IsDuplicateKeyError(err) {
err = ErrAcceptancePriorityConflict
}
if err != nil {
return nil, err
}
return &v, nil
}
// Resolve ownership using bounded input batch IDs and identity-only bulk reads.
// No employee lookups, private evidence payloads, ownership writes or replica cache.
func resolveAcceptanceSuppliers(org string, ids []string, batches map[string]domain.HumanBatchRecord, rows []domain.HumanItemRecord, tasks map[string]domain.AnnotationTaskRecord) map[string]string {
out := map[string]string{}
bySource := map[string][]domain.HumanItemRecord{}
for _, row := range rows {
bySource[row.BatchID] = append(bySource[row.BatchID], row)
}
for _, id := range ids {
out[id] = ""
b, ok := batches[id]
if !ok || b.OrganizationID != normalizedOrganizationID(org) || b.SourceBatchID == "" {
continue
}
source, ok := batches[b.SourceBatchID]
if !ok || source.OrganizationID != b.OrganizationID || source.ProjectID != b.ProjectID {
continue
}
supplier := ""
valid := len(bySource[source.ID]) > 0
for _, row := range bySource[source.ID] {
sid := row.SupplierID
if row.OrganizationID != b.OrganizationID || row.ProjectID != b.ProjectID {
valid = false
break
}
if task, ok := tasks[row.LegacyTaskID]; ok {
if task.OrganizationID != b.OrganizationID || task.ProjectID != b.ProjectID || (sid != "" && task.SupplierID != "" && sid != task.SupplierID) {
valid = false
break
}
if sid == "" {
sid = task.SupplierID
}
}
if sid == "" || (supplier != "" && supplier != sid) {
valid = false
break
}
supplier = sid
}
if valid {
out[id] = supplier
}
}
return out
}
func (s *MemoryStore) ResolveAcceptanceSourceSuppliers(ctx context.Context, org string, ids []string) (map[string]string, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
s.mu.Lock()
defer s.mu.Unlock()
batches := map[string]domain.HumanBatchRecord{}
sources := map[string]bool{}
for _, id := range ids {
if b, ok := s.humanBatches[id]; ok {
batches[id] = b
if source, ok := s.humanBatches[b.SourceBatchID]; ok {
batches[source.ID] = source
sources[source.ID] = true
}
}
}
rows := []domain.HumanItemRecord{}
tasks := map[string]domain.AnnotationTaskRecord{}
for _, row := range s.humanItems {
if sources[row.BatchID] {
rows = append(rows, row)
if task, ok := s.annotationTasks[row.LegacyTaskID]; ok {
tasks[task.ID] = task
}
}
}
return resolveAcceptanceSuppliers(org, ids, batches, rows, tasks), nil
}
func (s *MongoStore) ResolveAcceptanceSourceSuppliers(ctx context.Context, org string, ids []string) (map[string]string, error) {
if len(ids) == 0 {
return map[string]string{}, nil
}
batches := map[string]domain.HumanBatchRecord{}
first, err := s.readBatchAccess(ctx, org, ids)
if err != nil {
return nil, err
}
sourceIDs := []string{}
for _, b := range first {
batches[b.ID] = b
if b.SourceBatchID != "" {
sourceIDs = append(sourceIDs, b.SourceBatchID)
}
}
if len(sourceIDs) == 0 {
return resolveAcceptanceSuppliers(org, ids, batches, nil, nil), nil
}
sources, err := s.readBatchAccess(ctx, org, sourceIDs)
if err != nil {
return nil, err
}
for _, b := range sources {
batches[b.ID] = b
}
cur, err := s.humanItems.Find(ctx, organizationScopedFilter(org, bson.M{"batchId": bson.M{"$in": sourceIDs}}), options.Find().SetProjection(bson.M{"_id": 0, "id": 1, "batchId": 1, "organizationId": 1, "projectId": 1, "supplierId": 1, "legacyTaskId": 1}))
if err != nil {
return nil, err
}
rows, err := decodeMany[domain.HumanItemRecord](ctx, cur)
if err != nil {
return nil, err
}
taskIDs := []string{}
for _, row := range rows {
if row.LegacyTaskID != "" {
taskIDs = append(taskIDs, row.LegacyTaskID)
}
}
tasks := map[string]domain.AnnotationTaskRecord{}
if len(taskIDs) > 0 {
cur, err := s.annotationTasks.Find(ctx, organizationScopedFilter(org, bson.M{"id": bson.M{"$in": taskIDs}}), options.Find().SetProjection(bson.M{"_id": 0, "id": 1, "organizationId": 1, "projectId": 1, "supplierId": 1}))
if err != nil {
return nil, err
}
values, err := decodeMany[domain.AnnotationTaskRecord](ctx, cur)
if err != nil {
return nil, err
}
for _, task := range values {
tasks[task.ID] = task
}
}
return resolveAcceptanceSuppliers(org, ids, batches, rows, tasks), nil
}