OpenContracts Sharing Architecture¶

# Backend: base.py DRFMutation
if not obj.user_can(user, PermissionTypes.UPDATE):  # Only UPDATE!
    raise PermissionError(...)

// Frontend: CorpusSettings.tsx
const canPermission = permissions.includes(PermissionTypes.CAN_PERMISSION);
// UI disabled if !canPermission, but backend doesn't enforce this

┌─────────────────────────────────────────────────────────────────────┐
│                        Permission System                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌──────────────┐    ┌──────────────────┐    ┌──────────────────┐  │
│  │   Frontend   │    │     GraphQL      │    │     Backend      │  │
│  │              │    │                  │    │                  │  │
│  │ CAN_PERMISSION│───▶│ myPermissions   │◀───│ permission_corpus│  │
│  │ CAN_UPDATE   │    │ objectSharedWith │    │ update_corpus    │  │
│  │ CAN_READ     │    │                  │    │ read_corpus      │  │
│  └──────────────┘    └──────────────────┘    └──────────────────┘  │
│         │                    │                       │              │
│         ▼                    ▼                       ▼              │
│  ┌──────────────┐    ┌──────────────────┐    ┌──────────────────┐  │
│  │  UI Gating   │    │    Mutations     │    │ Django Guardian  │  │
│  │  (cosmetic)  │    │  (enforcement)   │    │   (storage)      │  │
│  └──────────────┘    └──────────────────┘    └──────────────────┘  │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

# In CreateCorpusMutation.mutate() around line 2562-2566
# BEFORE:
set_permissions_for_obj_to_user(
    info.context.user,
    corpus,
    [PermissionTypes.CRUD, PermissionTypes.PUBLISH],
)

# AFTER:
set_permissions_for_obj_to_user(
    info.context.user,
    corpus,
    [PermissionTypes.CRUD, PermissionTypes.PUBLISH, PermissionTypes.PERMISSION],
)

class SetCorpusVisibility(graphene.Mutation):
    """
    Set corpus visibility (public/private).

    Requires either:
    - User is corpus creator (owner), OR
    - User has PERMISSION permission on corpus, OR
    - User is superuser
    """

    class Arguments:
        corpus_id = graphene.ID(required=True)
        is_public = graphene.Boolean(required=True)

    ok = graphene.Boolean()
    message = graphene.String()

    @login_required
    @graphql_ratelimit(rate=RateLimits.WRITE_MEDIUM)
    def mutate(root, info, corpus_id, is_public):
        user = info.context.user
        corpus_pk = from_global_id(corpus_id)[1]

        try:
            corpus = Corpus.objects.get(pk=corpus_pk)
        except Corpus.DoesNotExist:
            return SetCorpusVisibility(ok=False, message="Corpus not found")

        # Permission check: owner OR has PERMISSION OR superuser
        can_change_visibility = (
            user.is_superuser or
            corpus.creator_id == user.id or
            corpus.user_can(user, PermissionTypes.PERMISSION)
        )

        if not can_change_visibility:
            return SetCorpusVisibility(
                ok=False,
                message="You don't have permission to change this corpus's visibility"
            )

        if is_public:
            # Use existing make_corpus_public logic (async task)
            make_corpus_public_task.si(corpus_id=corpus_pk).apply_async()
            return SetCorpusVisibility(
                ok=True,
                message="Making corpus public. This may take a moment for large corpuses."
            )
        else:
            # Make private (simpler - just update the flag)
            corpus.is_public = False
            corpus.save(update_fields=['is_public'])
            return SetCorpusVisibility(ok=True, message="Corpus is now private")

class UpdateCorpusMutation(DRFMutation):
    class Arguments:
        id = graphene.String(required=True)
        title = graphene.String(required=False)
        description = graphene.String(required=False)
        icon = graphene.String(required=False)
        label_set = graphene.String(required=False)
        preferred_embedder = graphene.String(required=False)
        slug = graphene.String(required=False)
        # REMOVED: is_public = graphene.Boolean(required=False)
        corpus_agent_instructions = graphene.String(required=False)
        document_agent_instructions = graphene.String(required=False)

class CorpusSerializer(serializers.ModelSerializer):
    class Meta:
        model = Corpus
        fields = [...]
        read_only_fields = ["id", "is_public"]  # Add is_public to read_only

export const SET_CORPUS_VISIBILITY = gql`
  mutation SetCorpusVisibility($corpusId: ID!, $isPublic: Boolean!) {
    setCorpusVisibility(corpusId: $corpusId, isPublic: $isPublic) {
      ok
      message
    }
  }
`;

def grant_permission_to_creators(apps, schema_editor):
    from guardian.shortcuts import assign_perm
    Corpus = apps.get_model('corpuses', 'Corpus')

    for corpus in Corpus.objects.select_related('creator').iterator():
        if corpus.creator:
            assign_perm('permission_corpus', corpus.creator, corpus)

class Migration(migrations.Migration):
    operations = [
        migrations.RunPython(grant_permission_to_creators, migrations.RunPython.noop),
    ]

class ShareCorpus(graphene.Mutation):
    """Share a corpus with another user."""
    class Arguments:
        corpus_id = graphene.ID(required=True)
        user_id = graphene.ID(required=True)
        permissions = graphene.List(graphene.String, required=True)

    # Requires PERMISSION on corpus
    # Calls set_permissions_for_obj_to_user()

class RevokeCorpusAccess(graphene.Mutation):
    """Remove a user's access to a corpus."""
    class Arguments:
        corpus_id = graphene.ID(required=True)
        user_id = graphene.ID(required=True)

    # Requires PERMISSION on corpus
    # Calls set_permissions_for_obj_to_user(user, corpus, [])

query SearchUsersForSharing($query: String!) {
  searchUsers(query: $query) {
    edges {
      node {
        id
        username
        email
      }
    }
  }
}

Notification.objects.create(
    recipient=target_user,
    notification_type=NotificationTypes.CORPUS_SHARED,
    actor=sharing_user,
    target_corpus=corpus,
    message=f"{sharing_user.username} shared '{corpus.title}' with you"
)

# mutations.py:2562-2566
set_permissions_for_obj_to_user(
    user, corpus,
    [PermissionTypes.CRUD, PermissionTypes.PUBLISH]  # Missing PERMISSION!
)