Refactoring of Jitsi-Meet integration : better organisation and context from jitsi token support

tracim/tracim/controllers/jitsi_meet.py

+import typing
 import tg
 from tg import abort
 from tg import expose
 from tracim.lib.predicates import current_user_is_reader
 from sqlalchemy.orm.exc import NoResultFound
 
-from tracim.lib.utils import str_as_alpha_num_str
-from tracim.lib.jitsi_meet.jitsi_meet import JitsiMeetRoom
-from tracim.lib.jitsi_meet.jitsi_meet import JitsiTokenConfig
+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
 
         except NoResultFound:
             abort(404)
 
-
     @tg.require(current_user_is_reader())
     @expose('tracim.templates.videoconf.jitsi_meet')
     def get(self):
-        return self._process()
+        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):
-        return self._process()
+        return self._jitsi_room()
 
-    def _process(self):
+    @classmethod
+    def _jitsi_room(
+            cls,
+            jitsi_user: typing.Union[JitsiMeetUser, User, None]=None,
+    ):
         cfg = CFG.get_instance()
         if not cfg.JITSI_MEET_ACTIVATED:
             abort(404)
         dictified_workspace = Context(CTX.WORKSPACE).toDict(workspace,
                                                             'workspace')
 
-        # TODO - G.M - 18-01-2017 -
-        # allow to set specific room name from workspace object ?
-        room = "{uuid}{workspace_id}{workspace_label}".format(
-            uuid=cfg.TRACIM_INSTANCE_UUID,
-            workspace_id=workspace.workspace_id,
-            workspace_label=workspace.label)
-
-        # Jitsi-Meet doesn't like specials_characters
-        room = str_as_alpha_num_str(room)
-
-        token = None
-        if cfg.JITSI_MEET_USE_TOKEN:
-            if cfg.JITSI_MEET_TOKEN_GENERATOR == 'local':
-                token = JitsiTokenConfig(
-                    app_id=cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_APP_ID,
-                    secret=cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_SECRET,
-                    alg=cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_ALG,
-                    duration=cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_DURATION,
-                )
-            else:
-                abort(400)
-
         jitsi_meet_room = JitsiMeetRoom(
-            room=room,
-            domain=cfg.JITSI_MEET_DOMAIN,
-            token_config=token)
+            issuer=jitsi_user,
+            receivers=workspace,
+        )
 
         return DictLikeClass(fake_api=fake_api,
                              result=dictified_workspace,

tracim/tracim/lib/jitsi_meet/jitsi_meet.py

-import datetime
-import typing
-
-import jwt
-
-class NoTokenConfigError(Exception):
-    pass
-
-class JitsiTokenConfig(object):
-
-    def __init__(self,
-                 app_id: str,
-                 secret: str,
-                 alg: str,
-                 duration: int,
-                 )-> None:
-        """
-        JWT token generator config for JitsiMeet,
-        :param app_id: application identifier
-        :param secret: secret share between token generator and XMPP server
-        :param alg: algorithm used
-        :param duration: duration of token
-        """
-        self.app_id = app_id
-        self.secret = secret
-        self.alg = alg
-        self.duration = duration
-
-
-class JitsiMeetRoom(object):
-
-    def __init__(self,
-                 domain: str,
-                 room: str,
-                 token_config: typing.Optional[JitsiTokenConfig],
-                 ) -> None:
-        """
-        JitsiMeet room Parameters
-        :param domain: jitsi-meet domain
-        :param room: room name
-        :param token_config: token config, None if token not used.
-        """
-        self.domain = domain
-        self.room = room
-        self.token_config = token_config
-
-    def generate_token(self) -> str:
-        """
-        Create jwt token according to room name and config
-        see https://github.com/jitsi/lib-jitsi-meet/blob/master/doc/tokens.md
-        :return: jwt encoded token as string
-        """
-        if not self.token_config:
-            raise NoTokenConfigError
-        now = datetime.datetime.utcnow()
-        exp = now+datetime.timedelta(seconds=self.token_config.duration)
-        data = {
-            "iss": self.token_config.app_id,  # Issuer
-            "room": self.room,  # Custom-param for jitsi_meet
-            "aud": "*",  # TODO: Understood this param
-            "exp": exp,  # Expiration date
-            "nbf": now,  # NotBefore
-            "iat": now,   # IssuedAt
-        }
-        jwt_token = jwt.encode(data,
-                               self.token_config.secret,
-                               algorithm=self.token_config.alg)
-        return jwt_token.decode("utf-8")
-
-    def generate_url(self) -> str:
-        """
-        Generate url with or without token
-        :return: url as string
-        """
-        if self.token_config:
-            token = self.generate_token()
-            url = "{}/{}?jwt={}".format(self.domain,
-                                        self.room,
-                                        token,)
-        else:
-            url = "{}/{}".format(self.domain,
-                                 self.room,)
-        return "https://{}".format(url)

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 JitsiMeetNoTokenGenerator(Exception):
+    pass
+
+
+class JitsiMeetTokenNotActivated(Exception):
+    pass
+
+
+class JitsiMeetRoom(object):
+    def __init__(
+            self,
+            receivers: Workspace,
+            issuer: typing.Union[User, JitsiMeetUser, None]=None,
+    ) -> None:
+        """
+        :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._set_domain()
+        self._set_token_params()
+        self._set_context(
+            receivers=receivers,
+            issuer=issuer,
+        )
+        self.room = self._generate_room_name(receivers)
+
+    def _set_domain(self):
+        cfg = CFG.get_instance()
+        self.domain = cfg.JITSI_MEET_DOMAIN
+
+    def _set_token_params(self):
+        cfg = CFG.get_instance()
+        self.use_token = cfg.JITSI_MEET_USE_TOKEN
+        if self.use_token:
+            if cfg.JITSI_MEET_TOKEN_GENERATOR == 'local':
+                self.token_app_id = cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_APP_ID  # nopep8
+                self.token_secret = cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_SECRET  # nopep8
+                self.token_alg = cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_ALG
+                self.token_duration = cfg.JITSI_MEET_TOKEN_GENERATOR_LOCAL_DURATION  # nopep8
+            else:
+                raise JitsiMeetNoTokenGenerator
+
+    def _set_context(
+            self,
+            receivers: Workspace,
+            issuer: typing.Union[User, JitsiMeetUser, None],
+    ):
+
+        # User
+        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(
+                jitsi_meet_user_id=str(uuid.uuid4()),
+            )
+
+        # Group
+        group = receivers.label
+
+        self.context = JitsiMeetContext(
+            user=user,
+            group=group,
+        )
+
+    @classmethod
+    def _generate_room_name(cls, workspace: Workspace):
+        cfg = CFG.get_instance()
+        room = "{uuid}{workspace_id}{workspace_label}".format(
+            uuid=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_token(self) -> 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 url with or without 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)

tracim/tracim/lib/jitsi_meet/token.py

+import datetime
+import typing
+import jwt
+
+
+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,
+    ):
+        """
+
+        :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:
+        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",
+    ):
+        """
+        Context as in JitsiToken Payload
+        see https://github.com/jitsi/lib-jitsi-meet/blob/52eb3decf6542413c739ce2209456fac728a89d5/doc/tokens.md  # nopep8
+        :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:
+        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 JitsiMeet,
+        :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) -> str:
+        now = datetime.datetime.utcnow()
+        exp = now+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": now,  # NotBefore
+            "iat": now,   # 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/templates/videoconf/invite.mak

         <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()}</textarea>
+        <textarea readonly=readonly wrap="off" style="width: 100%;">${jitsi_meet_room.generate_url(jitsi_meet_room.generate_token())}</textarea>
     </div>
     <div class="modal-footer">
         <button type="button" class="btn btn-default" data-dismiss="modal">${_('Close')}</button>

tracim/tracim/templates/videoconf/jitsi_meet.mak

         var options = {
 	    // jitsi-meet support now(10-2017) only one way to auto-auth, token,
 	    // which is anonymous BOSH auth with specific url (with token value in params of the url).
-            %if jitsi_meet_room.token_config:
+            %if jitsi_meet_room.use_token:
                 jwt: '${jitsi_meet_room.generate_token()}',
             %endif
             roomName : '${jitsi_meet_room.room}',
         // 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
-        api.executeCommand('displayName', '${fake_api.current_user.name}');
-        // We can override also avatar.
-        api.executeCommand('avatarUrl', 'https://avatars0.githubusercontent.com/u/3671647');
+        % 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">

tracim/tracim/tests/library/test_jitsi_meet.py

-import datetime
-
-import jwt
-from nose.tools import raises
-
-from tracim.lib.jitsi_meet.jitsi_meet import JitsiTokenConfig
-from tracim.lib.jitsi_meet.jitsi_meet import JitsiMeetRoom
-from tracim.lib.jitsi_meet.jitsi_meet import NoTokenConfigError
-
-
-class TestJitsiMeetRoom(object):
-
-    TOKEN_CONFIG = JitsiTokenConfig(
-        app_id='test',
-        secret='secret',
-        alg='HS256',
-        duration=60,
-    )
-    ROOM = 'room'
-    DOMAIN = 'tracim'
-
-    def test_unit__generate_token(self) -> None:
-
-        jmr = JitsiMeetRoom(
-            domain=self.DOMAIN,
-            room=self.ROOM,
-            token_config=self.TOKEN_CONFIG,
-        )
-        str_token = jmr.generate_token()
-        decoded_token = jwt.decode(str_token,
-                                   key=self.TOKEN_CONFIG.secret,
-                                   algorithm=self.TOKEN_CONFIG.alg,
-                                   audience='*',
-                                   issuer=self.TOKEN_CONFIG.app_id,
-                                   )
-        assert decoded_token.get('room') == self.ROOM
-        assert decoded_token.get('iat')
-        assert decoded_token.get('iat') == decoded_token.get('nbf')
-        assert decoded_token.get('exp') == decoded_token.get('iat') + self.TOKEN_CONFIG.duration  # nopep8
-
-    @raises(NoTokenConfigError)
-    def test_unit__generate_token__no_token(self) -> None:
-        jmr = JitsiMeetRoom(
-            domain=self.DOMAIN,
-            room=self.ROOM,
-            token_config=None,
-        )
-        jmr.generate_token()
-
-    def test_unit__generate_url_token(self) -> None:
-        jmr = JitsiMeetRoom(
-            domain=self.DOMAIN,
-            room=self.ROOM,
-            token_config=self.TOKEN_CONFIG,
-        )
-
-        def generate_token():
-            return 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MTYyNzA3NzksImlzcyI6InRlc3QiLCJhdWQiOiIqIiwibmJmIjoxNTE2MjcwNzE5LCJyb29tIjoicm9vbSIsImlhdCI6MTUxNjI3MDcxOX0.zqFBUcPGjlCfXTjuFP7brqalY8TKlgcg6DUE72KhCx0'  # nopep8
-
-        jmr.generate_token = generate_token
-        url = jmr.generate_url()
-        assert url == 'https://{domain}/{room}?jwt={token}'.format(
-            domain=self.DOMAIN,
-            room=self.ROOM,
-            token=generate_token()
-        )
-
-    def test_unit__generate_url_no_token(self) -> None:
-        jmr = JitsiMeetRoom(
-            domain=self.DOMAIN,
-            room=self.ROOM,
-            token_config=None,
-        )
-        url = jmr.generate_url()
-        assert url == 'https://{domain}/{room}'.format(
-            domain=self.DOMAIN,
-            room=self.ROOM,
-        )

tracim/tracim/tests/library/test_jitsi_meet_token.py

+import jwt
+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'
+
+    def test_unit__generate_token(self) -> None:
+
+        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('room') == self.ROOM
+        assert decoded_token.get('iat')
+        assert decoded_token.get('iat') == decoded_token.get('nbf')
+        assert decoded_token.get('exp') == decoded_token.get('iat') + self.TOKEN_DURATION  # nopep8