OpenSlides/openslides/utils/consumers.py

from typing import Any, Dict, List, Optional

import jsonschema
from asgiref.sync import sync_to_async
from channels.db import database_sync_to_async
from channels.generic.websocket import AsyncJsonWebsocketConsumer
from django.apps import apps

from ..core.config import config
from ..core.models import Projector
from .auth import async_anonymous_is_enabled, has_perm
from .cache import element_cache, split_element_id
from .collection import (
    Collection,
    CollectionElement,
    format_for_autoupdate,
    from_channel_message,
)


class ProtocollAsyncJsonWebsocketConsumer(AsyncJsonWebsocketConsumer):
    """
    Mixin for JSONWebsocketConsumers, that speaks the a special protocol.
    """
    schema = {
        "$schema": "http://json-schema.org/draft-04/schema#",
        "title": "OpenSlidesWebsocketProtocol",
        "description": "The base packages that OpenSlides sends between the server and the client.",
        "type": "object",
        "properties": {
            "type": {
                "description": "Defines what kind of packages is packed.",
                "type": "string",
                "pattern": "notify|constantsRequest",  # The server can sent other types
            },
            "content": {
                "description": "The content of the package.",
            },
            "id": {
                "description": "An identifier of the package.",
                "type": "string",
            },
            "in_response": {
                "description": "The id of another package that the other part sent before.",
                "type": "string",
            }
        },
        "required": ["type", "content", "id"],
    }

    async def send_json(self, type: str, content: Any, id: Optional[str] = None, in_response: Optional[str] = None) -> None:
        """
        Sends the data with the type.
        """
        out = {'type': type, 'content': content}
        if id:
            out['id'] = id
        if in_response:
            out['in_response'] = in_response
        await super().send_json(out)

    async def receive_json(self, content: Any) -> None:
        """
        Receives the json data, parses it and calls receive_content.
        """
        try:
            jsonschema.validate(content, self.schema)
        except jsonschema.ValidationError as err:
            try:
                in_response = content['id']
            except (TypeError, KeyError):
                # content is not a dict (TypeError) or has not the key id (KeyError)
                in_response = None

            await self.send_json(
                type='error',
                content=str(err),
                in_response=in_response)
            return

        await self.receive_content(type=content['type'], content=content['content'], id=content['id'])

    async def receive_content(self, type: str, content: object, id: str) -> None:
        raise NotImplementedError("ProtocollAsyncJsonWebsocketConsumer needs the method receive_content()")


class SiteConsumer(ProtocollAsyncJsonWebsocketConsumer):
    """
    Websocket Consumer for the site.
    """
    groups = ['site']

    async def connect(self) -> None:
        """
        A user connects to the site.

        If it is an anonymous user and anonymous is disabled, the connection is closed.

        Sends the startup data to the user.
        """
        # TODO: add a way to ask for the data since a change_id and send only data that is newer
        if not await async_anonymous_is_enabled() and self.scope['user'].id is None:
            await self.close()
        else:
            await self.accept()
            data = await startup_data(self.scope['user'])
            await self.send_json(type='autoupdate', content=data)

    async def receive_content(self, type: str, content: Any, id: str) -> None:
        """
        If we recieve something from the client we currently just interpret this
        as a notify message.

        The server adds the sender's user id (0 for anonymous) and reply
        channel name so that a receiver client may reply to the sender or to all
        sender's instances.
        """
        if type == 'notify':
            if notify_message_is_valid(content):
                await self.channel_layer.group_send(
                    "projector",
                    {
                        "type": "send_notify",
                        "incomming": content,
                        "senderReplyChannelName": self.channel_name,
                        "senderUserId": self.scope['user'].id or 0,
                    },
                )
                await self.channel_layer.group_send(
                    "site",
                    {
                        "type": "send_notify",
                        "incomming": content,
                        "senderReplyChannelName": self.channel_name,
                        "senderUserId": self.scope['user'].id or 0,
                    },
                )
            else:
                await self.send_json(type='error', content='Invalid notify message', in_response=id)
        elif type == 'constantsRequest':
            angular_constants: Dict[str, Any] = {}
            for app in apps.get_app_configs():
                try:
                    # Each app can deliver values to angular when implementing this method.
                    # It should return a list with dicts containing the 'name' and 'value'.
                    get_angular_constants = app.get_angular_constants
                except AttributeError:
                    # The app doesn't have this method. Continue to next app.
                    continue
                constants = await database_sync_to_async(get_angular_constants)()
                angular_constants.update(constants)
            await self.send_json(type='constantsResponse', content=angular_constants, in_response=id)

    async def send_notify(self, event: Dict[str, Any]) -> None:
        """
        Send a notify message to the user.
        """
        user_id = self.scope['user'].id or 0

        out = []
        for item in event['incomming']:
            users = item.get('users')
            reply_channels = item.get('replyChannels')
            projectors = item.get('projectors')
            if ((isinstance(users, list) and user_id in users)
                    or (isinstance(reply_channels, list) and self.channel_name in reply_channels)
                    or (users is None and reply_channels is None and projectors is None)):
                item['senderReplyChannelName'] = event.get('senderReplyChannelName')
                item['senderUserId'] = event.get('senderUserId')
                item['senderProjectorId'] = event.get('senderProjectorId')
                out.append(item)

        if out:
            await self.send_json(type='notify', content=out)

    async def send_data(self, event: Dict[str, Any]) -> None:
        """
        Send changed or deleted elements to the user.
        """
        change_id = event['change_id']
        output = []
        changed_elements, deleted_elements = await element_cache.get_restricted_data(self.scope['user'], change_id)
        for collection_string, elements in changed_elements.items():
            for element in elements:
                output.append(format_for_autoupdate(
                    collection_string=collection_string,
                    id=element['id'],
                    action='changed',
                    data=element))
        for element_id in deleted_elements:
            collection_string, id = split_element_id(element_id)
            output.append(format_for_autoupdate(
                collection_string=collection_string,
                id=id,
                action='deleted'))
        await self.send_json(type='autoupdate', content=output)


class ProjectorConsumer(ProtocollAsyncJsonWebsocketConsumer):
    """
    Websocket Consumer for the projector.
    """

    groups = ['projector']

    async def connect(self) -> None:
        """
        Adds the websocket connection to a group specific to the projector with the given id.
        Also sends all data that are shown on the projector.
        """
        user = self.scope['user']
        projector_id = self.scope["url_route"]["kwargs"]["projector_id"]
        await self.accept()

        if not await database_sync_to_async(has_perm)(user, 'core.can_see_projector'):
            await self.send_json(type='error', content='No permissions to see this projector.')
            # TODO: Shouldend we just close the websocket connection with an error message?
            #       self.close(code=4403)
        else:
            out = await sync_to_async(projector_startup_data)(projector_id)
            await self.send_json(type='autoupdate', content=out)

    async def receive_content(self, type: str, content: Any, id: str) -> None:
        """
        If we recieve something from the client we currently just interpret this
        as a notify message.

        The server adds the sender's user id (0 for anonymous) and reply
        channel name so that a receiver client may reply to the sender or to all
        sender's instances.
        """
        projector_id = self.scope["url_route"]["kwargs"]["projector_id"]
        await self.channel_layer.group_send(
            "projector",
            {
                "type": "send_notify",
                "incomming": content,
                "senderReplyChannelName": self.channel_name,
                "senderProjectorId": projector_id,
            },
        )
        await self.channel_layer.group_send(
            "site",
            {
                "type": "send_notify",
                "incomming": content,
                "senderReplyChannelName": self.channel_name,
                "senderProjectorId": projector_id,
            },
        )

    async def send_notify(self, event: Dict[str, Any]) -> None:
        """
        Send a notify message to the projector.
        """
        projector_id = self.scope["url_route"]["kwargs"]["projector_id"]

        out = []
        for item in event['incomming']:
            users = item.get('users')
            reply_channels = item.get('replyChannels')
            projectors = item.get('projectors')
            if ((isinstance(projectors, list) and projector_id in projectors)
                    or (isinstance(reply_channels, list) and self.channel_name in reply_channels)
                    or (users is None and reply_channels is None and projectors is None)):
                item['senderReplyChannelName'] = event.get('senderReplyChannelName')
                item['senderUserId'] = event.get('senderUserId')
                item['senderProjectorId'] = event.get('senderProjectorId')
                out.append(item)

        if out:
            await self.send_json(type='notify', content=out)

    async def send_data(self, event: Dict[str, Any]) -> None:
        """
        Informs all projector clients about changed data.
        """
        projector_id = self.scope["url_route"]["kwargs"]["projector_id"]
        collection_elements = from_channel_message(event['message'])

        output = await projector_sync_send_data(projector_id, collection_elements)
        if output:
            await self.send_json(type='autoupdate', content=output)


async def startup_data(user: Optional[CollectionElement], change_id: int = 0) -> List[Any]:
    """
    Returns all data for startup.
    """
    # TODO: use the change_id argument
    output = []
    restricted_data = await element_cache.get_all_restricted_data(user)
    for collection_string, elements in restricted_data.items():
        for element in elements:
            formatted_data = format_for_autoupdate(
                collection_string=collection_string,
                id=element['id'],
                action='changed',
                data=element)

            output.append(formatted_data)
    return output


def projector_startup_data(projector_id: int) -> Any:
    """
    Generate the startup data for a projector.
    """
    try:
        projector = Projector.objects.get(pk=projector_id)
    except Projector.DoesNotExist:
        return {'text': 'The projector {} does not exist.'.format(projector_id)}
    else:
        # Now check whether broadcast is active at the moment. If yes,
        # change the local projector variable.
        if config['projector_broadcast'] > 0:
            projector = Projector.objects.get(pk=config['projector_broadcast'])

        # Collect all elements that are on the projector.
        output = []
        for requirement in projector.get_all_requirements():
            required_collection_element = CollectionElement.from_instance(requirement)
            output.append(required_collection_element.as_autoupdate_for_projector())

        # Collect all config elements.
        config_collection = Collection(config.get_collection_string())
        projector_data = (config_collection.get_access_permissions()
                          .get_projector_data(config_collection.get_full_data()))
        for data in projector_data:
            output.append(format_for_autoupdate(
                config_collection.collection_string,
                data['id'],
                'changed',
                data))

        # Collect the projector instance.
        collection_element = CollectionElement.from_instance(projector)
        output.append(collection_element.as_autoupdate_for_projector())

        # Send all the data that were only collected before.
        return output


@sync_to_async
def projector_sync_send_data(projector_id: int, collection_elements: List[CollectionElement]) -> List[Any]:
    """
    sync function that generates the elements for an projector.
    """
    # Load the projector object. If broadcast is on, use the broadcast projector
    # instead.
    if config['projector_broadcast'] > 0:
        projector_id = config['projector_broadcast']

    projector = Projector.objects.get(pk=projector_id)

    # TODO: This runs once for every open projector tab. Either use
    #       caching or something else, so this is only called once
    output = []
    for collection_element in collection_elements:
        if collection_element.is_deleted():
            output.append(collection_element.as_autoupdate_for_projector())
        else:
            for element in projector.get_collection_elements_required_for_this(collection_element):
                output.append(element.as_autoupdate_for_projector())
    return output


def notify_message_is_valid(message: object) -> bool:
    """
    Returns True, when the message is a valid notify_message.
    """
    schema = {
        "$schema": "http://json-schema.org/draft-04/schema#",
        "title": "Notify elements.",
        "description": "Elements that one client can send to one or many other clients.",
        "type": "array",
        "items": {
            "type": "object",
            "properties": {
                "projectors": {
                    "type": "array",
                    "items": {"type": "integer"},
                },
                "reply_channels": {
                    "type": "array",
                    "items": {"type": "string"},
                },
                "users": {
                    "type": "array",
                    "items": {"type": "integer"},
                }
            }
        },
        "minItems": 1,
    }
    try:
        jsonschema.validate(message, schema)
    except jsonschema.ValidationError:
        return False
    else:
        return True