Updating with version 3. You can now delete a channel and upload a profile image to the channel. Improved UX.

Author: Josh Wolff

.idea/dictionaries/jw1.xml

@@ -9,40 +9,39 @@ def __init__(self, resource):
         """
         Initializes an instance of Examples. You can try the different examples in this class.
         To do so, initialize the class and then call one of the functions.
-        :param resource: An instance of SpontitResource
+        :param resource: an instance of SpontitResource
         """
         assert type(resource) == SpontitResource
         self.__resource = resource
 
     def simple_push_example(self):
         """
         Sends a simple push notification.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Hello!")
 
     def scheduled_push(self):
         """
         Schedules a push notification for one hour from the current time.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
-        # 3600 seconds in one hour
         return self.__resource.push("Hello, in 1 hour",
                                     schedule_time_stamp=int(time.time()) + 3600)
 
     def immediate_expiration_push(self):
         """
         Sends a push notification and sets the expiration for the current time. Because our expiration function
         polls approximately every 15-30 minutes, the notification will delete within 30 minutes.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Hello, expire ASAP (within 15 minutes)",
                                     expiration=SpontitResource.Expiration(0, 0, 0))
 
     def expire_one_hour_after_schedule(self):
         """
         Schedules a push notification for one hour from now, and then expires it one hour later.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Hello, in 1 hour. Bye in 2.",
                                     schedule_time_stamp=int(time.time()) + 3600,
@@ -52,18 +51,18 @@ def rate_limit_example(self):
         """
         Spontit currently only supports sending one push notification per second.
         This function throttles that limit as an example of what you can expect if you exceed that limit.
-        :return: The final response of the 10 calls to push.
+        :return: the final response of the 10 calls to push.
         """
-        response = None
+        response_received = None
         for _ in range(10):
-            response = self.simple_push_example()
-            print(response)
-        return response
+            response_received = self.simple_push_example()
+            print(response_received)
+        return response_received
 
     def subtitle_body_example(self):
         """
         Sends a push notification with a subtitle and a body.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Hello!",
                                     subtitle="An API Notice",
@@ -81,7 +80,7 @@ def post_a_link_ex_1(self):
         """
         Sends a push notification with a link to Jack Dorsey's first tweet. should_open_link_in_app is set to False
         so that the Twitter app opens (rather than opening twitter.com within the Spontit app).
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Jack's first tweet.",
                                     link="https://twitter.com/jack/status/20",
@@ -95,7 +94,7 @@ def post_a_link_ex_1(self):
     def post_a_link_ex_2(self):
         """
         Sends a push notification with a link to Amazon.com.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Buy from Amazon.",
                                     link="https://amazon.com")
@@ -104,17 +103,17 @@ def post_a_link_ex_3(self):
         """
         Sends a push notification linking the Spontit review compose window in the App Store. should_open_link_in_app is
         set to False so that the App Store opens.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
-        return self.__resource.push("Please give Spontit 5 stars!!!",
+        return self.__resource.push("Please rate Spontit in the App Store!",
                                     link="https://itunes.apple.com/app/id1448318683?action=write-review",
                                     should_open_link_in_app=False)
 
     def post_an_ios_deep_link_ex_1(self):
         """
         Sends a push notification deep linking to Stocks app.
         Only works for iOS Spontit App, >= v6.0.1
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Open the stocks app.",
                                     ios_deep_link="stocks://")
@@ -123,106 +122,183 @@ def post_an_ios_deep_link_ex_2(self):
         """
         Sends a push notification deep linking to the gallery tab of the Shortcuts app.
         Only works for iOS Spontit App, >= v6.0.1
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
         return self.__resource.push("Open the gallery tab of the Shortcuts app.",
                                     ios_deep_link="shortcuts://gallery")
 
     def post_an_ios_deep_link_ex_3(self):
         """
         Pushes a notification that deep links to the Spontit review creation window in the App Store.
-        :return: The result of the call to push
+        :return: the result of the call to push
         """
-        return self.__resource.push("Please give Spontit 5 stars!!!",
+        return self.__resource.push("Please rate Spontit in the App Store!",
                                     ios_deep_link="itms-apps://itunes.apple.com/app/id1448318683?action=write-review")
 
     def create_new_channel(self):
         """
-        Creates a new channel
-        :return: The new channel
+        Creates a new channel.
+        :return: the new channel
         """
-        return self.__resource.create_channel("My First Custom Channel")
+        response = self.__resource.create_channel("My First Custom Channel")
+        return Examples.__get_channel_from_response(response)
 
     def create_new_channel_with_category(self):
         """
         Creates a new channel with a category code of 0.
-        :return: The new channel
+        :return: the new channel
         """
-        available_categories = self.__resource.get_channel_categories()
+        available_categories = self.__resource.get_categories()
         category_code = 0
         if 'data' in available_categories and len(available_categories['data']) > 0:
             category_code = available_categories['data'][0].get('categoryCode', 0)
 
         new_display_name = "My New Channel"
-        return self.__resource.create_channel(new_display_name, category_code)
+        response = self.__resource.create_channel(new_display_name, int(category_code))
+        return Examples.__get_channel_from_response(response)
+
+    def create_new_channel_with_profile_image_and_push_to_it(self):
+        """
+        Creates a new channel, uploads a profile image, and sends a simple push notification to it.
+        You should see the profile image in the push notification.
+        :return: the result of the push notification request
+        """
+        new_channel_display_name = "Profile Image Channel"
+        _ = self.__resource.create_channel(new_channel_display_name)
 
-    def create_new_channel_and_push_to_it(self):
+        import os
+        cwd = os.getcwd()  # Get the current working directory (cwd)
+        print(cwd)
+        files = os.listdir(cwd)  # Get all the files in that directory
+        print(files)
+
+        response = self.__resource.channel_profile_image_upload(
+            image_path="examples/orange.png",
+            is_png=True,
+            channel_name=new_channel_display_name
+        )
+        self.__resource.push(
+            "Hello new channel!",
+            channel_name=new_channel_display_name
+        )
+        print("After uploading a profile image, you receive a URL that you can use to confirm the upload succeeded.")
+        print("You can also view the result of the push. You should see the channel image in the push, provided you "
+              "have good connection.")
+        print(response)
+
+    def create_new_channel_and_update_its_settings(self):
         """
         Creates a new channel and sends a simple push notification to it.
-        :return: The result of the push notification
+        :return: the result of the push notification request
         """
         new_channel_display_name = "Push Push Channel"
         _ = self.__resource.create_channel(new_channel_display_name)
+        self.__resource.update_channel(
+           new_channel_display_name,
+           add_all_followers=True,
+           auto_add_future_followers=True,
+           category_code=1
+        )
 
-        # The channel might not have been completely initialized just yet. It is generally recommended to create your
-        # channels prior to pushing. Sleeping is far less than ideal, and we will work on a better solution to
-        # create channels on the fly. If you have any requests, please create an issue in the repo.
-        time.sleep(1.0)
-
-        mapping = self.__resource.get_display_name_to_channel_id_mapping()
-        if 'data' in mapping:
-            channel_id_to_push_to = mapping['data'].get(new_channel_display_name, None)
-            if channel_id_to_push_to is not None:
-                return self.__resource.push("Hello!",
-                                            channel_id=channel_id_to_push_to)
-        return {
-            "errors": [{
-                "message": "Channel not found."
-            }]
-        }
+    def create_and_then_delete_channel(self):
+        """
+        Creates a channel and then deletes it.
+        :return: the channel (before deletion)
+        """
+        new_channel_display_name = "Invite Me Channel"
+        response = self.__resource.create_channel(new_channel_display_name)
+        print("Delete Response:", self.__resource.delete_channel(new_channel_display_name))
+        return Examples.__get_channel_from_response(response)
 
     def create_new_channel_and_get_invite_options(self):
         """
-        Creates a new channel and gets the invite options.
-        :return: The ways to invite someone to the channel, if the channel exists
+        Creates a new channel and print out the item. Embedded in the channel item are the invite options
+        :return: the channel item
         """
         new_channel_display_name = "Invite Me Channel"
-        _ = self.__resource.create_channel(new_channel_display_name)
-
-        # The channel might not have been completely initialized just yet. It is generally recommended to create your
-        # channels prior to pushing. Sleeping is far less than ideal, and we will work on a better solution to
-        # create channels on the fly. If you have any requests, please create an issue in the repo.
-        time.sleep(1.0)
-
-        mapping = self.__resource.get_display_name_to_channel_id_mapping()
-        if 'data' in mapping:
-            channel_id_to_invite_to = mapping['data'].get(new_channel_display_name, None)
-            if channel_id_to_invite_to is not None:
-                return self.__resource.get_invite_options(channel_id_to_invite_to)
-        return {
-            "errors": [{
-                "message": "Channel not found."
-            }]
-        }
+        response = self.__resource.create_channel(new_channel_display_name)
+        return Examples.__get_channel_from_response(response)
 
     def get_invite_options_for_my_main_account(self):
         """
-        Gets the invite options for your main channel.
-        :return: The response
+        Get the main channel. Embedded in the main channel are the invite options
+        :return: the main channel (your account)
+        """
+        response = self.__resource.get_channel()
+        return Examples.__get_channel_from_response(response)
+
+    def list_my_channels(self):
+        """
+        List all created channels
+        :return: the channels
         """
-        return self.__resource.get_invite_options()
+        response = self.__resource.get_channels()
+        return Examples.__get_channel_from_response(response)
+
+    @staticmethod
+    def __get_channel_from_response(response):
+        """
+        Print the channel from the responses. This function assumes a response is passed that contains "data". If not,
+        it catches the KeyError and prints the error
+        :param response: the response received from the Channel endpoint
+        :return: either the new channel item or None
+        """
+        try:
+            new_channel = response['data']
+            print(new_channel)
+            return new_channel
+        except KeyError:
+            print(response)
+            return None
+
+    def do_everything(self):
+        """
+        Runs every example. Are you ready?
+        :return:
+        """
+        example_functions = [
+            self.simple_push_example,
+            self.scheduled_push,
+            self.immediate_expiration_push,
+            self.expire_one_hour_after_schedule,
+            self.rate_limit_example,
+            self.subtitle_body_example,
+            self.post_a_link_ex_1,
+            self.post_a_link_ex_2,
+            self.post_an_ios_deep_link_ex_3,
+            self.create_new_channel,
+            self.create_new_channel_with_category,
+            self.create_new_channel_with_profile_image_and_push_to_it,
+            self.create_new_channel_and_update_its_settings,
+            self.create_and_then_delete_channel,
+            self.create_new_channel_and_get_invite_options,
+            self.get_invite_options_for_my_main_account,
+            self.list_my_channels
+        ]
+
+        for func in example_functions:
+            # Added time.sleep(1) because of the rate limit. Only one push per second per channel.
+            # (e.g. You can have two pushes in the same second if each goes to a different channel.)
+            # See rate_limit_example
+            print(func.__name__)
+            func()
+            time.sleep(1)
+            print("")
 
 
 if __name__ == "__main__":
     # Try an example...
     spontit_src = SpontitResource("my_username", "my_secret_key")
     example_instance = Examples(spontit_src)
-    response = example_instance.simple_push_example()
-    print("Simple push example result: " + str(response))
+    push_response = example_instance.simple_push_example()
+    print("Simple push example result: " + str(push_response))
+
+    # ...or be bold...
+    example_instance.do_everything()
 
     # ...or get right to pushing!
-    response = spontit_src.push("Hello!!!")
-    print("Result: " + str(response))
+    push_response = spontit_src.push("Hello!!!")
+    print("Result: " + str(push_response))
 
     # To see documentation, run:
     help(SpontitResource)