mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
4f46523758
An active application ADMIN now passes every memo-local authorization check on named operations: authorship, audience, Space membership and participation, attachment and reaction ownership. Structural validity still applies, an archived admin holds no privilege, and collection listings keep the audience predicate so feeds never surface other users' private memos. - core/access: admin bypass in the read policy; CanManageMemo and CanManageAttachment as the shared author-level predicates. - store: drivers read the actor's role alongside its lifecycle state in the mutation transaction; validators accept an admin where they required the author or a member; shared attachment binding and removal predicates. - api: handlers use the shared predicates; admins may place memos in any existing Space and see a memo's Space by name. - web: one canManageMemo helper replaces the ad hoc creator checks. - docs: multi-spaces design revised in place; share RPC comments updated.
143 lines
4.3 KiB
Go
143 lines
4.3 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
)
|
|
|
|
type MemoRelationType string
|
|
|
|
const (
|
|
// MemoRelationReference is the type for a reference memo relation.
|
|
MemoRelationReference MemoRelationType = "REFERENCE"
|
|
// MemoRelationComment is the type for a comment memo relation.
|
|
MemoRelationComment MemoRelationType = "COMMENT"
|
|
)
|
|
|
|
type MemoRelation struct {
|
|
MemoID int32
|
|
RelatedMemoID int32
|
|
Type MemoRelationType
|
|
}
|
|
|
|
// MemoRelationEndpointSnapshot is the memo-local database state used to
|
|
// authorize one endpoint during a reference-relation mutation.
|
|
type MemoRelationEndpointSnapshot struct {
|
|
ActorUserID int32
|
|
Actor MemoActorState
|
|
|
|
EndpointID int32
|
|
EndpointCreatorID int32
|
|
EndpointRowStatus RowStatus
|
|
EndpointVisibility Visibility
|
|
EndpointSpaceID *int32
|
|
|
|
EndpointSpaceExists bool
|
|
EndpointMemberActive bool
|
|
}
|
|
|
|
// ValidateMemoRelationEndpointRead applies authenticated memo-local read
|
|
// policy to an endpoint. An active instance administrator passes the audience
|
|
// checks; structural validity still applies.
|
|
func ValidateMemoRelationEndpointRead(snapshot *MemoRelationEndpointSnapshot) error {
|
|
if snapshot == nil || !snapshot.Actor.Active {
|
|
return ErrMemoPermissionDenied
|
|
}
|
|
if snapshot.EndpointID <= 0 {
|
|
return ErrMemoMutationConflict
|
|
}
|
|
if snapshot.EndpointRowStatus != Normal && snapshot.EndpointRowStatus != Archived {
|
|
return ErrMemoMutationConflict
|
|
}
|
|
if !isValidVisibility(snapshot.EndpointVisibility) {
|
|
return ErrMemoMutationConflict
|
|
}
|
|
if snapshot.EndpointVisibility == SpaceAudience &&
|
|
(snapshot.EndpointSpaceID == nil || !snapshot.EndpointSpaceExists) {
|
|
return ErrMemoMutationConflict
|
|
}
|
|
if snapshot.Actor.Admin {
|
|
return nil
|
|
}
|
|
if snapshot.EndpointRowStatus == Archived && snapshot.EndpointCreatorID != snapshot.ActorUserID {
|
|
return ErrMemoPermissionDenied
|
|
}
|
|
|
|
switch snapshot.EndpointVisibility {
|
|
case Public, Protected:
|
|
return nil
|
|
case Private:
|
|
if snapshot.EndpointCreatorID != snapshot.ActorUserID {
|
|
return ErrMemoPermissionDenied
|
|
}
|
|
return nil
|
|
case SpaceAudience:
|
|
if !snapshot.EndpointMemberActive {
|
|
return ErrMemoPermissionDenied
|
|
}
|
|
return nil
|
|
default:
|
|
return ErrMemoMutationConflict
|
|
}
|
|
}
|
|
|
|
type FindMemoRelation struct {
|
|
MemoID *int32
|
|
RelatedMemoID *int32
|
|
Type *MemoRelationType
|
|
MemoFilter *string
|
|
// SourceMemoRowStatus filters the relation source memo before pagination.
|
|
SourceMemoRowStatus *RowStatus
|
|
// MemoIDList matches relations where memo_id OR related_memo_id is in the list.
|
|
MemoIDList []int32
|
|
// SourceMemoIDList matches relations where memo_id is in the list.
|
|
SourceMemoIDList []int32
|
|
// RelatedMemoIDList matches relations where related_memo_id is in the list.
|
|
RelatedMemoIDList []int32
|
|
Limit *int
|
|
Offset *int
|
|
}
|
|
|
|
type DeleteMemoRelation struct {
|
|
MemoID *int32
|
|
RelatedMemoID *int32
|
|
Type *MemoRelationType
|
|
}
|
|
|
|
// ValidateMemoRelationDelete ensures the generic deletion path can only
|
|
// mutate reference relations. COMMENT relations are immutable context and are
|
|
// removed only as part of the lifecycle of an incident memo.
|
|
func ValidateMemoRelationDelete(delete *DeleteMemoRelation) error {
|
|
if delete == nil {
|
|
return errors.New("memo relation deletion is required")
|
|
}
|
|
if delete.Type == nil || *delete.Type != MemoRelationReference {
|
|
return errors.New("only REFERENCE memo relations may be deleted")
|
|
}
|
|
if delete.MemoID == nil && delete.RelatedMemoID == nil {
|
|
return errors.New("memo relation deletion requires an endpoint")
|
|
}
|
|
if (delete.MemoID != nil && *delete.MemoID <= 0) || (delete.RelatedMemoID != nil && *delete.RelatedMemoID <= 0) {
|
|
return errors.New("memo relation deletion has an invalid endpoint")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) UpsertMemoRelation(ctx context.Context, create *MemoRelation) (*MemoRelation, error) {
|
|
if create == nil || create.Type != MemoRelationReference {
|
|
return nil, errors.New("only REFERENCE memo relations may be persisted")
|
|
}
|
|
return s.driver.UpsertMemoRelation(ctx, create)
|
|
}
|
|
|
|
func (s *Store) ListMemoRelations(ctx context.Context, find *FindMemoRelation) ([]*MemoRelation, error) {
|
|
return s.driver.ListMemoRelations(ctx, find)
|
|
}
|
|
|
|
func (s *Store) DeleteMemoRelation(ctx context.Context, delete *DeleteMemoRelation) error {
|
|
if err := ValidateMemoRelationDelete(delete); err != nil {
|
|
return err
|
|
}
|
|
return s.driver.DeleteMemoRelation(ctx, delete)
|
|
}
|