Merge pull request #86 from stefan-qsd/develop

Message actions feature

Author: qsoftdevelopment

.pubnub.yml

@@ -1,8 +1,21 @@
 name: python
-version: 4.2.1
+version: 4.3.0
 schema: 1
 scm: github.com/pubnub/python
 changelog:
+  - version: v4.3.0
+    date: Jan 28, 2020
+    changes:
+      - type: feature
+        text: Implemented Message Actions API
+      - type: feature
+        text: Implemented Fetch Messages API
+      - type: feature
+        text: Added 'include_meta' to history()
+      - type: feature
+        text: Added 'include_meta' to fetch_messages()
+      - type: feature
+        text: Added 'include_message_actions' to fetch_messages()
   - version: v4.2.1
     date: Jan 9, 2020
     changes:
@@ -191,6 +204,9 @@ features:
     - STORAGE-START-END
     - STORAGE-COUNT
     - STORAGE-MESSAGE-COUNT
+    - STORAGE-HISTORY-WITH-META
+    - STORAGE-FETCH-WITH-META
+    - STORAGE-FETCH-WITH-MESSAGE-ACTIONS
   time:
     - TIME-TIME
   subscribe:
@@ -205,6 +221,7 @@ features:
     - SUBSCRIBE-USER-LISTENER
     - SUBSCRIBE-SPACE-LISTENER
     - SUBSCRIBE-MEMBERSHIP-LISTENER
+    - SUBSCRIBE-MESSAGE-ACTIONS-LISTENER
   signal:
     - SIGNAL-SEND
   objects:
@@ -228,6 +245,10 @@ features:
     - OBJECTS-ADD-MEMBERS
     - OBJECTS-UPDATE-MEMBERS
     - OBJECTS-REMOVE-MEMBERS
+  message-actions:
+    - MESSAGE-ACTIONS-GET
+    - MESSAGE-ACTIONS-ADD
+    - MESSAGE-ACTIONS-REMOVE
 
 supported-platforms:
   -

CHANGELOG.md

@@ -1,3 +1,13 @@
+## [4.3.0](https://github.com/pubnub/python/tree/v4.3.0)
+
+  [Full Changelog](https://github.com/pubnub/python/compare/v4.2.1...v4.3.0)
+
+- 🌟 Implemented Message Actions API
+- 🌟 Implemented Fetch Messages API
+- 🌟 Added 'include_meta' to history()
+- 🌟 Added 'include_meta' to fetch_messages()
+- 🌟 Added 'include_message_actions' to fetch_messages()
+
 ## [4.2.1](https://github.com/pubnub/python/tree/v4.2.1)
 
   [Full Changelog](https://github.com/pubnub/python/compare/v4.2.0...v4.2.1)

pubnub/callbacks.py

@@ -34,6 +34,9 @@ def space(self, pubnub, space):
     def membership(self, pubnub, membership):
         pass
 
+    def message_action(self, pubnub, message_action):
+        pass
+
 
 class ReconnectionCallback(object):
     @abstractmethod

pubnub/endpoints/fetch_messages.py

@@ -0,0 +1,138 @@
+import logging
+
+import six
+
+from pubnub import utils
+from pubnub.endpoints.endpoint import Endpoint
+from pubnub.enums import HttpMethod, PNOperationType
+from pubnub.errors import PNERR_CHANNEL_MISSING, PNERR_HISTORY_MESSAGE_ACTIONS_MULTIPLE_CHANNELS
+from pubnub.exceptions import PubNubException
+from pubnub.models.consumer.history import PNFetchMessagesResult
+
+logger = logging.getLogger("pubnub")
+
+
+class FetchMessages(Endpoint):
+    FETCH_MESSAGES_PATH = "/v3/history/sub-key/%s/channel/%s"
+    FETCH_MESSAGES_WITH_ACTIONS_PATH = "/v3/history-with-actions/sub-key/%s/channel/%s"
+
+    DEFAULT_MESSAGES = 100
+    MAX_MESSAGES = 25
+    MAX_MESSAGES_ACTIONS = 100
+
+    def __init__(self, pubnub):
+        Endpoint.__init__(self, pubnub)
+        self._channels = []
+        self._start = None
+        self._end = None
+        self._maximum_per_channel = None
+        self._include_meta = None
+        self._include_message_actions = None
+
+    def channels(self, channels):
+        utils.extend_list(self._channels, channels)
+        return self
+
+    def maximum_per_channel(self, maximum_per_channel):
+        assert isinstance(maximum_per_channel, six.integer_types)
+        self._maximum_per_channel = maximum_per_channel
+        return self
+
+    def start(self, start):
+        assert isinstance(start, six.integer_types)
+        self._start = start
+        return self
+
+    def end(self, end):
+        assert isinstance(end, six.integer_types)
+        self._end = end
+        return self
+
+    def include_meta(self, include_meta):
+        assert isinstance(include_meta, bool)
+        self._include_meta = include_meta
+        return self
+
+    def include_message_actions(self, include_message_actions):
+        assert isinstance(include_message_actions, bool)
+        self._include_message_actions = include_message_actions
+        return self
+
+    def custom_params(self):
+        params = {'max': str(self._maximum_per_channel)}
+
+        if self._start is not None:
+            params['start'] = str(self._start)
+
+        if self._end is not None:
+            params['end'] = str(self._end)
+
+        if self._include_meta is not None:
+            params['include_meta'] = "true" if self._include_meta else "false"
+
+        return params
+
+    def build_path(self):
+        if self._include_message_actions is False:
+            return FetchMessages.FETCH_MESSAGES_PATH % (
+                self.pubnub.config.subscribe_key,
+                utils.join_channels(self._channels)
+            )
+        else:
+            return FetchMessages.FETCH_MESSAGES_WITH_ACTIONS_PATH % (
+                self.pubnub.config.subscribe_key,
+                utils.url_encode(self._channels[0])
+            )
+
+    def http_method(self):
+        return HttpMethod.GET
+
+    def is_auth_required(self):
+        return True
+
+    def validate_params(self):
+        self.validate_subscribe_key()
+
+        if self._channels is None or len(self._channels) == 0:
+            raise PubNubException(pn_error=PNERR_CHANNEL_MISSING)
+
+        if self._include_meta is None:
+            self._include_meta = False
+
+        if self._include_message_actions is None:
+            self._include_message_actions = False
+
+        if self._include_message_actions is False:
+            if self._maximum_per_channel is None or self._maximum_per_channel < FetchMessages.DEFAULT_MESSAGES:
+                self._maximum_per_channel = FetchMessages.DEFAULT_MESSAGES
+                logger.info("maximum_per_channel param defaulting to %d", FetchMessages.DEFAULT_MESSAGES)
+            elif self._maximum_per_channel > FetchMessages.MAX_MESSAGES:
+                self._maximum_per_channel = FetchMessages.MAX_MESSAGES
+                logger.info("maximum_per_channel param defaulting to %d", FetchMessages.DEFAULT_MESSAGES)
+        else:
+            if len(self._channels) > 1:
+                raise PubNubException(pn_error=PNERR_HISTORY_MESSAGE_ACTIONS_MULTIPLE_CHANNELS)
+
+            if self._maximum_per_channel is None or self._maximum_per_channel < 1 or\
+                    self._maximum_per_channel > FetchMessages.MAX_MESSAGES_ACTIONS:
+                self._maximum_per_channel = FetchMessages.MAX_MESSAGES_ACTIONS
+                logger.info("maximum_per_channel param defaulting to %d", FetchMessages.DEFAULT_MESSAGES)
+
+    def create_response(self, envelope):  # pylint: disable=W0221
+        return PNFetchMessagesResult.from_json(
+            json_input=envelope,
+            include_message_actions=self._include_message_actions,
+            start_timetoken=self._start,
+            end_timetoken=self._end)
+
+    def request_timeout(self):
+        return self.pubnub.config.non_subscribe_request_timeout
+
+    def connect_timeout(self):
+        return self.pubnub.config.connect_timeout
+
+    def operation_type(self):
+        return PNOperationType.PNFetchMessagesOperation
+
+    def name(self):
+        return "Fetch messages"

pubnub/endpoints/history.py

@@ -18,6 +18,7 @@ def __init__(self, pubnub):
         self._reverse = None
         self._count = None
         self._include_timetoken = None
+        self._include_meta = None
 
     def channel(self, channel):
         self._channel = channel
@@ -48,6 +49,11 @@ def include_timetoken(self, include_timetoken):
         self._include_timetoken = include_timetoken
         return self
 
+    def include_meta(self, include_meta):
+        assert isinstance(include_meta, bool)
+        self._include_meta = include_meta
+        return self
+
     def custom_params(self):
         params = {}
 
@@ -68,6 +74,9 @@ def custom_params(self):
         if self._include_timetoken is not None:
             params['include_token'] = "true" if self._include_timetoken else "false"
 
+        if self._include_meta is not None:
+            params['include_meta'] = "true" if self._include_meta else "false"
+
         return params
 
     def build_path(self):
@@ -90,7 +99,8 @@ def create_response(self, envelope):
         return PNHistoryResult.from_json(
             json_input=envelope,
             crypto=self.pubnub.config.crypto,
-            include_tt_option=self._include_timetoken,
+            include_timetoken=self._include_timetoken,
+            include_meta=self._include_meta,
             cipher=self.pubnub.config.cipher_key)
 
     def request_timeout(self):

pubnub/endpoints/message_actions/__init__.py

@@ -0,0 +1,81 @@
+from pubnub import utils
+from pubnub.endpoints.endpoint import Endpoint
+from pubnub.errors import PNERR_MESSAGE_ACTION_VALUE_MISSING, PNERR_MESSAGE_ACTION_TYPE_MISSING, \
+    PNERR_MESSAGE_TIMETOKEN_MISSING, PNERR_MESSAGE_ACTION_MISSING
+from pubnub.exceptions import PubNubException
+from pubnub.enums import HttpMethod, PNOperationType
+from pubnub.models.consumer.message_actions import PNAddMessageActionResult
+
+
+class AddMessageAction(Endpoint):
+    ADD_MESSAGE_ACTION_PATH = "/v1/message-actions/%s/channel/%s/message/%s"
+
+    def __init__(self, pubnub):
+        Endpoint.__init__(self, pubnub)
+        self._channel = None
+        self._message_action = None
+
+    def channel(self, channel):
+        self._channel = str(channel)
+        return self
+
+    def message_action(self, message_action):
+        self._message_action = message_action
+        return self
+
+    def custom_params(self):
+        return {}
+
+    def build_data(self):
+        params = {
+            'type': self._message_action.type,
+            'value': self._message_action.value
+        }
+
+        return utils.write_value_as_string(params)
+
+    def build_path(self):
+        return AddMessageAction.ADD_MESSAGE_ACTION_PATH % (
+            self.pubnub.config.subscribe_key,
+            utils.url_encode(self._channel),
+            self._message_action.message_timetoken
+        )
+
+    def http_method(self):
+        return HttpMethod.POST
+
+    def validate_params(self):
+        self.validate_subscribe_key()
+        self.validate_channel()
+        self.validate_message_action()
+
+    def create_response(self, envelope):  # pylint: disable=W0221
+        return PNAddMessageActionResult(envelope['data'])
+
+    def is_auth_required(self):
+        return True
+
+    def request_timeout(self):
+        return self.pubnub.config.non_subscribe_request_timeout
+
+    def connect_timeout(self):
+        return self.pubnub.config.connect_timeout
+
+    def operation_type(self):
+        return PNOperationType.PNAddMessageAction
+
+    def name(self):
+        return "Add message action"
+
+    def validate_message_action(self):
+        if self._message_action is None:
+            raise PubNubException(pn_error=PNERR_MESSAGE_ACTION_MISSING)
+
+        if self._message_action.message_timetoken is None:
+            raise PubNubException(pn_error=PNERR_MESSAGE_TIMETOKEN_MISSING)
+
+        if self._message_action.type is None or len(self._message_action.type) == 0:
+            raise PubNubException(pn_error=PNERR_MESSAGE_ACTION_TYPE_MISSING)
+
+        if self._message_action.value is None or len(self._message_action.value) == 0:
+            raise PubNubException(pn_error=PNERR_MESSAGE_ACTION_VALUE_MISSING)