adding metadata and tags to message

Author: david-schrenker

socketlabs/injectionapi/message/__imports__.py

@@ -4,4 +4,5 @@
 from .bulkrecipient import BulkRecipient
 from .customheader import CustomHeader
 from .emailaddress import EmailAddress
-from .messagebase import MessageBase
+from .messagebase import MessageBase
+from .metadata import Metadata

socketlabs/injectionapi/message/basicmessage.py

@@ -2,6 +2,7 @@
 from .customheader import CustomHeader
 from .emailaddress import EmailAddress
 from .messagebase import MessageBase
+from .metadata import Metadata
 
 
 class BasicMessage(MessageBase):
@@ -30,7 +31,7 @@ class BasicMessage(MessageBase):
         message.add_to_email_address(EmailAddress("[email protected]", "Recipient #4"))
 
     """
-    
+
     def __init__(self):
         self._subject = None
         self._plain_text_body = None
@@ -47,6 +48,8 @@ def __init__(self):
         self._to_recipients = []
         self._cc_recipients = []
         self._bcc_recipients = []
+        self._metadata = []
+        self._tags = []
 
     @property
     def to_email_address(self):
@@ -404,21 +407,93 @@ def custom_headers(self, val: list):
                 if isinstance(item, CustomHeader):
                     self._custom_headers.append(item)
 
-    def add_custom_header(self, header, val: str = None):
+    def add_custom_header(self, name, val: str = None):
         """
-        Add a CustomHeader to the attachment
-        :param header: the CustomHeader. CustomHeader, dict, and string is allowed
-        :type header: CustomHeader, dict, str
-        :param val: the custom header value, required if header is str
+        Add a CustomHeader to the message
+        :param name: the CustomHeader. CustomHeader, dict, and string is allowed
+        :type name: CustomHeader, dict, str
+        :param val: the custom header value, required if name is str
         :type val: str
         """
-        if isinstance(header, CustomHeader):
+        if isinstance(name, CustomHeader):
             self._custom_headers.append(header)
-        if isinstance(header, str):
+        if isinstance(name, str):
             self._custom_headers.append(CustomHeader(header, val))
+        if isinstance(name, dict):
+            for name, value in name.items():
+                self._custom_headers.append(CustomHeader(name, value))
+
+    @property
+    def metadata(self):
+        """
+        Get the list of Metadata.
+        :return list of Metadata
+        :rtype list
+        """
+        return self._metadata
+
+    @metadata.setter
+    def metadata(self, val: list):
+        """
+        Set the list of Metadata.
+        :param val: list of Metadata
+        :type val: list
+        """
+        self._metadata = []
+        if val is not None:
+            for item in val:
+                if isinstance(item, Metadata):
+                    self._metadata.append(item)
+
+    def add_metadata(self, name, val: str = None):
+        """
+        Add a Metadata item to the message
+        :param name: the Metadata. Metadata, dict, and string is allowed
+        :type name: Metadata, dict, str
+        :param val: the metadata value, required if name is str
+        :type val: str
+        """
+        if isinstance(header, Metadata):
+            self._metadata.append(header)
+        if isinstance(header, str):
+            self._metadata.append(Metadata(header, val))
         if isinstance(header, dict):
             for name, value in header.items():
-                self._custom_headers.append(CustomHeader(name, value))
+                self._metadata.append(Metadata(name, value))
+
+    @property
+    def tags(self):
+        """
+        Get the list of Metadata.
+        :return list of Metadata
+        :rtype list
+        """
+        return self._tags
+
+    @tags.setter
+    def tags(self, val: list):
+        """
+        Set the list of Metadata.
+        :param val: list of Metadata
+        :type val: list
+        """
+        self._tags = []
+        if val is not None:
+            for item in val:
+                self._tags.append(item)
+
+    def add_tag(self, val: str):
+        """
+        Add a Tag item to the message
+        :param val: the tag value
+        :type val: str
+        """
+        if isinstance(val, str):
+            self._tags.append(val)
+        if isinstance(val, list):
+            for value in val.items():
+                self._tags.append(value)
+
 
     def __str__(self):
         """

socketlabs/injectionapi/message/bulkmessage.py

@@ -3,6 +3,7 @@
 from .customheader import CustomHeader
 from .emailaddress import EmailAddress
 from .messagebase import MessageBase
+from .metadata import Metadata
 
 
 class BulkMessage(MessageBase):
@@ -50,6 +51,8 @@ def __init__(self):
         self._custom_headers = []
         self._to_recipients = []
         self._global_merge_data = dict()
+        self._metadata = []
+        self._tags = []
 
     @property
     def to_recipient(self):
@@ -381,6 +384,77 @@ def add_custom_header(self, header, val: str = None):
             for name, value in header.items():
                 self._custom_headers.append(CustomHeader(name, value))
 
+    @property
+    def metadata(self):
+        """
+        Get the list of Metadata.
+        :return list of Metadata
+        :rtype list
+        """
+        return self._metadata
+
+    @metadata.setter
+    def metadata(self, val: list):
+        """
+        Set the list of Metadata.
+        :param val: list of Metadata
+        :type val: list
+        """
+        self._metadata = []
+        if val is not None:
+            for item in val:
+                if isinstance(item, Metadata):
+                    self._metadata.append(item)
+
+    def add_metadata(self, name, val: str = None):
+        """
+        Add a Metadata item to the message
+        :param name: the Metadata. Metadata, dict, and string is allowed
+        :type name: Metadata, dict, str
+        :param val: the metadata value, required if name is str
+        :type val: str
+        """
+        if isinstance(header, Metadata):
+            self._metadata.append(header)
+        if isinstance(header, str):
+            self._metadata.append(Metadata(header, val))
+        if isinstance(header, dict):
+            for name, value in header.items():
+                self._metadata.append(Metadata(name, value))
+
+    @property
+    def tags(self):
+        """
+        Get the list of Metadata.
+        :return list of Metadata
+        :rtype list
+        """
+        return self._tags
+
+    @tags.setter
+    def tags(self, val: list):
+        """
+        Set the list of Metadata.
+        :param val: list of Metadata
+        :type val: list
+        """
+        self._tags = []
+        if val is not None:
+            for item in val:
+                self._tags.append(item)
+
+    def add_tag(self, val: str):
+        """
+        Add a Tag item to the message
+        :param val: the tag value
+        :type val: str
+        """
+        if isinstance(val, str):
+            self._tags.append(val)
+        if isinstance(val, list):
+            for value in val.items():
+                self._tags.append(value)
+
     def __str__(self):
         """
         Represents the BulkMessage as a string (# of recipients & subject)

socketlabs/injectionapi/message/metadata.py

@@ -0,0 +1,83 @@
+from ..core.stringextension import StringExtension
+
+
+class Metadata(object):
+    """
+    Represents a metadata as a name-value pair.
+
+    :Example:
+
+        metadata1 = Metadata()
+        metadata1.name = "name1"
+        metadata1.value = "value1"
+
+        metadata2 = Metadata("name1", "value1")
+
+    """
+
+    def __init__(self, name: str = None, val: str = None):
+        """
+        Initializes a new instance of the Metadata class
+        :param name: the name of the metadata
+        :type name: str
+        :param val: the value of the metadata
+        :type val: str
+        """
+        self._name = name
+        self._value = val
+
+    @property
+    def name(self):
+        """
+        Get the name
+        :return the name
+        :rtype str
+        """
+        return str(self._name)
+
+    @name.setter
+    def name(self, val: str):
+        """
+        Set the name
+        :param val: the name
+        :type val: str
+        """
+        self._name = val
+
+    @property
+    def value(self):
+        """
+        Get the value
+        :return the value
+        :rtype str
+        """
+        return str(self._value)
+
+    @value.setter
+    def value(self, val: str):
+        """
+        Set the value
+        :param val: the value
+        :type val: str
+        """
+        self._value = val
+
+    def isvalid(self):
+        """
+        Determines if the Metadata is valid.
+        :return the result
+        :rtype bool
+        """
+        validName = not StringExtension.is_none_or_white_space(self._name)
+        validValue = not StringExtension.is_none_or_white_space(self._value)
+        if validName and validValue:
+            return True
+        return False
+
+    def __str__(self):
+        """
+        Represents the Metadata name-value pair as a string
+        :return the string
+        :rtype str
+        """
+        return str(self._name + ", " + self._value)