forked from longtao.wu/droboticflow
227 lines
7.5 KiB
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
|
|
}
|