droboticflow/internal/store/acceptance_authorization.go

199 lines
8.2 KiB
Go

package store
import (
"context"
"errors"
"sort"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
var ErrAcceptanceAuthorizationRequired = errors.New("请先为该供应商开启“允许最终验收”")
var ErrAcceptanceAuthorizationConflict = errors.New("授权已被其他管理员修改,请刷新后重试")
func acceptanceAuthorizationID(org, supplier string) string {
return normalizedOrganizationID(org) + ":" + supplier
}
func emptyAcceptanceAuthorization(org, supplier string) domain.SupplierAcceptanceAuthorization {
return domain.SupplierAcceptanceAuthorization{ID: acceptanceAuthorizationID(org, supplier), OrganizationID: normalizedOrganizationID(org), SupplierID: supplier}
}
func (s *MemoryStore) acceptanceAuthorizationLocked(org, supplier string) domain.SupplierAcceptanceAuthorization {
v, ok := s.acceptanceAuthorizations[acceptanceAuthorizationID(org, supplier)]
if !ok {
return emptyAcceptanceAuthorization(org, supplier)
}
return clone(v)
}
func (s *MemoryStore) GetSupplierAcceptanceAuthorization(_ context.Context, org, supplier string) (*domain.SupplierAcceptanceAuthorization, error) {
s.mu.Lock()
defer s.mu.Unlock()
v := s.acceptanceAuthorizationLocked(org, supplier)
return &v, nil
}
func (s *MemoryStore) SetSupplierAcceptanceAuthorization(_ context.Context, org, supplier string, enabled bool, version int, actor string) (*domain.SupplierAcceptanceAuthorization, error) {
s.mu.Lock()
defer s.mu.Unlock()
sp, ok := s.suppliers[supplier]
if !ok || !humanOrganizationMatches(sp.OrganizationID, org) || sp.Status != "active" {
return nil, ErrSupplierUnavailable
}
v := s.acceptanceAuthorizationLocked(org, supplier)
if v.Version != version {
return nil, ErrAcceptanceAuthorizationConflict
}
v.Enabled = enabled
v.Version++
v.UpdatedAt = nowISO()
v.History = append(v.History, domain.SupplierAcceptanceAuthorizationChange{Enabled: enabled, ActorID: actor, At: v.UpdatedAt})
if s.acceptanceAuthorizations == nil {
s.acceptanceAuthorizations = map[string]domain.SupplierAcceptanceAuthorization{}
}
s.acceptanceAuthorizations[v.ID] = clone(v)
return &v, nil
}
func (s *MongoStore) GetSupplierAcceptanceAuthorization(ctx context.Context, org, supplier string) (*domain.SupplierAcceptanceAuthorization, error) {
v := emptyAcceptanceAuthorization(org, supplier)
err := s.queryCollection("supplierAcceptanceAuthorizations").FindOne(ctx, bson.M{"_id": v.ID}).Decode(&v)
if errors.Is(err, mongo.ErrNoDocuments) {
err = nil
}
return &v, err
}
func (s *MongoStore) SetSupplierAcceptanceAuthorization(ctx context.Context, org, supplier string, enabled bool, version int, actor string) (*domain.SupplierAcceptanceAuthorization, error) {
result, err := s.withAccountMutationLock(ctx, "suppliers:"+normalizedOrganizationID(org), func(ctx context.Context) (any, error) {
sp, err := s.GetSupplier(ctx, supplier)
if err != nil {
return nil, err
}
if sp == nil || !humanOrganizationMatches(sp.OrganizationID, org) || sp.Status != "active" {
return nil, ErrSupplierUnavailable
}
v, err := s.GetSupplierAcceptanceAuthorization(ctx, org, supplier)
if err != nil {
return nil, err
}
if v.Version != version {
return nil, ErrAcceptanceAuthorizationConflict
}
v.Enabled = enabled
v.Version++
v.UpdatedAt = nowISO()
v.History = append(v.History, domain.SupplierAcceptanceAuthorizationChange{Enabled: enabled, ActorID: actor, At: v.UpdatedAt})
c := s.queryCollection("supplierAcceptanceAuthorizations")
if version == 0 {
_, err = c.InsertOne(ctx, v)
} else {
var r *mongo.UpdateResult
r, err = c.ReplaceOne(ctx, bson.M{"_id": v.ID, "version": version}, v)
if err == nil && r.MatchedCount == 0 {
err = ErrAcceptanceAuthorizationConflict
}
}
if mongo.IsDuplicateKeyError(err) {
err = ErrAcceptanceAuthorizationConflict
}
return v, err
})
if err != nil {
return nil, err
}
return result.(*domain.SupplierAcceptanceAuthorization), nil
}
// Snapshot identities once, before managed writes begin. Never rescan on restart:
// a newly-created reviewer must not accidentally become a legacy reviewer.
func (s *MongoStore) SnapshotLegacyAcceptanceAccounts(ctx context.Context, org string) error {
_, err := s.withAccountMutationLock(ctx, "suppliers:"+normalizedOrganizationID(org), func(ctx context.Context) (any, error) {
c := s.queryCollection("acceptanceCompatibilitySnapshots")
id := normalizedOrganizationID(org)
var snap struct {
UserIDs []string `bson:"userIds"`
}
err := c.FindOne(ctx, bson.M{"_id": id}).Decode(&snap)
if errors.Is(err, mongo.ErrNoDocuments) {
cursor, e := s.users.Find(ctx, bson.M{"$and": bson.A{orgCompatibilityFilter(org), bson.M{"role": domain.UserRoleAcceptanceReviewer, "acceptanceAccessMode": bson.M{"$ne": "managed"}}}}, options.Find().SetProjection(bson.M{"id": 1}))
if e != nil {
return nil, e
}
users, e := decodeMany[domain.UserRecord](ctx, cursor)
if e != nil {
return nil, e
}
snap.UserIDs = []string{}
for _, user := range users {
snap.UserIDs = append(snap.UserIDs, user.ID)
}
sort.Strings(snap.UserIDs)
_, err = c.InsertOne(ctx, bson.M{"_id": id, "organizationId": id, "userIds": snap.UserIDs, "createdAt": nowISO()})
}
if err != nil {
return nil, err
}
// Conditional writes preserve every later role change, including replay
// after a crash between snapshot creation and this compatibility marking.
_, err = s.users.UpdateMany(ctx, bson.M{"id": bson.M{"$in": snap.UserIDs}, "role": domain.UserRoleAcceptanceReviewer, "acceptanceAccessMode": bson.M{"$in": bson.A{nil, "", "legacy"}}}, bson.M{"$set": bson.M{"acceptanceAccessMode": "legacy"}})
return nil, err
})
return err
}
func stampAcceptanceClaim(item *domain.HumanItemRecord, user domain.UserRecord, grant domain.SupplierAcceptanceAuthorization) {
item.AcceptanceClaim = &domain.AcceptanceClaimAccess{UserID: user.ID, SupplierID: user.SupplierID, GrantVersion: grant.Version, StageID: item.CurrentStageID, Round: item.ReviewRound, ClaimedAt: item.ClaimedAt}
}
func currentAcceptanceClaim(item domain.HumanItemRecord, supplier, user string) bool {
v := item.AcceptanceClaim
return v != nil && (supplier == "" || v.SupplierID == supplier) && (user == "" || v.UserID == user) &&
v.UserID == item.AssignedUserID && v.StageID == item.CurrentStageID && v.Round == item.ReviewRound &&
v.ClaimedAt != "" && v.ClaimedAt == item.ClaimedAt && (item.Status == domain.HumanItemClaimed || item.Status == domain.HumanItemInProgress)
}
func (s *MemoryStore) SharedAcceptanceInventory(_ context.Context, org, supplier, user string) ([]string, int, error) {
s.mu.Lock()
defer s.mu.Unlock()
projects := map[string]bool{}
count := 0
for _, item := range s.humanItems {
if humanOrganizationMatches(item.OrganizationID, org) && currentAcceptanceClaim(item, supplier, user) {
projects[item.ProjectID] = true
count++
}
}
ids := []string{}
for id := range projects {
ids = append(ids, id)
}
sort.Strings(ids)
return ids, count, nil
}
func (s *MongoStore) SharedAcceptanceInventory(ctx context.Context, org, supplier, user string) ([]string, int, error) {
filter := bson.M{"organizationId": normalizedOrganizationID(org), "acceptanceClaim": bson.M{"$ne": nil}, "status": bson.M{"$in": bson.A{domain.HumanItemClaimed, domain.HumanItemInProgress}},
"$expr": bson.M{"$and": bson.A{bson.M{"$eq": bson.A{"$acceptanceClaim.userId", "$assignedUserId"}}, bson.M{"$eq": bson.A{"$acceptanceClaim.stageId", "$currentStageId"}}, bson.M{"$eq": bson.A{"$acceptanceClaim.round", "$reviewRound"}}, bson.M{"$eq": bson.A{"$acceptanceClaim.claimedAt", "$claimedAt"}}, bson.M{"$ne": bson.A{"$claimedAt", ""}}}}}
if supplier != "" {
filter["acceptanceClaim.supplierId"] = supplier
}
if user != "" {
filter["acceptanceClaim.userId"] = user
}
cursor, err := s.humanItems.Find(ctx, filter, options.Find().SetProjection(bson.M{"projectId": 1}))
if err != nil {
return nil, 0, err
}
items, err := decodeMany[domain.HumanItemRecord](ctx, cursor)
if err != nil {
return nil, 0, err
}
projects := map[string]bool{}
for _, item := range items {
projects[item.ProjectID] = true
}
ids := []string{}
for id := range projects {
ids = append(ids, id)
}
sort.Strings(ids)
return ids, len(items), nil
}