PyCS/pycs/frontend/notifications/NotificationManager.py

import warnings

from functools import partial
from socketio import Server
from typing import Callable

from pycs import app
from pycs.database.File import File
from pycs.database.Label import Label
from pycs.database.Model import Model
from pycs.database.Project import Project
from pycs.database.Result import Result
from pycs.frontend.util.JSONEncoder import JSONEncoder
from pycs.jobs.Job import Job
from pycs.util import Singleton


class NotificationManager(Singleton):
    """
    send events via a socket.io connection
    """

    def __repr__(self) -> str:
        return f"<{self.__class__.__name__} 0x{id(self):x}>"

    def setup(self, sio: Server):
        self.sio = sio

    def init(self):
        self.sio = None
        self.json = JSONEncoder()

    def __call__(self, name, obj_id, cls=None):
        if self.sio is None:
            warnings.warn("NotificationManager was called before a setup was performed!")
            return

        if cls is not None:
            assert isinstance(obj_id, int), \
                f"{cls.__name__} ID must be an integer, but was {type(obj_id)} ({obj_id=})!"
            obj = cls.query.get(obj_id)

        else:
            obj = obj_id

        assert obj is not None, "Object was unexpectedly None!"
        app.logger.debug(f"{name}: {obj}")

        enc = self.json.default(obj)
        self.sio.emit(name, enc)


    def _new_signal(self, signal_name, suffix, *args, **kwargs):
        return partial(self, f'{signal_name}-{suffix}', *args, **kwargs)


    def create(self, suffix, *args, **kwargs) -> Callable:
        return self._new_signal('create', suffix, *args, **kwargs)


    def edit(self, suffix, *args, **kwargs) -> Callable:
        return self._new_signal('edit', suffix, *args, **kwargs)


    def remove(self, suffix, *args, **kwargs) -> Callable:
        return self._new_signal('remove', suffix, *args, **kwargs)


    @classmethod
    def removed(kls, suffix, *args, **kwargs):
        return kls().remove(suffix)(*args, **kwargs)


    @classmethod
    def edited(kls, suffix, *args, **kwargs):
        return kls().edit(suffix)(*args, **kwargs)


    @classmethod
    def created(kls, suffix, *args, **kwargs):
        return kls().create(suffix)(*args, **kwargs)


    # def create_job(self, created_job: Job):
    #     """
    #     fire create-job event

    #     :param created_job:
    #     :return:
    #     """
    #     self.__emit('create-job', created_job)

    # def edit_job(self, edited_job: Job):
    #     """
    #     fire edit-job event

    #     :param edited_job:
    #     :return:
    #     """
    #     self.__emit('edit-job', edited_job)

    # def remove_job(self, removed_job: Job):
    #     """
    #     fire remove-job event

    #     :param removed_job:
    #     :return:
    #     """
    #     self.__emit('remove-job', removed_job)

    # def create_model(self, created_model_id: int):
    #     """
    #     fire create-model event

    #     :param created_model:
    #     :return:
    #     """
    #     self.__emit('create-model', created_model_id, Model)

    # def remove_model(self, model_serialized: dict):
    #     """
    #     fire remove-model event

    #     :param removed_model:
    #     :return:
    #     """
    #     self.__emit('remove-model', model_serialized)

    # def create_project(self, created_project_id: int):
    #     """
    #     fire create-project event

    #     :param created_project:
    #     :return:
    #     """
    #     self.__emit('create-project', created_project_id, Project)

    # def remove_project(self, project_serialized: dict):
    #     """
    #     fire remove-project event

    #     :param removed_project:
    #     :return:
    #     """
    #     self.__emit('remove-project', project_serialized)

    # def edit_project(self, edited_project_id: int):
    #     """
    #     fire edit-project event

    #     :param edited_project:
    #     :return:
    #     """
    #     self.__emit('edit-project', edited_project_id, Project)

    # def create_label(self, created_label_id: int):
    #     """
    #     fire create-label event

    #     :param created_label:
    #     :return:
    #     """
    #     self.__emit('create-label', created_label_id, Label)

    # def edit_label(self, edited_label_id: int):
    #     """
    #     fire edit-label event

    #     :param edited_label:
    #     :return:
    #     """
    #     self.__emit('edit-label', edited_label_id, Label)

    # def remove_label(self, label_serialized: dict):
    #     """
    #     fire remove-label event

    #     :param removed_label:
    #     :return:
    #     """
    #     self.__emit('remove-label', label_serialized)

    # def create_file(self, created_file_id: int):
    #     """
    #     fire create-file event

    #     :param created_file:
    #     :return:
    #     """
    #     self.__emit('create-file', created_file_id, File)

    # def edit_file(self, edited_file_id: int):
    #     """
    #     fire edit-file event

    #     :param edited_file:
    #     :return:
    #     """
    #     self.__emit('edit-file', edited_file_id, File)

    # def remove_file(self, file_serialized: dict):
    #     """
    #     fire remove-file event

    #     :param removed_file:
    #     :return:
    #     """
    #     self.__emit('remove-file', file_serialized)

    # def create_result(self, created_result_id: int):
    #     """
    #     fire create-result event

    #     :param created_result:
    #     :return:
    #     """
    #     self.__emit('create-result', created_result_id, Result)

    # def edit_result(self, edited_result_id: int):
    #     """
    #     fire edit-result event

    #     :param edited_result:
    #     :return:
    #     """
    #     self.__emit('edit-result', edited_result_id, Result)

    # def remove_result(self, result_serialized: dict):
    #     """
    #     fire remove-result event

    #     :param removed_result:
    #     :return:
    #     """
    #     self.__emit('remove-result', result_serialized)