Merge pull request #531 from inkhey/jitsi-meet_integ_demo

install/requirements.txt

 email_reply_parser==0.5.9
 filelock==2.0.13
 imapclient==1.1.0
+PyJWT==1.5.3

tracim/development.ini.base

 # Fallback language if browser and tracim can't find one they agree on.
 i18n.lang = en
 
+tracim_instance.uuid = 79160afe-e324-473a-9aef-7b93f69c1c1b
+
 cache_dir = %(here)s/data
 # preview generator cache directory
 preview_cache_dir = /tmp/tracim/preview/
 # it's just an empty file use to prevent concurrent access to imap unseen mail
 email.reply.lockfile_path = %(here)s/email_fetcher.lock
 
+## Jitsi_meet_integration
+jitsi_meet.activated = False
+# Domain/IP where jitsi_meet is located, example: "meet.jit.si", "127.0.0.1"
+jitsi_meet.domain = your_jitsi_meet_instance
+# Choose between token and anonymous auth, anonymous is default one.
+# for token auth config, see : https://github.com/jitsi/lib-jitsi-meet/blob/52eb3decf6542413c739ce2209456fac728a89d5/doc/tokens.md
+jitsi_meet.use_token = False
+# If token mode is choosen, you need to provide a token generator.
+# "local" value mean that tracim himself will create token for jitsi-meet
+# Distant token generator are not yet implemented.
+jitsi_meet.token_generator = local
+# identifier share between jitsi_meet and local token_generator
+jitsi_meet.token_generator.local.app_id = tracim
+# Secret share between jitsi-meet and local token_generator
+jitsi_meet.token_generator.local.secret = my_secret
+# Algorithm used to sign JWT token
+jitsi_meet.token_generator.local.algorithm = HS256
+# Duration of token validity in second. 5 minutes (300) is a good choice.
+jitsi_meet.token_generator.local.duration = 300
+
 ## Radical (CalDav server) configuration
 # radicale.server.host = 0.0.0.0
 # radicale.server.port = 5232

tracim/setup.py

     'nose',
     'coverage',
     'gearbox',
+    'mock',
 ]
 
 install_requires = [

tracim/tracim/config/app_cfg.py

         """Parse configuration file."""
         mandatory_msg = \
             'ERROR: {} configuration is mandatory. Set it before continuing.'
+        self.TRACIM_INSTANCE_UUID = tg.config.get(
+            'tracim_instance.uuid',
+        )
         self.DEPOT_STORAGE_DIR = tg.config.get(
             'depot_storage_dir',
         )
             # ContentType.Folder -- Folder is skipped
         ]
 
+        self.JITSI_MEET_ACTIVATED = asbool(tg.config.get(
+            'jitsi_meet.activated',
+            False,
+        ))
+        self.JITSI_MEET_DOMAIN = tg.config.get(
+            'jitsi_meet.domain'
+        )
+        self.JITSI_MEET_USE_TOKEN = asbool(tg.config.get(
+            'jitsi_meet.use_token',
+            False,
+        ))
+        self.JITSI_MEET_TOKEN_GENERATOR = tg.config.get(
+            'jitsi_meet.token_generator',
+            'local'
+        )
+        self.JITSI_MEET_TOKEN_GENERATOR_LOCAL_APP_ID = tg.config.get(
+            'jitsi_meet.token_generator.local.app_id'
+        )
+        self.JITSI_MEET_TOKEN_GENERATOR_LOCAL_SECRET = tg.config.get(
+            'jitsi_meet.token_generator.local.secret'
+        )
+        self.JITSI_MEET_TOKEN_GENERATOR_LOCAL_ALGORITHM = tg.config.get(
+            'jitsi_meet.token_generator.local.algorithm',
+            'HS256'
+        )
+        self.JITSI_MEET_TOKEN_GENERATOR_LOCAL_DURATION = int(tg.config.get(
+            'jitsi_meet.token_generator.local.duration',
+            60
+        ))
+
         self.RADICALE_SERVER_HOST = tg.config.get(
             'radicale.server.host',
             '127.0.0.1',

tracim/tracim/controllers/jitsi_meet.py

+import typing
+import tg
+from tg import abort
+from tg import expose
+from tg import tmpl_context
+from tg.predicates import not_anonymous
+from tracim.lib.predicates import current_user_is_reader
+from sqlalchemy.orm.exc import NoResultFound
+
+from tracim.lib.jitsi_meet.room import JitsiMeetRoom
+from tracim.lib.jitsi_meet.token import JitsiMeetUser
+from tracim.config.app_cfg import CFG
+
+from tracim.model.data import User
+from tracim.model.serializers import Context, CTX, DictLikeClass
+from tracim.controllers import TIMRestController, TIMRestPathContextSetup
+
+class JitsiMeetController(TIMRestController):
+
+    allow_only = not_anonymous()
+
+    def _before(self, *args, **kw) -> None:
+        TIMRestPathContextSetup.current_user()
+        try:
+            TIMRestPathContextSetup.current_workspace()
+        except NoResultFound:
+            abort(404)
+
+    @tg.require(current_user_is_reader())
+    @expose('tracim.templates.videoconf.jitsi_meet')
+    def get(self) -> DictLikeClass:
+        """
+        Jitsi-Meet Room page
+        """
+        user = tmpl_context.current_user
+        return self._jitsi_room(jitsi_user=user)
+
+    @tg.require(current_user_is_reader())
+    @expose('tracim.templates.videoconf.invite')
+    def invite(self) -> DictLikeClass:
+        """
+        Modal windows : Invitation to Jitsi-Meet room
+        """
+        # TODO - G.M - 14-02-2017 - Allow to invite not Anonymous user ?
+        # Jitsi-Meet allow to set user info through token
+        # invite already "named" user should be possible
+        return self._jitsi_room()
+
+    @classmethod
+    def _jitsi_room(
+            cls,
+            jitsi_user: typing.Union[JitsiMeetUser, User, None]=None,
+    )-> DictLikeClass:
+        """
+        Get all infos to generate DictLikeClass usable for JitsiMeetRoom
+        Templates.
+        :param jitsi_user: User who access to room
+        """
+        cfg = CFG.get_instance()
+        if not cfg.JITSI_MEET_ACTIVATED:
+            abort(404)
+        user = tmpl_context.current_user
+        workspace = tmpl_context.workspace
+        current_user_content = Context(CTX.CURRENT_USER).toDict(user)
+        fake_api = Context(CTX.CURRENT_USER).toDict(
+            {'current_user': current_user_content,
+             }
+        )
+        dictified_workspace = Context(CTX.WORKSPACE).toDict(workspace,
+                                                            'workspace')
+
+        jitsi_meet_room = JitsiMeetRoom(
+            issuer=jitsi_user,
+            receivers=workspace,
+        )
+
+        return DictLikeClass(fake_api=fake_api,
+                             result=dictified_workspace,
+                             jitsi_meet_room=jitsi_meet_room)

tracim/tracim/controllers/root.py

 from tracim.model.serializers import CTX
 from tracim.model.serializers import DictLikeClass
 
-
 class RootController(StandardController):
     """
     The root controller for the tracim application.

tracim/tracim/controllers/workspace.py

 
 from tracim.controllers import TIMRestController
 from tracim.controllers.content import UserWorkspaceFolderRestController
+from tracim.controllers.jitsi_meet import JitsiMeetController
 
 from tracim.lib.helpers import convert_id_into_instances
 from tracim.lib.content import ContentApi
     allow_only = not_anonymous()
 
     folders = UserWorkspaceFolderRestController()
+    videoconference = JitsiMeetController()
 
     @property
     def _base_url(self):
                 show_archived=show_archived,
             )
         )
+        videoconf_enabled = CFG.get_instance().JITSI_MEET_ACTIVATED
 
         dictified_workspace = Context(CTX.WORKSPACE).toDict(workspace, 'workspace')
 
-        # INFO - G.M - 15-02-2018 - Deal with url scheme for dav link
-        # TODO - G.M - 15-02-2018 - Find better solution to deal with url ?
         webdav_url = CFG.get_instance().WSGIDAV_CLIENT_BASE_URL
         website_protocol = urlparse(CFG.get_instance().WEBSITE_BASE_URL).scheme
         dav_protocol = 'dav'
             result=dictified_workspace,
             fake_api=fake_api,
             webdav_url=webdav_url,
+            videoconf_enabled=videoconf_enabled,
             website_protocol = website_protocol,
             dav_protocol = dav_protocol,
             show_deleted=show_deleted,

tracim/tracim/lib/jitsi_meet/room.py

+import typing
+from tracim.lib.jitsi_meet.token import JitsiMeetToken
+from tracim.lib.jitsi_meet.token import JitsiMeetUser
+from tracim.lib.jitsi_meet.token import JitsiMeetContext
+from tracim.lib.utils import str_as_alpha_num_str
+from tracim.config.app_cfg import CFG
+from tracim.model.data import Workspace
+from tracim.model.data import User
+import uuid
+
+
+class JitsiMeetRoom(object):
+    def __init__(
+            self,
+            receivers: Workspace,
+            issuer: typing.Union[User, JitsiMeetUser, None]=None,
+    ) -> None:
+        """
+        This class set all to create a JitsiMeetRoom according
+        to current config.
+        :param issuer: user who initiated Jitsi Meet talk
+        if None, default user is created. Can be both Tracim User or
+        JitsiMeetUser.
+        :param receivers: User or Room who can talk with sender. Now, only
+        Workspace are supported.
+        """
+        self.tracim_cfg = CFG.get_instance()
+        self._set_domain()
+        self._set_token_params()
+        self._set_context(
+            workspace=receivers,
+            issuer=issuer,
+        )
+        self.room = self._generate_room_name(receivers)
+
+    def _set_domain(self) -> None:
+        """
+        Set domain according to config
+        :return:
+        """
+        self.domain = self.tracim_cfg.JITSI_MEET_DOMAIN
+
+    def _set_token_params(self) -> None:
+        """
+        Set params related to token according to config.
+        :return: nothing
+        """
+        self.use_token = self.tracim_cfg.JITSI_MEET_USE_TOKEN
+        if self.use_token:
+            if self.tracim_cfg.JITSI_MEET_TOKEN_GENERATOR != 'local':
+                raise JitsiMeetNoTokenGenerator
+
+            self.token_app_id = self.tracim_cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_APP_ID  # nopep8
+            self.token_secret = self.tracim_cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_SECRET  # nopep8
+            self.token_alg = self.tracim_cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_ALGORITHM   # nopep8
+            self.token_duration = self.tracim_cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_DURATION  # nopep8
+
+    def _set_context(
+            self,
+            workspace: Workspace,
+            issuer: typing.Union[User, JitsiMeetUser, None],
+    ) -> None:
+        """
+        Set context of JWT token for Jitsi Meet
+        :param issuer: user who initiated Jitsi Meet talk
+        if None, default user is created. Can be both Tracim User or
+        JitsiMeetUser.
+        :param workspace: User or Room who can talk with sender. Now, only
+        Workspace are supported.
+        :return: nothing.
+        """
+
+        # INFO - G.M - 13-02-2018 - Convert all issuers values as JitsiMeetUser
+        if isinstance(issuer, JitsiMeetUser):
+            user = issuer
+        elif isinstance(issuer, User):
+            user = JitsiMeetUser(
+                name=issuer.display_name,
+                avatar_url=None,
+                jitsi_meet_user_id=issuer.display_name,
+            )
+        else:
+            user = JitsiMeetUser(
+                # INFO - G.M - 13-02-2018 - create unique id for anonymous user
+                jitsi_meet_user_id=str(uuid.uuid4()),
+            )
+
+        # INFO - G.M - 13-02-2018 - Associate
+        group = workspace.label
+
+        self.context = JitsiMeetContext(
+            user=user,
+            group=group,
+        )
+
+    def _generate_room_name(self, workspace: Workspace) -> str:
+        """
+        Generate Jitsi-Meet room name related to workspace
+        that should be unique, always the same for same workspace in same Tracim
+        instance but should also no contains any special characters
+        :param workspace: Tracim Workspace
+        :return: room name as str.
+        """
+        room = "{uuid}{workspace_id}{workspace_label}".format(
+            uuid=self.tracim_cfg.TRACIM_INSTANCE_UUID,
+            workspace_id=workspace.workspace_id,
+            workspace_label=workspace.label)
+
+        # Jitsi-Meet doesn't like specials_characters
+        return str_as_alpha_num_str(room)
+
+    def generate_jwt_token(self) -> str:
+        """
+        Generate Jitsi-Meet related JWT token
+        :return: JWT token as str
+        """
+        if not self.use_token:
+            raise JitsiMeetTokenNotActivated
+
+        token = JitsiMeetToken(
+            domain=self.domain,
+            room=self.room,
+            app_id=self.token_app_id,
+            secret=self.token_secret,
+            alg=self.token_alg,
+            duration=self.token_duration,
+            context=self.context,
+        )
+        return token.generate()
+
+    def generate_url(self, token=None) -> str:
+        """
+        Generate Jitsi-Meet url with or without token
+        examples :
+         - https://myjitsiinstance/myroom
+         - https://mysecurejitsiinstance/myroom?jwt=[very_long_jwt_token]
+        :return: url as string
+        """
+        if token:
+            url = "{}/{}?jwt={}".format(self.domain,
+                                        self.room,
+                                        token)
+        else:
+            url = "{}/{}".format(self.domain,
+                                 self.room,
+                                 )
+        return "https://{}".format(url)
+
+
+class JitsiMeetNoTokenGenerator(Exception):
+    pass
+
+
+class JitsiMeetTokenNotActivated(Exception):
+    pass

tracim/tracim/lib/jitsi_meet/token.py

+import datetime
+import typing
+import jwt
+
+# Jitsi Meet Token
+# Data model and methods to convert dict as JWT token
+# see https://github.com/jitsi/lib-jitsi-meet/blob/52eb3decf6542413c739ce2209456fac728a89d5/doc/tokens.md  # nopep8
+
+
+class JitsiMeetUser(object):
+
+    def __init__(
+            self,
+            jitsi_meet_user_id: str,
+            name: typing.Optional[str] = None,
+            email: typing.Optional[str] = None,
+            avatar_url: typing.Optional[str] = None,
+    ) -> None:
+        """
+        User data for Jitsi-Meet token
+        :param avatar_url: url for user avatar_url
+        :param name: display name of user
+        :param email: email of user
+        :param jitsi_meet_user_id: Jitsi-Meet id of user
+        """
+        self.avatar_url = avatar_url
+        self.name = name
+        self.email = email
+        self.jitsi_meet_user_id = jitsi_meet_user_id
+
+    def as_dict(self) -> dict:
+        """
+        Generate dict for JWT token
+        :return: user as dict
+        """
+        data = {
+            'id': self.jitsi_meet_user_id,
+        }
+        if self.name:
+            data['name'] = self.name
+        if self.email:
+            data['email'] = self.email
+        if self.avatar_url:
+            data['avatar'] = self.avatar_url
+        return data
+
+
+class JitsiMeetContext(object):
+
+    def __init__(
+            self,
+            user: typing.Optional[JitsiMeetUser]=None,
+            callee: typing.Optional[JitsiMeetUser]=None,
+            group: str="default",
+    ) -> None:
+        """
+        context as in Jitsi-Meet Token
+        :param user: Current user
+        :param callee: User Who respond in 1-to-1 conf
+        :param group: Used only for stats
+        """
+        self.user = user
+        self.callee = callee
+        self.group = group
+
+    def as_dict(self) -> dict:
+        """
+        Generate dict for JWT token
+        :return: context as dict
+        """
+        data = {}
+        if self.callee:
+            data['callee'] = self.callee.as_dict()
+        if self.user:
+            data['user'] = self.user.as_dict()
+        if self.group:
+            data['group'] = self.group
+        return data
+
+
+class JitsiMeetToken(object):
+
+    def __init__(
+            self,
+            domain: str,
+            room: str,
+            app_id: str,
+            secret: str,
+            alg: str,
+            duration: int,
+            context: typing.Optional[JitsiMeetContext] = None,
+    ) -> None:
+        """
+        JWT token generator for Jitsi-Meet,
+        :param app_id: application identifier
+        :param secret: secret share between token generator and XMPP server
+        :param alg: algorithm used
+        :param duration: duration of token
+        :param domain: Jitsi-Meet domain
+        :param room: room name
+        """
+        self.room = room
+        self.domain = domain
+        self.app_id = app_id
+        self.secret = secret
+        self.alg = alg
+        self.duration = duration
+        self.context = context
+
+    def generate(self, issue_date: typing.Optional[datetime.datetime] = None) -> str:
+        """
+        Generate JWT token
+        :return: JWT token as str
+        """
+        if not issue_date:
+            issue_date = datetime.datetime.utcnow()
+        exp = issue_date+datetime.timedelta(seconds=self.duration)
+        data = {
+            "iss": self.app_id,  # Issuer
+            "room": self.room,  # Custom-param for jitsi_meet
+            "aud": "*",  # TODO: Understood this param
+            "exp": exp,  # Expiration date
+            "nbf": issue_date,  # NotBefore
+            "iat": issue_date,   # IssuedAt
+        }
+        if self.context:
+            data['context'] = self.context.as_dict()
+        jwt_token = jwt.encode(
+            data,
+            self.secret,
+            algorithm=self.alg
+        )
+        return jwt_token.decode("utf-8")

tracim/tracim/lib/utils.py

 from tg.util import lazify
 from redis import Redis
 from rq import Queue
+from unidecode import unidecode
 
 from wsgidav.middleware import BaseMiddleware
 from tracim.lib.base import logger
     return bool(string)
 
 
+def str_as_alpha_num_str(unicode_string: str) -> str:
+    """
+    convert unicode string to alpha_num-only string.
+    convert also accented character to ascii equivalent.
+    :param unicode_string:
+    :return:
+    """
+    ascii_string = unidecode(unicode_string)
+    alpha_num_string = ''.join(e for e in ascii_string if e.isalnum())
+    return alpha_num_string
+
+
 class LazyString(BaseLazyString):
     pass
 

tracim/tracim/templates/videoconf/invite.mak

+<%namespace name="TIM" file="tracim.templates.pod"/>
+<%namespace name="ICON" file="tracim.templates.widgets.icon"/>
+<%def name="title()">${_('Invite someone to video-conference')}</%def>
+
+<%def name="content(jitsi_meet_room)">
+    <div class="modal-header">
+        <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">&times;</span><span class="sr-only">Close</span></button>
+        <h4 class="modal-title">${ICON.FA('fa-share')}  ${self.title()}</h4>
+    </div>
+    <div class="modal-body">
+        <p>
+        ${_('To invite someone from outside of tracim into this conference, share this link. This link is available for 5 minutes.')}
+        </p>
+        <textarea readonly=readonly wrap="off" style="width: 100%;">${jitsi_meet_room.generate_url(jitsi_meet_room.generate_jwt_token())}</textarea>
+    </div>
+    <div class="modal-footer">
+        <button type="button" class="btn btn-default" data-dismiss="modal">${_('Close')}</button>
+    </div>
+        </form>
+</%def>
+${self.content(jitsi_meet_room)}
+

tracim/tracim/templates/videoconf/jitsi_meet.mak

+<%inherit file="local:templates.master_authenticated_left_treeview_right_toolbar"/>
+<%namespace name="TIM" file="tracim.templates.pod"/>
+<%namespace name="ROW" file="tracim.templates.widgets.row"/>
+<%namespace name="TABLE_ROW" file="tracim.templates.widgets.table_row"/>
+<%namespace name="LEFT_MENU" file="tracim.templates.widgets.left_menu"/>
+<%namespace name="P" file="tracim.templates.widgets.paragraph"/>
+<%namespace name="TOOLBAR" file="tracim.templates.videoconf.toolbar"/>
+
+<%def name="title()">
+    ${_('Video conference: {workspace}').format(workspace=result.workspace.label)}
+</%def>
+
+<%def name="TITLE_ROW()">
+    <div class="content__title">
+    ${ROW.TITLE_ROW(
+    _('Video conference: {workspace}').format(workspace=result.workspace.label),
+    'fa-video-camera', 'content__title__subtitle-home-hidden-xs',
+    't-user-color', _('Welcome to video conference of {workspace}, {username}.').format(workspace=
+    result.workspace.label,
+    username=fake_api.current_user.name))}
+    </div>
+</%def>
+
+<%def name="SIDEBAR_RIGHT_CONTENT()">
+    ${TOOLBAR.JITSIMEETROOM(fake_api.current_user, result.workspace, jitsi_meet_room)}
+</%def>
+
+
+<%def name="SIDEBAR_LEFT_CONTENT()">
+    ${LEFT_MENU.TREEVIEW('sidebar-left-menu', 'workspace_{}__'.format(result.workspace.id))}
+</%def>
+
+<%def name="REQUIRED_DIALOGS()">
+</%def>
+
+<div class="content__home">
+    <div id="jitsi">
+    </div>
+    <script src="https://${jitsi_meet_room.domain}/libs/external_api.min.js"></script>
+    <script>
+        let domain = '${jitsi_meet_room.domain}';
+        let options = {
+	    // INFO - G.M - 14-02-2018 jitsi-meet external API
+        // support only one way to auto-auth due to security concern : token,
+	    // which is anonymous BOSH auth with specific url
+        // for another way to deal with auto-auth :
+        // see this rejected PR : https://github.com/jitsi/jitsi-meet/pull/2109
+            %if jitsi_meet_room.use_token:
+                jwt: '${jitsi_meet_room.generate_jwt_token()}',
+            %endif
+            roomName : '${jitsi_meet_room.room}',
+            parentNode: document.querySelector('#jitsi'),
+            // TODO - G.M - 14-02-2018 - Find a solution to height trouble.
+            // height should be related to page size
+            height: 700,
+            // TODO - G.M - 14-02-2018 Check 'no_SSL' params
+        };
+        let api = new JitsiMeetExternalAPI(domain, options);
+        // INFO - G.M - 14-02-2018 - About Display Name
+        // Display name in jitsi-meet use XEP-0172 for MUC, which is discouraged,
+        // when others clients use resource part of the Jabber id to do it.
+        // That's why displayName compat with others XMPP client is not optimal.
+        // check this : https://github.com/jitsi/jitsi-meet/pull/2068
+        % if jitsi_meet_room.context and jitsi_meet_room.context.user:
+            %if jitsi_meet_room.context.user.name:
+            api.executeCommand('displayName', '${jitsi_meet_room.context.user.name}');
+            %endif
+            // We can override also avatar.
+            %if jitsi_meet_room.context.user.avatar_url:
+            api.executeCommand('avatarUrl', '${jitsi_meet_room.context.user.avatar_url}');
+            %endif
+        % endif
+    </script>
+</div>
+<div id="videoconf-invite-modal-dialog" class="modal bs-example-modal-lg" tabindex="-1" role="dialog" aria-labelledby="myLargeModalLabel" aria-hidden="true">
+  <div class="modal-dialog">
+    <div class="modal-content">
+    </div>
+  </div>
+</div>

tracim/tracim/templates/videoconf/toolbar.mak

+<%namespace name="ICON" file="tracim.templates.widgets.icon"/>
+
+<%namespace name="TIM" file="tracim.templates.pod"/>
+
+
+<%def name="JITSIMEETROOM(current_user, workspace,jitsi_meet_room)">
+    ## SIDEBAR RIGHT
+    <div>
+        <div class="btn-group btn-group-vertical">
+           ## INFO - G.M - 09-01-2018 - Share a link disabled, because
+           ## link doesn't refresh.
+           ## <a title="${_('Invite by sharing a link')}" class="btn btn-default" data-toggle="modal" data-target="#videoconf-invite-modal-dialog" data-remote="${tg.url('/workspaces/{}/videoconference/invite'.format(result.workspace.id))}" >${ICON.FA('fa-share fa-fw t-less-visible')} ${_('Invite')}</a>
+        </div>
+        <p></p>
+    </div> <!-- # End of side bar right -->
+    ## SIDEBAR RIGHT [END]
+</%def>

tracim/tracim/templates/workspace/getone.mak

 </%def>
 
 <%def name="SIDEBAR_RIGHT_CONTENT()">
-##    {TOOLBAR.SECURED_FOLDER(fake_api.current_user, result.folder.workspace, result.folder)}
+ ${TOOLBAR.WORKSPACE_USER(fake_api.current_user, result.workspace, videoconf_enabled)}
 </%def>
 
 <%def name="REQUIRED_DIALOGS()">

tracim/tracim/templates/workspace/toolbar.mak

                 <a title="${_('Delete current workspace')}" class="btn btn-default" href="${tg.url('/admin/workspaces/{}/delete'.format(result.workspace.id))}">${ICON.FA('fa-trash fa-fw t-less-visible')} ${_('Delete')}</a>
             </div>
         % endif
+            ${JITSI_MEET_BUTTON(current_user, workspace)}
     </div> <!-- # End of side bar right -->
     ## SIDEBAR RIGHT [END]
 </%def>
+
+<%def name="WORKSPACE_USER(current_user, workspace, videoconf_enabled)">
+    <div>
+        % if videoconf_enabled:
+        ${JITSI_MEET_BUTTON(current_user, workspace)}
+       % endif
+    </div> <!-- # End of side bar right -->
+</%def>
+
+<%def name="JITSI_MEET_BUTTON(current_user, workspace)">
+    <div class="btn-group btn-group-vertical">
+        <a title="${_('Video conference')}" class="btn btn-default" href="${tg.url('/workspaces/{}/videoconference'.format(result.workspace.id))}">${ICON.FA('fa-video-camera fa-fw t-less-visible')} ${_('Video Conference')}</a>
+    </div>
+</%def>

tracim/tracim/tests/library/test_jitsi_meet_room.py

+from tracim.lib.jitsi_meet.room import JitsiMeetRoom
+from tracim.lib.jitsi_meet.room import JitsiMeetTokenNotActivated
+from tracim.lib.jitsi_meet.room import JitsiMeetNoTokenGenerator
+from tracim.lib.jitsi_meet.token import JitsiMeetUser
+from tracim.model.data import User
+from tracim.model.data import Workspace
+from nose.tools import raises
+from mock import patch, Mock
+
+
+class TestJitsiMeetRoom(object):
+
+    ROOM = 'room'
+    DOMAIN = 'tracim'
+    TOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MTYyNzA3NzksImlzcyI6InRlc3QiLCJhdWQiOiIqIiwibmJmIjoxNTE2MjcwNzE5LCJyb29tIjoicm9vbSIsImlhdCI6MTUxNjI3MDcxOX0.zqFBUcPGjlCfXTjuFP7brqalY8TKlgcg6DUE72KhCx0'  # nopep8
+
+    def test_unit__generate_url_token_no_token(self) -> None:
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr.domain = TestJitsiMeetRoom.DOMAIN
+            jmr.room = TestJitsiMeetRoom.ROOM
+            url = jmr.generate_url()
+            assert url == 'https://{domain}/{room}'.format(
+                domain=self.DOMAIN,
+                room=self.ROOM,
+                token=self.TOKEN
+            )
+
+    def test_unit__generate_url_token(self) -> None:
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr.domain = TestJitsiMeetRoom.DOMAIN
+            jmr.room = TestJitsiMeetRoom.ROOM
+            url = jmr.generate_url(token=self.TOKEN)
+            assert url == 'https://{domain}/{room}?jwt={token}'.format(
+                domain=self.DOMAIN,
+                room=self.ROOM,
+                token=self.TOKEN
+            )
+
+    @raises(JitsiMeetNoTokenGenerator)
+    def test_unit__set_token_params_no_token_generator(self) -> None:
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr.tracim_cfg = Mock()
+            jmr.tracim_cfg.JITSI_MEET_TOKEN_GENERATOR = None
+            jmr._set_token_params()
+
+    @raises(JitsiMeetTokenNotActivated)
+    def test_unit__generate_token_not_activated(self) -> None:
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr.use_token = False
+            jmr.generate_jwt_token()
+
+    def test_unit__set_context_return_always_jitsi_meet_user(self):
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr._set_context(issuer=None, workspace=Workspace())
+            assert jmr.context
+            assert hasattr(jmr.context, 'user')
+            assert isinstance(jmr.context.user, JitsiMeetUser)
+
+            jmr2 = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr2._set_context(issuer=JitsiMeetUser(jitsi_meet_user_id='user'),
+                              workspace=Workspace())
+            assert jmr2.context
+            assert hasattr(jmr2.context, 'user')
+            assert isinstance(jmr2.context.user, JitsiMeetUser)
+
+            jmr3 = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            jmr3._set_context(issuer=User(), workspace=Workspace())
+            assert jmr3.context
+            assert hasattr(jmr3.context, 'user')
+            assert isinstance(jmr3.context.user, JitsiMeetUser)
+
+    def test_unit__generate_room_name(self):
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            mock = Mock()
+            jmr.tracim_cfg = Mock()
+            jmr.tracim_cfg.TRACIM_INSTANCE_UUID = 'myuuid'
+            mock.workspace_id = 1
+            mock.label = 'myroom'
+            assert jmr._generate_room_name(mock) == 'myuuid1myroom'
+
+    def test_unit__generate_room_name_no_special_character(self):
+        with patch.object(JitsiMeetRoom,
+                          "__init__",
+                          lambda item, receivers: None):
+            jmr = JitsiMeetRoom(
+                receivers=Workspace()
+            )
+            mock = Mock()
+            jmr.tracim_cfg = Mock()
+            # TODO - G.M - 14-02-2018 - Be exhaustive about special char ?
+            jmr.tracim_cfg.TRACIM_INSTANCE_UUID = '*%hél\/ <>."{}|+&-@"~]=lo{à!ll;:'  # nopep8
+            mock.workspace_id = 1
+            mock.label = 'myroom'
+            assert jmr._generate_room_name(mock) == 'helloall1myroom'

tracim/tracim/tests/library/test_jitsi_meet_token.py

+import jwt
+import datetime
+import calendar
+
+from tracim.lib.jitsi_meet.token import JitsiMeetToken
+from tracim.lib.jitsi_meet.token import JitsiMeetContext
+from tracim.lib.jitsi_meet.token import JitsiMeetUser
+
+
+class TestJitsiMeetToken(object):
+
+    TOKEN_APP_ID = 'test'
+    TOKEN_SECRET = 'secret'
+    TOKEN_ALG = 'HS256'
+    TOKEN_DURATION = 60
+    TOKEN_USER = JitsiMeetUser(name='john',
+                               email='john@doe',
+                               jitsi_meet_user_id='0')
+    TOKEN_CONTEXT = JitsiMeetContext(user=TOKEN_USER, group='test')
+    ROOM = 'room'
+    DOMAIN = 'tracim'
+    ISSUE_DATE = datetime.datetime.utcfromtimestamp(0)
+
+    def test_unit__generate_token_check_value(self) -> None:
+        """
+        Test all value without checking jwt validity (timestamp 0 as issue date)
+        :return: Nothing
+        """
+
+        token = JitsiMeetToken(
+            domain=self.DOMAIN,
+            room=self.ROOM,
+            app_id=self.TOKEN_APP_ID,
+            secret=self.TOKEN_SECRET,
+            alg=self.TOKEN_ALG,
+            duration=self.TOKEN_DURATION,
+            context=self.TOKEN_CONTEXT,
+        )
+
+        str_token = token.generate(issue_date=self.ISSUE_DATE)
+        decoded_token = jwt.decode(str_token,
+                                   key=self.TOKEN_SECRET,
+                                   algorithm=self.TOKEN_ALG,
+                                   audience='*',
+                                   issuer=self.TOKEN_APP_ID,
+                                   verify=False
+                                   )
+
+        assert decoded_token.get('iss') == self.TOKEN_APP_ID
+        assert decoded_token.get('room') == self.ROOM
+        assert decoded_token.get('aud') == "*"
+        assert decoded_token.get('context')
+        assert decoded_token['context'].get('user')
+        assert decoded_token['context']['user'].get('name') == 'john'
+        assert decoded_token['context']['user'].get('email') == 'john@doe'
+        assert decoded_token['context']['user'].get('id') == '0'
+        assert decoded_token['context'].get('group') == 'test'
+        assert decoded_token.get('iat') == calendar.timegm(
+            self.ISSUE_DATE.utctimetuple()
+        )
+        assert decoded_token.get('iat') == decoded_token.get('nbf')
+        assert decoded_token.get('exp') == decoded_token.get('iat') + self.TOKEN_DURATION  # nopep8
+
+    def test_unit__generate_token_check_jwt(self) -> None:
+        """
+        Test only JWT validity and time params with default issue date
+        :return: Nothing
+        """
+        token = JitsiMeetToken(
+            domain=self.DOMAIN,
+            room=self.ROOM,
+            app_id=self.TOKEN_APP_ID,
+            secret=self.TOKEN_SECRET,
+            alg=self.TOKEN_ALG,
+            duration=self.TOKEN_DURATION,
+            context=self.TOKEN_CONTEXT,
+        )
+
+        str_token = token.generate()
+        decoded_token = jwt.decode(str_token,
+                                   key=self.TOKEN_SECRET,
+                                   algorithm=self.TOKEN_ALG,
+                                   audience='*',
+                                   issuer=self.TOKEN_APP_ID,
+                                   )
+
+        assert decoded_token.get('iat') == decoded_token.get('nbf')
+        assert decoded_token.get('exp') == decoded_token.get('iat') + self.TOKEN_DURATION  # nopep8
+
+
+class TestJitsiMeetUser(object):
+
+    def test_unit__as_dict(self):
+
+        user1 = JitsiMeetUser(jitsi_meet_user_id='1')
+        assert user1.as_dict() == {'id': '1'}
+
+        user2 = JitsiMeetUser(jitsi_meet_user_id='2', name='john')
+        assert user2.as_dict() == {'id': '2', 'name': 'john'}
+
+        user3 = JitsiMeetUser(jitsi_meet_user_id='3', name='john', email='a@b')
+        assert user3.as_dict() == {'id': '3', 'name': 'john', 'email': 'a@b'}
+
+        user4 = JitsiMeetUser(
+            jitsi_meet_user_id='4',
+            name='john',
+            email='a@b',
+            avatar_url='http://mysuperavatar/avatar.png'
+        )
+        assert user4.as_dict() == {
+            'id': '4',
+            'name': 'john',
+            'email': 'a@b',
+            'avatar': 'http://mysuperavatar/avatar.png',
+        }
+
+        user5 = JitsiMeetUser(
+            jitsi_meet_user_id='5',
+            name='john',
+            avatar_url='http://mysuperavatar/avatar.png'
+        )
+        assert user5.as_dict() == {
+            'id': '5',
+            'name': 'john',
+            'avatar': 'http://mysuperavatar/avatar.png',
+        }
+
+        user6 = JitsiMeetUser(
+            jitsi_meet_user_id='6',
+            email='a@b',
+            avatar_url='http://mysuperavatar/avatar.png'
+        )
+        assert user6.as_dict() == {
+            'id': '6',
+            'email': 'a@b',
+            'avatar': 'http://mysuperavatar/avatar.png',
+        }
+
+        user7 = JitsiMeetUser(
+            jitsi_meet_user_id='7',
+            email='a@b',
+        )
+        assert user7.as_dict() == {
+            'id': '7',
+            'email': 'a@b',
+        }
+
+        user8 = JitsiMeetUser(
+            jitsi_meet_user_id='8',
+            avatar_url='http://mysuperavatar/avatar.png'
+        )
+        assert user8.as_dict() == {
+            'id': '8',
+            'avatar': 'http://mysuperavatar/avatar.png',
+        }
+
+
+class TestJitsiMeetContext(object):
+
+    def test_unit__as_dict(self):
+
+        context = JitsiMeetContext()
+        assert context.as_dict() == {
+            'group': 'default'
+        }
+
+        context = JitsiMeetContext(group='group1')
+        assert context.as_dict() == {
+            'group': 'group1'
+        }
+
+        user = JitsiMeetUser(jitsi_meet_user_id='user')
+        context = JitsiMeetContext(group='group1', user=user)
+        assert context.as_dict() == {
+            'group': 'group1',
+            'user': user.as_dict()
+        }
+
+        callee = JitsiMeetUser(jitsi_meet_user_id='callee')
+        context = JitsiMeetContext(group='group1', user=user, callee=callee)
+        assert context.as_dict() == {
+            'group': 'group1',
+            'user': user.as_dict(),
+            'callee': callee.as_dict()
+        }