root.py

# -*- coding: utf-8 -*-

# imports
import vispa
from vispa.controller import AbstractController
from vispa.controller.ajax import AjaxController
from vispa.controller.filesystem import FSController
from vispa.controller.bus import BusController
from vispa.controller.error import ErrorController
from vispa.models.user import User
from vispa.models.workspace import Workspace
from vispa.models.preference import VispaPreference, ExtensionPreference
from vispa.models.shortcuts import VispaShortcuts, ExtensionShortcuts
import cherrypy
import logging
import os
import json as JSON

logger = logging.getLogger(__name__)


class RootController(AbstractController):

    def __init__(self):
        """
        The Constructor. Members from other classes
        are added as pages for cherrypy URL mapping.
        """
        AbstractController.__init__(self)
        self.ajax = AjaxController()
        self.fs = FSController()
        # self.error = ErrorController()
        self.extensions = AbstractController()
        self.bus = BusController()
        self.common_js = []
        self.common_css = []

    @cherrypy.expose
    @cherrypy.tools.workspace(on=False)
    @cherrypy.tools.signature()
    def sigtest(self, o, l, i, s):
        for elem in (o, l, i, s):
            print "%s (%s)" % (elem, type(elem))
        return "geht"

    def add_common_js(self, filepath):
        self.common_js.append(filepath)

    def add_common_css(self, filepath):
        self.common_css.append(filepath)

    def mount_extension_controller(self, mountpoint, controller):
        if hasattr(self.extensions, mountpoint):
            logger.warning("Controller mountpoint already exists: %s" % mountpoint)
        else:
            logger.info("Mounting controller '%s'" % os.path.join(os.sep, mountpoint))
            setattr(self.extensions, mountpoint, controller)

    def requested_path(self, delete=True):
        path = ""
        if "requested_path" in cherrypy.session.keys():
            path += cherrypy.session["requested_path"]
            if delete:
                del cherrypy.session["requested_path"]
        if "query_string" in cherrypy.session.keys():
            if cherrypy.session["query_string"]:
                path += "?" + cherrypy.session["query_string"]
                if delete:
                    del cherrypy.session["query_string"]
        return path

    def get_preferences(self, db, user_id, parse_json=False):
        preferences = {}
        preferences["vispa_preferences"] = VispaPreference.get_data_by_user_id(db, user_id)
        preferences["extension_preferences"] = ExtensionPreference.get_data_by_user_id(db, user_id)
        preferences["vispa_shortcuts"] = VispaShortcuts.get_data_by_user_id(db, user_id)
        preferences["extension_shortcuts"] = ExtensionShortcuts.get_data_by_user_id(db, user_id)
        # parse?
        if not parse_json:
            return preferences
        else:
            parsed_preferences = {}
            for key, value in preferences.items():
                parsed_preference = {}
                for key2, value2 in value.items():
                    parsed_preference[key2] = JSON.loads(value2)
                parsed_preferences[key] = JSON.dumps(parsed_preference)
            return parsed_preferences

    def workspace_data(self, workspace_id=None, keys=None):
        keys = keys or ["id", "user_id", "name", "host", "login", "key", "basedir", "command", "created"]
        user_id = self.get("user_id")
        workspace_data = {}
        workspaces = Workspace.get_user_workspaces(cherrypy.request.db, user_id)
        for workspace in workspaces:
            data = workspace.make_dict(keys=keys)
            if workspace_id == workspace.id:
                return data
            workspace_data[int(workspace.id)] = data
        return workspace_data

    @cherrypy.expose
    @cherrypy.tools.allow(methods=["GET"])
    @cherrypy.tools.stats(page="index")
    @cherrypy.tools.render(template="html/sites/index.html")
    def index2(self, *args, **kwargs):
        db = cherrypy.request.db
        username = cherrypy.request.user.name
        devmode = vispa.config("web", "devmode", True)
        use_websockets = vispa.config("websockets", "enabled", False)
        secure_websockets = vispa.config("websockets", "secure", False)
        preferences = self.get_preferences(db, cherrypy.request.user.id, parse_json=True)
        client_logging_enabled = vispa.config("web", "client_logging_enabled", True)
        client_logging_level = vispa.config("web", "client_logging_level", "info")
        client_logging_ignore = vispa.config("web", "client_logging_ignore", [])
        workspace_ids = self.get("workspace_ids")
        workspace_data = self.workspace_data()
        workspace_data = JSON.dumps(workspace_data)
        add_workspaces = vispa.config("workspace", "allow_new_workspaces", True)
        data = {"devmode"          : devmode,
                "username"         : username,
                "common_js"        : self.common_js,
                "common_css"       : self.common_css,
                "use_websockets"   : use_websockets,
                "secure_websockets": secure_websockets,
                "workspace_ids"    : self.convert(workspace_ids, int),
                "workspace_data"   : workspace_data,
                "add_workspaces"   : add_workspaces,
                "logging_enabled"  : client_logging_enabled,
                "logging_level"    : client_logging_level,
                "logging_ignore"   : client_logging_ignore}
        data.update(preferences)
        return data

    @cherrypy.expose
    @cherrypy.tools.workspace(on=False)
    @cherrypy.tools.allow(methods=["GET"])
    @cherrypy.tools.stats(page="bootstrap")
    @cherrypy.tools.render(template="sites/index.mako")
    def index(self, *args, **kwargs):
        db = cherrypy.request.db
        username = cherrypy.request.user.name
        dev_mode = vispa.config("web", "dev_mode", True)
        # use_websockets = vispa.config("websockets", "enabled", False)
        # secure_websockets = vispa.config("websockets", "secure", False)
        preferences = self.get_preferences(db, cherrypy.request.user.id, parse_json=True)
        client_log_level = vispa.config("web", "client_log_level", "info")
        workspace_ids = self.convert(self.get("workspace_ids"), int)
        workspace_ids = JSON.dumps(workspace_ids)
        workspace_data = self.workspace_data()
        workspace_data = JSON.dumps(workspace_data)
        # add_workspaces = vispa.config("workspace", "allow_new_workspaces", True)
        data = {
            "dev_mode"         : dev_mode,
            "username"         : username,
            "common_js"        : self.common_js,
            "common_css"       : self.common_css,
            # "use_websockets"   : use_websockets,
            # "secure_websockets": secure_websockets,
            "workspace_ids"    : workspace_ids,
            "workspace_data"   : workspace_data,
            # "add_workspaces"   : add_workspaces,
            "log_level"        : client_log_level,
        }
        data.update(preferences)
        return data

    @cherrypy.expose
    @cherrypy.tools.workspace(on=False)
    @cherrypy.tools.user(reverse=True, path="/")
    @cherrypy.tools.allow(methods=["GET"])
    @cherrypy.tools.stats(page="login")
    @cherrypy.tools.render(template="html/sites/login.html")
    def login(self, *args, **kwargs):
        path = self.requested_path()
        welcome_text = vispa.config("web", "welcome_text", "")
        login_text = vispa.config("web", "login_text", "")
        registration_text = vispa.config("web", "registration_text", "")
        forgot_text = vispa.config("web", "forgot_text", "")
        use_forgot = vispa.config("web", "use_forgot", False)
        return {"requested_path"   : path,
                "welcome_text"     : welcome_text,
                "login_text"       : login_text,
                "registration_text": registration_text,
                "forgot_text"      : forgot_text,
                "use_forgot"       : use_forgot}

    @cherrypy.expose
    @cherrypy.tools.user()
    @cherrypy.tools.workspace(on=False)
    def logout(self):
        vispa.fire_callback("user.logout", cherrypy.request.user)
        cherrypy.lib.sessions.expire()
        raise cherrypy.HTTPRedirect(vispa.url.dynamic("/"))

    @cherrypy.expose
    @cherrypy.tools.user(reverse=True)
    @cherrypy.tools.render(template="html/sites/activate.html")
    def activate(self, hash, *args, **kwargs):
        user = User.activate(cherrypy.request.db, hash)
        if not isinstance(user, User):
            return self.success()
        else:
            return self.fail()

    @cherrypy.expose
    @cherrypy.tools.user(reverse=True)
    @cherrypy.tools.render(template="html/sites/forgot.html")
    def forgot(self, hash, *args, **kwargs):
        user = User.get_by_hash(cherrypy.request.db, hash)
        if isinstance(user, User):
            return self.success({"hash": hash})
        else:
            return self.fail()

    @cherrypy.expose
    @cherrypy.tools.workspace(on=False)
    @cherrypy.tools.allow(methods=["GET"])
    @cherrypy.tools.stats(page="workspace")
    @cherrypy.tools.render(template="html/sites/workspace.html")
    def workspace(self, *args, **kwargs):
        path = self.requested_path()
        show_add_form = vispa.config("workspace", "allow_new_workspaces", True)
        workspace_data = self.workspace_data()
        workspace_data = JSON.dumps(workspace_data)
        return {"requested_path": path,
                "show_add_form" : show_add_form,
                "workspace_data": workspace_data}

    @cherrypy.expose
    @cherrypy.tools.user()
    @cherrypy.tools.allow(methods=["GET"])
    def resetworkspace(self, *args, **kwargs):
        if "workspace_id" in cherrypy.session.keys():
            del cherrypy.session["workspace_id"]
        raise cherrypy.HTTPRedirect(vispa.url.dynamic("/"))