Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

5.3 KB
Raw Blame
import logging
from dataclasses import dataclass
from typing import Any

from django.db import transaction

from zerver.lib.attachments import get_old_unclaimed_attachments, validate_attachment_request
from zerver.lib.event_types import Attachment as AttachmentData
from zerver.lib.event_types import AttachmentUpdateEvent
from zerver.lib.markdown import MessageRenderingResult
from zerver.lib.upload import claim_attachment, delete_message_attachments
from zerver.models import (
    ArchivedAttachment,
    Attachment,
    ImageAttachment,
    Message,
    ScheduledMessage,
    Stream,
)
from zerver.tornado.django_api import send_event_on_commit


@dataclass
class AttachmentChangeResult:
    did_attachment_change: bool
    detached_attachments: list[dict[str, Any]]


def do_claim_attachments(
    message: Message | ScheduledMessage, potential_path_ids: list[str]
) -> bool:
    if len(potential_path_ids) == 0:
        return False

    claimed = False
    user_profile = message.sender
    is_message_realm_public = False
    is_message_web_public = False
    if isinstance(message, Message):
        is_channel_message = message.is_channel_message
    else:
        assert isinstance(message, ScheduledMessage)
        is_channel_message = message.is_channel_message()

    if is_channel_message:
        stream = Stream.objects.get(id=message.recipient.type_id)
        is_message_realm_public = stream.is_public()
        is_message_web_public = (
            user_profile.realm.web_public_streams_enabled() and stream.is_web_public
        )

    for path_id in potential_path_ids:
        is_valid, attachment = validate_attachment_request(user_profile, path_id)
        if not is_valid:
            # Technically, there are 2 cases here:
            # * The user put something in their message that has the form
            # of an upload URL, but does not actually correspond to a previously
            # uploaded file.  validate_attachment_request will return None.
            # * The user is trying to send a link to a file they don't have permission to
            # access themselves.  validate_attachment_request will return False.
            #
            # Either case is unusual and suggests a UI bug that got
            # the user in this situation, so we log in these cases.
            logging.warning(
                "User %s tried to share upload %s in message %s, but lacks permission",
                user_profile.id,
                path_id,
                message.id,
            )
            continue

        assert attachment is not None
        claimed = True
        attachment = claim_attachment(
            attachment, message, is_message_realm_public, is_message_web_public
        )
        if not isinstance(message, ScheduledMessage):
            # attachment update events don't say anything about scheduled messages,
            # so sending an event is pointless.
            event = AttachmentUpdateEvent(
                attachment=AttachmentData(**attachment.to_dict()),
                upload_space_used=user_profile.realm.currently_used_upload_space_bytes(),
            )
            send_event_on_commit(user_profile.realm, event, [user_profile.id])
    return claimed


@transaction.atomic(durable=True)
def do_delete_old_unclaimed_attachments(weeks_ago: int) -> None:
    old_unclaimed_attachments, old_unclaimed_archived_attachments = get_old_unclaimed_attachments(
        weeks_ago
    )

    with delete_message_attachments(delete_from=(ImageAttachment, Attachment)) as delete_one:
        for path_id in (
            old_unclaimed_attachments.values_list("path_id", flat=True)
            .select_for_update(of=("self",), no_key=False)
            .iterator()
        ):
            delete_one(path_id)
    with delete_message_attachments(
        delete_from=(ImageAttachment, ArchivedAttachment)
    ) as delete_one:
        for path_id in (
            old_unclaimed_archived_attachments.values_list("path_id", flat=True)
            .select_for_update(of=("self",), no_key=False)
            .iterator()
        ):
            delete_one(path_id)


def check_attachment_reference_change(
    message: Message | ScheduledMessage, rendering_result: MessageRenderingResult
) -> AttachmentChangeResult:
    # For an unsaved message edit (message.* has been updated, but not
    # saved to the database), adjusts Attachment data to correspond to
    # the new content.
    prev_attachments = {a.path_id for a in message.attachment_set.all()}
    new_attachments = set(rendering_result.potential_attachment_path_ids)

    if new_attachments == prev_attachments:
        return AttachmentChangeResult(bool(prev_attachments), [])

    to_remove = list(prev_attachments - new_attachments)
    if len(to_remove) > 0:
        attachments_to_update = Attachment.objects.filter(path_id__in=to_remove).select_for_update(
            no_key=True
        )
        message.attachment_set.remove(*attachments_to_update)

    sender = message.sender
    detached_attachments_query = Attachment.objects.filter(
        path_id__in=to_remove, messages__isnull=True, owner=sender
    )
    detached_attachments = [attachment.to_dict() for attachment in detached_attachments_query]

    to_add = list(new_attachments - prev_attachments)
    if len(to_add) > 0:
        do_claim_attachments(message, to_add)

    return AttachmentChangeResult(message.attachment_set.exists(), detached_attachments)