Feature/additional space and message type fields

.github/workflows/run-tests.yml

@@ -74,9 +74,13 @@ jobs:
             cp sdk-specifications/features/access/authorization-failure-reporting.feature tests/acceptance/pam
             cp sdk-specifications/features/access/grant-token.feature tests/acceptance/pam
             cp sdk-specifications/features/access/revoke-token.feature tests/acceptance/pam
+            cp sdk-specifications/features/files/file-upload-to-space.feature tests/acceptance/files
+            cp sdk-specifications/features/history/history-vsp.feature tests/acceptance/history
 
             sudo pip3 install -r requirements-dev.txt
             behave --junit tests/acceptance/pam
+            behave --junit tests/acceptance/files
+            behave --junit tests/acceptance/history
       - name: Expose acceptance tests reports
         uses: actions/upload-artifact@v3
         if: always()

pubnub/endpoints/fetch_messages.py

@@ -31,7 +31,8 @@ def __init__(self, pubnub):
         self._count = None
         self._include_meta = None
         self._include_message_actions = None
-        self._include_message_type = None
+        self._include_message_type = True
+        self._include_space_id = None
         self._include_uuid = None
 
     def channels(self, channels):
@@ -76,8 +77,17 @@ def include_uuid(self, include_uuid):
         self._include_uuid = include_uuid
         return self
 
+    def include_space_id(self, include_space_id):
+        assert isinstance(include_space_id, bool)
+        self._include_space_id = include_space_id
+        return self
+
     def custom_params(self):
-        params = {'max': int(self._count)}
+        params = {
+            'max': int(self._count),
+            'include_type': 'true' if self._include_message_type else 'false',
+            'include_message_type': 'true' if self._include_message_type else 'false',
+        }
 
         if self._start is not None:
             params['start'] = str(self._start)
@@ -88,8 +98,8 @@ def custom_params(self):
         if self._include_meta is not None:
             params['include_meta'] = "true" if self._include_meta else "false"
 
-        if self._include_message_type is not None:
-            params['include_message_type'] = "true" if self._include_message_type else "false"
+        if self._include_space_id is not None:
+            params['include_space_id'] = "true" if self._include_space_id else "false"
 
         if self.include_message_actions and self._include_uuid is not None:
             params['include_uuid'] = "true" if self._include_uuid else "false"
@@ -154,6 +164,8 @@ def create_response(self, envelope):  # pylint: disable=W0221
         return PNFetchMessagesResult.from_json(
             json_input=envelope,
             include_message_actions=self._include_message_actions,
+            include_message_type=self._include_message_type,
+            include_space_id=self._include_space_id,
             start_timetoken=self._start,
             end_timetoken=self._end)
 

pubnub/endpoints/file_operations/publish_file_message.py

@@ -3,6 +3,8 @@
 from pubnub import utils
 from pubnub.models.consumer.file import PNPublishFileMessageResult
 from pubnub.endpoints.mixins import TimeTokenOverrideMixin
+from pubnub.models.consumer.message_type import PNMessageType
+from typing import Union
 
 
 class PublishFileMessage(FileOperationEndpoint, TimeTokenOverrideMixin):
@@ -20,6 +22,8 @@ def __init__(self, pubnub):
         self._cipher_key = None
         self._replicate = None
         self._ptto = None
+        self._message_type = None
+        self._space_id = None
 
     def meta(self, meta):
         self._meta = meta
@@ -49,6 +53,14 @@ def file_name(self, file_name):
         self._file_name = file_name
         return self
 
+    def message_type(self, message_type: Union[PNMessageType, str]):
+        self._message_type = message_type
+        return self
+
+    def space_id(self, space_id):
+        self._space_id = str(space_id)
+        return self
+
     def _encrypt_message(self, message):
         if self._cipher_key or self._pubnub.config.cipher_key:
             return self._pubnub.config.crypto.encrypt(
@@ -87,6 +99,12 @@ def custom_params(self):
             "ttl": self._ttl,
             "store": 1 if self._should_store else 0
         })
+        if self._message_type is not None:
+            params['type'] = str(self._message_type)
+
+        if self._space_id is not None:
+            params['space-id'] = str(self._space_id)
+
         return params
 
     def is_auth_required(self):

pubnub/endpoints/file_operations/send_file.py

@@ -1,12 +1,13 @@
 from pubnub.endpoints.file_operations.file_based_endpoint import FileOperationEndpoint
-
 from pubnub.crypto import PubNubFileCrypto
 from pubnub.enums import HttpMethod, PNOperationType
 from pubnub.models.consumer.file import PNSendFileResult
 from pubnub.endpoints.file_operations.publish_file_message import PublishFileMessage
 from pubnub.endpoints.file_operations.fetch_upload_details import FetchFileUploadS3Data
 from pubnub.request_handlers.requests_handler import RequestsRequestHandler
 from pubnub.endpoints.mixins import TimeTokenOverrideMixin
+from pubnub.models.consumer.message_type import PNMessageType
+from typing import Union
 
 
 class SendFileNative(FileOperationEndpoint, TimeTokenOverrideMixin):
@@ -23,6 +24,8 @@ def __init__(self, pubnub):
         self._file_object = None
         self._replicate = None
         self._ptto = None
+        self._message_type = None
+        self._space_id = None
 
     def file_object(self, fd):
         self._file_object = fd
@@ -69,7 +72,14 @@ def is_compressable(self):
         return True
 
     def custom_params(self):
-        return {}
+        params = {}
+        if self._message_type is not None:
+            params['type'] = str(self._message_type)
+
+        if self._space_id is not None:
+            params['space-id'] = str(self._space_id)
+
+        return params
 
     def validate_params(self):
         self.validate_subscribe_key()
@@ -110,6 +120,14 @@ def cipher_key(self, cipher_key):
         self._cipher_key = cipher_key
         return self
 
+    def message_type(self, message_type: Union[PNMessageType, str]):
+        self._message_type = message_type
+        return self
+
+    def space_id(self, space_id):
+        self._space_id = str(space_id)
+        return self
+
     def create_response(self, envelope, data=None):
         return PNSendFileResult(envelope, self._file_upload_envelope)
 
@@ -139,7 +157,9 @@ def sync(self):
             ttl(self._ttl).\
             replicate(self._replicate).\
             ptto(self._ptto).\
-            cipher_key(self._cipher_key).sync()
+            cipher_key(self._cipher_key).\
+            message_type(self._message_type).\
+            space_id(self._space_id).sync()
 
         response_envelope.result.timestamp = publish_file_response.result.timestamp
         return response_envelope

pubnub/endpoints/pubsub/publish.py

@@ -5,6 +5,8 @@
 from pubnub.models.consumer.pubsub import PNPublishResult
 from pubnub.enums import HttpMethod, PNOperationType
 from pubnub.endpoints.mixins import TimeTokenOverrideMixin
+from pubnub.models.consumer.message_type import PNMessageType
+from typing import Union
 
 
 class Publish(Endpoint, TimeTokenOverrideMixin):
@@ -15,7 +17,9 @@ class Publish(Endpoint, TimeTokenOverrideMixin):
     def __init__(self, pubnub):
         super(Publish, self).__init__(pubnub)
         self._channel = None
+        self._space_id = None
         self._message = None
+        self._message_type = None
         self._should_store = None
         self._use_post = None
         self._meta = None
@@ -27,10 +31,18 @@ def channel(self, channel):
         self._channel = str(channel)
         return self
 
+    def space_id(self, space_id):
+        self._space_id = str(space_id)
+        return self
+
     def message(self, message):
         self._message = message
         return self
 
+    def message_type(self, message_type: Union[PNMessageType, str]):
+        self._message_type = message_type
+        return self
+
     def use_post(self, use_post):
         self._use_post = bool(use_post)
         return self
@@ -91,6 +103,12 @@ def custom_params(self):
         if self.pubnub.config.auth_key is not None:
             params["auth"] = utils.url_encode(self.pubnub.config.auth_key)
 
+        if self._message_type is not None:
+            params['type'] = str(self._message_type)
+
+        if self._space_id is not None:
+            params['space-id'] = str(self._space_id)
+
         return params
 
     def build_path(self):

pubnub/endpoints/signal.py

@@ -2,6 +2,8 @@
 from pubnub.endpoints.endpoint import Endpoint
 from pubnub.enums import HttpMethod, PNOperationType
 from pubnub.models.consumer.signal import PNSignalResult
+from pubnub.models.consumer.message_type import PNMessageType
+from typing import Union
 
 
 class Signal(Endpoint):
@@ -11,6 +13,8 @@ def __init__(self, pubnub):
         Endpoint.__init__(self, pubnub)
         self._channel = None
         self._message = None
+        self._space = None
+        self._message_type = None
 
     def channel(self, channel):
         self._channel = str(channel)
@@ -20,6 +24,14 @@ def message(self, message):
         self._message = message
         return self
 
+    def space_id(self, space):
+        self._space = str(space)
+        return self
+
+    def message_type(self, message_type: Union[PNMessageType, str]):
+        self._message_type = message_type
+        return self
+
     def build_path(self):
         stringified_message = utils.write_value_as_string(self._message)
         msg = utils.url_encode(stringified_message)
@@ -29,7 +41,15 @@ def build_path(self):
         )
 
     def custom_params(self):
-        return {}
+        params = {}
+
+        if self._message_type is not None:
+            params['type'] = str(self._message_type)
+
+        if self._space is not None:
+            params['space-id'] = str(self._space)
+
+        return params
 
     def http_method(self):
         return HttpMethod.GET

pubnub/models/consumer/history.py

@@ -1,3 +1,6 @@
+from pubnub.models.consumer.message_type import PNMessageType
+
+
 class PNHistoryResult(object):
     def __init__(self, messages, start_timetoken, end_timetoken):
         self.messages = messages
@@ -63,7 +66,8 @@ def __str__(self):
         return "Fetch messages result for range %d..%d" % (self.start_timetoken, self.end_timetoken)
 
     @classmethod
-    def from_json(cls, json_input, include_message_actions=False, start_timetoken=None, end_timetoken=None):
+    def from_json(cls, json_input, include_message_actions=False, include_message_type=False, include_space_id=False,
+                  start_timetoken=None, end_timetoken=None):
         channels = {}
 
         for key, entry in json_input['channels'].items():
@@ -84,6 +88,14 @@ def from_json(cls, json_input, include_message_actions=False, start_timetoken=No
                     else:
                         message.actions = {}
 
+                if include_message_type:
+                    message.message_type = PNMessageType.from_response(
+                        message_type=item['type'] if 'type' in item.keys() else None,
+                        pn_message_type=item['message_type'])
+
+                if include_space_id:
+                    message.space_id = item['space_id']
+
                 channels[key].append(message)
 
         return PNFetchMessagesResult(

pubnub/models/consumer/message_type.py

@@ -0,0 +1,27 @@
+class PNMessageType:
+    pn_message_type: str = None
+    message_type: str = None
+    _type_mapping = {
+        'None': 'message',
+        '0': 'message',
+        '1': 'signal',
+        '2': 'object',
+        '3': 'message_action',
+        '4': 'file',
+    }
+
+    def __init__(self, message_type: str = None) -> None:
+        self.message_type = message_type
+
+    def set_pn_message_type(self, pn_message_type: str):
+        self.pn_message_type = self._type_mapping[str(pn_message_type)]
+        return self
+
+    def from_response(message_type: str = None, pn_message_type: str = None):
+        return PNMessageType(message_type).set_pn_message_type(pn_message_type)
+
+    def __str__(self) -> str:
+        return self.message_type if self.message_type is not None else str(self.pn_message_type)
+
+    def toJSON(self) -> str:
+        return str(self)

pubnub/models/consumer/pubsub.py

@@ -2,8 +2,8 @@
 
 
 class PNMessageResult(object):
-    def __init__(self, message, subscription, channel, timetoken, user_metadata=None, publisher=None):
-
+    def __init__(self, message, subscription, channel, timetoken, user_metadata=None, publisher=None, message_type=None,
+                 space_id=None):
         if subscription is not None:
             assert isinstance(subscription, str)
 
@@ -29,6 +29,8 @@ def __init__(self, message, subscription, channel, timetoken, user_metadata=None
         self.timetoken = timetoken
         self.user_metadata = user_metadata
         self.publisher = publisher
+        self.type = message_type
+        self.space_id = space_id
 
 
 class PNSignalMessageResult(PNMessageResult):

pubnub/models/server/subscribe.py

@@ -1,3 +1,6 @@
+from pubnub.models.consumer.message_type import PNMessageType
+
+
 class SubscribeEnvelope:
     def __init__(self, messages=None, metadata=None):
         assert isinstance(messages, (list, None))
@@ -30,6 +33,8 @@ def __init__(self):
         self.publish_metadata = None
         self.only_channel_subscription = False
         self.type = 0
+        self.message_type = None
+        self.space_id = None
 
     @classmethod
     def from_json(cls, json_input):
@@ -49,6 +54,16 @@ def from_json(cls, json_input):
         message.publish_metadata = PublishMetadata.from_json(json_input['p'])
         if 'e' in json_input:
             message.type = json_input['e']
+
+        if 'si' in json_input:
+            message.space_id = json_input['si']
+
+        if 'mt' in json_input:
+            if 'e' in json_input:
+                message.message_type = PNMessageType.from_response(json_input['mt'], json_input['e'])
+            else:
+                message.message_type = PNMessageType(json_input['mt'])
+
         return message
 
 

pubnub/workers.py

@@ -172,6 +172,8 @@ def _process_incoming_payload(self, message):
                     channel=channel,
                     subscription=subscription_match,
                     timetoken=publish_meta_data.publish_timetoken,
-                    publisher=publisher
+                    publisher=publisher,
+                    message_type=message.message_type,
+                    space_id=message.space_id
                 )
                 self._listener_manager.announce_message(pn_message_result)