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