Issue #101: API for list of workspace and calendars

API.md

+# API documentation
+
+## Authentication
+
+APi not actually implement authentication method. You must use cookies set by
+frontend login.
+
+## Workspaces
+
+### List
+
+    GET /api/workspaces/
+
+Return list of workspaces acessible by current connected user.
+
+#### Response
+
+    {
+       "value_list":[
+          {
+             "id":30,
+             "label":"my calendar",
+             "description":"blablabla",
+             "has_calendar":"true"
+          },
+          {
+             "id":230,
+             "label":"my calendar other",
+             "description":"blablabla 230",
+             "has_calendar":"true"
+          }
+       ]
+    }
+
+## Calendars
+
+### List
+
+    GET /api/calendars/
+
+Return list of calendars accessible by current connected user.
+
+#### Response
+
+    {
+       "value_list":[
+          {
+             "id":30,
+             "label":"my calendar",
+             "description":"blablabla 230"
+          },
+          {
+             "id":230,
+             "label":"my other calendar",
+             "description":"blablabla 230"
+          },
+          {
+             "id":20,
+             "label":"Name of the user",
+             "description":"my personnal calendar"
+          }
+       ]
+    }

tracim/tracim/config/__init__.py

 # -*- coding: utf-8 -*-
 from tg import AppConfig
+from tg.appwrappers.errorpage import ErrorPageApplicationWrapper \
+    as BaseErrorPageApplicationWrapper
 
 from tracim.lib.auth.wrapper import AuthConfigWrapper
+from tracim.lib.utils import ErrorPageApplicationWrapper
 
 
 class TracimAppConfig(AppConfig):
     """
     Tracim specific config processes.
     """
+    def __init__(self, minimal=False, root_controller=None):
+        super().__init__(minimal, root_controller)
+        self._replace_errors_wrapper()
+
+    def _replace_errors_wrapper(self) -> None:
+        """
+        Replace tg ErrorPageApplicationWrapper by ourself
+        """
+        for index, wrapper_class in enumerate(self.application_wrappers):
+            if issubclass(wrapper_class, BaseErrorPageApplicationWrapper):
+                self.application_wrappers[index] = ErrorPageApplicationWrapper
 
     def after_init_config(self, conf):
         AuthConfigWrapper.wrap(conf)

tracim/tracim/controllers/api.py

+# -*- coding: utf-8 -*-
+from tg import abort
+from tg import expose
+from tg import predicates
+from tg import request
+from tg import tmpl_context
+
+from tracim.lib.base import BaseController
+from tracim.lib.calendar import CalendarManager
+from tracim.lib.utils import api_require
+from tracim.lib.workspace import WorkspaceApi
+from tracim.model.serializers import Context, CTX
+
+"""
+To raise an error, use:
+
+```
+abort(
+    400,
+    detail={
+        'name': 'Parameter required'
+    },
+    comment='Missing data',
+)
+```
+
+"""
+
+
+class APIBaseController(BaseController):
+    def _before(self, *args, **kw):
+        if request.content_type != 'application/json':
+            abort(406, 'Only JSON requests are supported')
+
+        super()._before(*args, **kw)
+
+
+class WorkspaceController(APIBaseController):
+    @expose('json')
+    @api_require(predicates.not_anonymous())
+    def index(self):
+        # NOTE BS 20161025: I can't use tmpl_context.current_user,
+        # I d'ont know why
+        workspace_api = WorkspaceApi(tmpl_context.identity.get('user'))
+        workspaces = workspace_api.get_all()
+        serialized_workspaces = Context(CTX.API_WORKSPACE).toDict(workspaces)
+
+        return {
+            'value_list': serialized_workspaces
+        }
+
+
+class CalendarsController(APIBaseController):
+    @expose('json')
+    @api_require(predicates.not_anonymous())
+    def index(self):
+        # NOTE BS 20161025: I can't use tmpl_context.current_user,
+        # I d'ont know why
+        user = tmpl_context.identity.get('user')
+        calendar_workspaces = CalendarManager\
+            .get_workspace_readable_calendars_for_user(user)
+        calendars = Context(CTX.API_CALENDAR_WORKSPACE)\
+            .toDict(calendar_workspaces)
+
+        # Manually add information about user calendar
+        calendars.append(Context(CTX.API_CALENDAR_USER).toDict(user))
+
+        return {
+            'value_list': calendars
+        }
+
+
+class APIController(BaseController):
+    workspaces = WorkspaceController()
+    calendars = CalendarsController()

tracim/tracim/controllers/root.py

 from tg import url
 
 from tg.i18n import ugettext as _
+from tracim.controllers.api import APIController
 
 from tracim.lib import CST
 from tracim.lib.base import logger
     workspaces = UserWorkspaceRestController()
     user = UserRestController()
 
+    # api
+    api = APIController()
+
     def _render_response(self, tgl, controller, response):
         replace_reset_password_templates(controller.decoration.engines)
         return super()._render_response(tgl, controller, response)

tracim/tracim/lib/calendar.py

 
 from icalendar import Event as iCalendarEvent
 from sqlalchemy.orm.exc import NoResultFound
+from tg.i18n import ugettext as _
 
 from tracim.lib.content import ContentApi
 from tracim.lib.exceptions import UnknownCalendarType
 
 class CalendarManager(object):
     @classmethod
+    def get_personal_calendar_description(cls) -> str:
+        return _('My personal calendar')
+
+    @classmethod
     def get_base_url(cls):
         from tracim.config.app_cfg import CFG
         cfg = CFG.get_instance()
     def get_workspace_readable_calendars_urls_for_user(cls, user: User)\
             -> [str]:
         calendar_urls = []
+        for workspace in cls.get_workspace_readable_calendars_for_user(user):
+            calendar_urls.append(cls.get_workspace_calendar_url(
+                workspace_id=workspace.workspace_id,
+            ))
+
+        return calendar_urls
+
+    @classmethod
+    def get_workspace_readable_calendars_for_user(cls, user: User)\
+            -> ['Workspace']:
+        workspaces = []
         workspace_api = WorkspaceApi(user)
-        for workspace in workspace_api.get_all_for_user(user):
+
+        for workspace in workspace_api.get_all():
             if workspace.calendar_enabled:
-                calendar_urls.append(cls.get_workspace_calendar_url(
-                    workspace_id=workspace.workspace_id,
-                ))
+                workspaces.append(workspace)
 
-        return calendar_urls
+        return workspaces
 
     def is_discovery_path(self, path: str) -> bool:
         """

tracim/tracim/lib/utils.py

 import time
 import signal
 
+from tg import config
+from tg import require
+from tg import response
+from tg.controllers.util import abort
+from tg.appwrappers.errorpage import ErrorPageApplicationWrapper \
+    as BaseErrorPageApplicationWrapper
+
 from tracim.lib.base import logger
+from webob import Response
+from webob.exc import WSGIHTTPException
+
 
 def exec_time_monitor():
     def decorator_func(func):
         os.kill(os.getpid(), signal_id)  # Rethrow signal
 
     signal.signal(signal_id, _handler)
+
+
+class APIWSGIHTTPException(WSGIHTTPException):
+    def json_formatter(self, body, status, title, environ):
+        if self.comment:
+            msg = '{0}: {1}'.format(title, self.comment)
+        else:
+            msg = title
+        return {
+            'code': self.code,
+            'msg': msg,
+            'detail': self.detail,
+        }
+
+
+class api_require(require):
+    def default_denial_handler(self, reason):
+        # Add code here if we have to hide 401 errors (security reasons)
+
+        abort(response.status_int, reason, passthrough='json')
+
+
+class ErrorPageApplicationWrapper(BaseErrorPageApplicationWrapper):
+    # Define here response code to manage in APIWSGIHTTPException
+    api_managed_error_codes = [
+        400, 401, 403, 404,
+    ]
+
+    def __call__(self, controller, environ, context) -> Response:
+        # We only do ou work when it's /api request
+        # TODO BS 20161025: Look at PATH_INFO is not smart, find better way
+        if not environ['PATH_INFO'].startswith('/api'):
+            return super().__call__(controller, environ, context)
+
+        try:
+            resp = self.next_handler(controller, environ, context)
+        except:  # We catch all exception to display an 500 error json response
+            if config.get('debug', False):  # But in debug, we want to see it
+                raise
+            return APIWSGIHTTPException()
+
+        # We manage only specified errors codes
+        if resp.status_int not in self.api_managed_error_codes:
+            return resp
+
+        # Rewrite error in api format
+        return APIWSGIHTTPException(
+            code=resp.status_int,
+            detail=resp.detail,
+            title=resp.title,
+            comment=resp.comment,
+        )

tracim/tracim/model/serializers.py

     USER = 'USER'
     USERS = 'USERS'
     WORKSPACE = 'WORKSPACE'
+    API_WORKSPACE = 'API_WORKSPACE'
+    API_CALENDAR_WORKSPACE = 'API_CALENDAR_WORKSPACE'
+    API_CALENDAR_USER = 'API_CALENDAR_USER'
 
 
 class DictLikeClass(dict):
             type='workspace',
             state={'opened': True if len(item.children)>0 else False, 'selected': item.is_selected}
         )
+
+
+@pod_serializer(Workspace, CTX.API_WORKSPACE)
+def serialize_api_workspace(item: Workspace, context: Context):
+    return DictLikeClass(
+        id=item.workspace_id,
+        label=item.label,
+        description=item.description,
+        has_calendar=item.calendar_enabled,
+    )
+
+
+@pod_serializer(Workspace, CTX.API_CALENDAR_WORKSPACE)
+def serialize_api_calendar_workspace(item: Workspace, context: Context):
+    return DictLikeClass(
+        id=item.workspace_id,
+        label=item.label,
+        description=item.description,
+        type='workspace',
+    )
+
+
+@pod_serializer(User, CTX.API_CALENDAR_USER)
+def serialize_api_calendar_workspace(item: User, context: Context):
+    from tracim.lib.calendar import CalendarManager  # Cyclic import
+    return DictLikeClass(
+        id=item.user_id,
+        label=item.display_name,
+        description=CalendarManager.get_personal_calendar_description(),
+        type='user',
+    )