First alfa-tested release

rocketchat/calls/groups/get_private_room_info.py

+import logging
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetPrivateRoomInfo(RocketChatBase):
+    endpoint = '/api/v1/groups.info'
+
+    def build_endpoint(self, **kwargs):
+        return '{endpoint}?roomId={room_id}'.format(
+            endpoint=self.endpoint,
+            room_id=kwargs.get('room_id')
+        )
+
+    def post_response(self, result):
+        return result

rocketchat/calls/groups/get_private_rooms.py

+import logging
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetPrivateRooms(RocketChatBase):
+    endpoint = '/api/v1/groups.list'
+
+    def build_endpoint(self):
+        return self.endpoint
+
+    def post_response(self, result):
+        rooms = []
+
+        try:
+            _rooms = result.get('groups')
+
+            for room in _rooms:
+                room_dict = {}
+                room_dict['name'] = room.get('name')
+                room_dict['id'] = room.get('_id')
+                rooms.append(room_dict)
+
+        except Exception as e:
+            logger.error('Exception in fetching private rooms {e}'.format(
+                e=e
+            ), exc_info=True)
+
+        return rooms

rocketchat/calls/groups/get_room_id.py

+import logging
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetRoomId(RocketChatBase):
+    endpoint = '/api/v1/groups.info'
+
+    def build_endpoint(self, **kwargs):
+
+        return '{endpoint}?roomName={room_name}'.format(
+            endpoint=self.endpoint,
+            room_name=kwargs.get('room_name')
+        )
+
+    def post_response(self, result):
+        # print(result['group']['_id'])
+        return result['group']['_id']

rocketchat/calls/groups/set_room_topic.py

+import logging
+
+from rocketchat.calls.base import PostMixin, RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class SetRoomTopic(PostMixin, RocketChatBase):
+    endpoint = '/api/v1/groups.setTopic'
+
+    def build_endpoint(self, **kwargs):
+        return self.endpoint
+
+    def build_payload(self, **kwargs):
+        return {
+            'topic': kwargs.get('topic'),
+            'roomId': kwargs.get('room_id')
+        }
+
+    def post_response(self, result):
+        return result['success']

rocketchat/calls/groups/upload_file.py

+import logging
+
+from rocketchat.calls.base import RocketChatBase, PostMixin, logger
+logger.setLevel(logging.DEBUG)
+
+
+class UploadFile(PostMixin, RocketChatBase):
+    endpoint = '/api/v1/rooms.upload'
+
+    def build_endpoint(self, **kwargs):
+        return '{endpoint}/{room_id}'.format(endpoint=self.endpoint,
+                                             room_id=kwargs.get('room_id'))
+
+    def build_files(self, **kwargs):
+        return {'file': (kwargs.get('file'),
+                         open(kwargs.get('file'), 'rb'),
+                         kwargs.get('mime_type'))}
+
+    def build_payload(self, **kwargs):
+        return {'description': kwargs.get('description'), 'msg': kwargs.get('message')}
+
+    def post_response(self, result):
+        return result

rocketchat/calls/im/close_room.py

+import json
+import logging
+
+from rocketchat.calls.base import PostMixin, RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class CloseImRoom(PostMixin, RocketChatBase):
+    endpoint = "/api/v1/im.create"
+
+    def build_endpoint(self, **kwargs):
+        return self.endpoint
+
+    def build_payload(self, **kwargs):
+        return json.dumps({"roomId": kwargs.get("room_id")})
+
+    def post_response(self, result):
+        return result

rocketchat/calls/im/create_room.py

+import json
+import logging
+
+from rocketchat.calls.base import PostMixin, RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class CreateImRoom(PostMixin, RocketChatBase):
+    endpoint = "/api/v1/im.create"
+
+    def build_endpoint(self, **kwargs):
+        return self.endpoint
+
+    def build_payload(self, **kwargs):
+        return json.dumps({"username": kwargs.get("username")})
+
+    def post_response(self, result):
+        try:
+            _room = result.get('room')
+            room_dict = dict()
+            room_dict['id'] = _room.get('_id')
+
+            for username in _room.get("usernames"):
+                if username != self.settings["username"]:
+                    room_dict['username'] = username
+                    break
+
+        except Exception as e:
+            logger.error('Exception in creating im rooms {e}'.format(
+                e=e
+            ), exc_info=True)
+
+        return room_dict

rocketchat/calls/im/get_history.py

+import logging
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetImRoomHistory(RocketChatBase):
+    endpoint = '/api/v1/im.history'
+
+    def build_endpoint(self, **kwargs):
+        return '{endpoint}?roomId={room_id}&oldest={oldest}&inclusive={inclusive}'\
+                '&count={count}&unreads={unreads}&latest={latest}'.format(
+                 endpoint=self.endpoint,
+                 oldest=kwargs.get('oldest'),
+                 room_id=kwargs.get('room_id'),
+                 inclusive=kwargs.get('inclusive'),
+                 count=kwargs.get('count'),
+                 unreads=kwargs.get('unreads'),
+                 latest=kwargs.get('latest')
+                )
+
+    def post_response(self, result):
+        messages = []
+
+        try:
+            _messages = result.get('messages')
+
+            for msg in _messages:
+                msg_dict = dict()
+                msg_dict['msg'] = msg.get('msg')
+                msg_dict['room_id'] = msg.get('rid')
+                msg_dict['ts'] = msg.get('ts')
+                msg_dict['user'] = {
+                    'id': msg.get('u', {}).get('_id'),
+                    'username': msg.get('u', {}).get('username'),
+                }
+                msg_dict['id'] = msg.get('_id')
+
+                messages.append(msg_dict)
+
+        except Exception as e:
+            logger.error('Exception in fetching direct message rooms {e}'.format(
+                e=e
+            ), exc_info=True)
+
+        return messages

rocketchat/calls/im/get_rooms.py

+import logging
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetImRooms(RocketChatBase):
+    endpoint = "/api/v1/im.list"
+
+    def build_endpoint(self):
+        return self.endpoint
+
+    def post_response(self, result):
+        rooms = []
+
+        try:
+            _rooms = result.get("ims")
+
+            for room in _rooms:
+                if not room.get("usernames"):
+                    continue
+
+                for username in room.get("usernames"):
+                    if username != self.settings["username"]:
+                        break
+
+                room_dict = {}
+                room_dict["username"] = username
+                room_dict["id"] = room.get("_id")
+                rooms.append(room_dict)
+
+        except Exception as e:
+            logger.error(
+                "Exception in fetching im rooms {e}".format(e=e),
+                exc_info=True,
+            )
+
+        return rooms

rocketchat/calls/im/open_room.py

+import json
+import logging
+
+from rocketchat.calls.base import PostMixin, RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class OpenImRoom(PostMixin, RocketChatBase):
+    endpoint = "/api/v1/im.create"
+
+    def build_endpoint(self, **kwargs):
+        return self.endpoint
+
+    def build_payload(self, **kwargs):
+        return json.dumps({"roomId": kwargs.get("room_id")})
+
+    def post_response(self, result):
+        return result

rocketchat/calls/users/create_user.py

+import logging
+import json
+
+from rocketchat.calls.base import PostMixin, RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class CreateUser(PostMixin, RocketChatBase):
+    endpoint = '/api/v1/users.create'
+
+    def build_endpoint(self, **kwargs):
+        return self.endpoint
+
+    def build_payload(self, **kwargs):
+        return json.dumps({
+            'email': kwargs.get('email'),
+            'name': kwargs.get('name'),
+            'password': kwargs.get('password'),
+            'username': kwargs.get('username'),
+            'active': kwargs.get('active', True),
+            'roles': kwargs.get('roles', ['user']),
+            'joinDefaultChannels': kwargs.get('join_default_channels', True),
+            'requirePasswordChange': kwargs.get('require_password_change', False),
+            'sendWelcomeEmail': kwargs.get('send_welcome_email', False),
+            'verified': kwargs.get('verified', False),
+            'customFields': kwargs.get('customFields', {})
+        })
+
+    def post_response(self, result):
+        return result

rocketchat/calls/users/delete_user.py

+import logging
+import json
+
+from rocketchat.calls.base import PostMixin, RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class DeleteUser(PostMixin, RocketChatBase):
+    endpoint = '/api/v1/users.delete'
+
+    def build_endpoint(self, **kwargs):
+        return self.endpoint
+
+    def build_payload(self, **kwargs):
+        return json.dumps({
+            'userId': kwargs.get('user_id')
+        })
+
+    def post_response(self, result):
+        return result

rocketchat/calls/users/get_user_info.py

+import logging
+
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetUserInfo(RocketChatBase):
+    endpoint = '/api/v1/users.info'
+
+    def build_endpoint(self, **kwargs):
+        return '{endpoint}?userId={room_id}'.format(
+            endpoint=self.endpoint,
+            room_id=kwargs.get('user_id')
+        )
+
+    def post_response(self, result):
+        return result

rocketchat/calls/users/get_users.py

+import logging
+
+
+from rocketchat.calls.base import RocketChatBase
+
+logger = logging.getLogger(__name__)
+
+
+class GetUsers(RocketChatBase):
+    endpoint = '/api/v1/users.list'
+
+    def build_endpoint(self):
+        return self.endpoint
+
+    def post_response(self, result):
+        users = []
+
+        try:
+            _users = result.get('users')
+
+            for user in _users:
+                user_dict = dict()
+                user_dict['name'] = user.get('name')
+                user_dict['emails'] = [email['address'] for email in user.get('emails')]
+                user_dict['username'] = user.get('username')
+                user_dict['type'] = user.get('type')
+                user_dict['status'] = user.get('status')
+                user_dict['roles'] = user.get('roles')
+                user_dict['id'] = user.get('_id')
+                users.append(user_dict)
+
+        except Exception as e:
+            logger.error('Exception in fetching public rooms {e}'.format(
+                e=e
+            ), exc_info=True)
+
+        return users