messagemedia_conversations_sdk 1.0.0

data/lib/message_media_conversations/configuration.rb

@@ -0,0 +1,29 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaConversations
+
+  Logging.logger.root.appenders = Logging.appenders.stdout
+  Logging.logger.root.level = :info
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration
+    # The base Uri for API calls
+    @base_uri = 'https://api.messagemedia.com'
+
+    # The username to use with basic authentication
+    @basic_auth_user_name = 'TODO: Replace'
+
+    # The password to use with basic authentication
+    @basic_auth_password = 'TODO: Replace'
+
+    # The attribute accessors for public properties.
+    class << self
+      attr_accessor :array_serialization
+      attr_accessor :base_uri
+      attr_accessor :basic_auth_user_name
+      attr_accessor :basic_auth_password
+    end
+  end
+end

data/lib/message_media_conversations/controllers/app_users_controller.rb

@@ -0,0 +1,285 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaConversations
+  # AppUsersController
+  class AppUsersController < BaseController
+    @instance = AppUsersController.new
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def instance
+      self.class.instance
+    end
+
+    # Sends a message to the App User with the given ID.
+    # You can use this endpoint in conjuction with the app users or app user by
+    # id endpoint where the response from one of the latter endpoints would
+    # display the user id and this can be used with this endpoint to send a
+    # message to that user. A successful response from this endpoint will have
+    # the following structure:
+    # ```
+    # {
+    #   "channel": "facebook",
+    #   "text": "Thank you for your query we'll be in touch with an answer
+    # shortly."
+    # }
+    # ```
+    # @param [String] app_user_id Required parameter: appUserId
+    # @param [BaseMessageDto] body Required parameter: Example:
+    # @return SendMessageResponse response from the API call
+    def create_send_message(app_user_id,
+                            body)
+      begin
+        @logger.info("create_send_message called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for create_send_message.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/beta/conversations/users/{appUserId}/messages'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'appUserId' => app_user_id
+        )
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for create_send_message.")
+        _headers = {
+          'accept' => 'application/json',
+          'content-type' => 'application/json; charset=utf-8'
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for create_send_message.')
+        _request = @http_client.post(
+          _query_url,
+          headers: _headers,
+          parameters: body.to_json
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'create_send_message')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for create_send_message.")
+        if _context.response.status_code == 400
+          raise APIException.new(
+            'The posted request is invalid or the account is not provisioned.',
+            _context
+          )
+        elsif _context.response.status_code == 404
+          raise APIException.new(
+            'The app user does not exist.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for create_send_message.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        SendMessageResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Gets the list of messages sent to and received by the App User with the
+    # given ID. A successful response from this endpoint will have the following
+    # structure:
+    # ```
+    # {
+    #   "messages": {
+    #     "data": [
+    #       {
+    #         "direction": "RECEIVED",
+    #         "text": "Hey, I was just wondering how much shipping would be to
+    # Australia for one of them awesome t-shirts?",
+    #         "channel": "FACEBOOK",
+    #         "timestamp": "2017-12-12T18:18:40.000Z"
+    #       },
+    #       {
+    #         "direction": "SENT",
+    #         "text": "Thank you for your query we'll be in touch with an answer
+    # shortly.",
+    #         "channel": "FACEBOOK",
+    #         "timestamp": "2017-12-08T10:12:16.000Z"
+    #       }
+    #     ]
+    #   },
+    #   "metadata" : {
+    #     "user_id": "{id}",
+    #     "account_id": "FunGuys007"
+    #   }
+    # }
+    # ```
+    # @param [String] app_user_id Required parameter: appUserId
+    # @return GetAppUserMessagesResponse response from the API call
+    def get_app_user_messages(app_user_id)
+      begin
+        @logger.info("get_app_user_messages called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_app_user_messages.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/beta/conversations/users/{appUserId}/messages'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'appUserId' => app_user_id
+        )
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for get_app_user_messages.")
+        _headers = {
+          'accept' => 'application/json'
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_app_user_messages.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'get_app_user_messages')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for get_app_user_messages.")
+        if _context.response.status_code == 404
+          raise APIException.new(
+            'The app user does not exist.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for get_app_user_messages.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        GetAppUserMessagesResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Gets the App User with the given ID. A successful response from this
+    # endpoint will have the following structure:
+    # ```
+    # {
+    #   "id": "3898c5e4-73cc-44f9-812f-3698a4c3bb1d",
+    #   "surname": "Sims",
+    #   "given_name": "Ben"
+    # }
+    # ```
+    # @param [String] app_user_id Required parameter: appUserId
+    # @return GetAppUserByIdResponse response from the API call
+    def get_app_user_by_id(app_user_id)
+      begin
+        @logger.info("get_app_user_by_id called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_app_user_by_id.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/beta/conversations/users/{appUserId}'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'appUserId' => app_user_id
+        )
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for get_app_user_by_id.")
+        _headers = {
+          'accept' => 'application/json'
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_app_user_by_id.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'get_app_user_by_id')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for get_app_user_by_id.")
+        if _context.response.status_code == 404
+          raise APIException.new(
+            'The app user does not exist.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for get_app_user_by_id.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        GetAppUserByIdResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Gets a list of App Users that belong to the configured account. A
+    # successful response from this endpoint will have the following structure:
+    # ```
+    # {
+    #   "data": [
+    #     {
+    #       "id": "3898c5e4-73cc-44f9-812f-3698a4c3bb1d",
+    #       "surname": "Sims",
+    #       "given_name": "Ben"
+    #     },
+    #     {
+    #       "id": "331b1da8-10a5-44c7-91df-1dc14cc2f373",
+    #       "surname": "Hood",
+    #       "given_name": "Robert"
+    #     }
+    #   ]
+    # }
+    # ```
+    # @return GetAppUsersResponse response from the API call
+    def get_app_users
+      begin
+        @logger.info("get_app_users called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_app_users.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/beta/conversations/users'
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for get_app_users.")
+        _headers = {
+          'accept' => 'application/json'
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_app_users.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'get_app_users')
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for get_app_users.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        GetAppUsersResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+  end
+end

data/lib/message_media_conversations/controllers/base_controller.rb

@@ -0,0 +1,59 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaConversations
+  # Base controller.
+  class BaseController
+    attr_accessor :http_client, :http_call_back
+
+    def initialize(http_client: nil, http_call_back: nil)
+      @http_client = http_client || FaradayClient.new
+      @http_call_back = http_call_back
+
+      @global_headers = {
+        'user-agent' => 'messagesmedia-conversations'
+      }
+      @logger = Logging.logger[self]
+      @logger.info("Instantiated controller class.")
+    end
+
+    def validate_parameters(args)
+      args.each do |_name, value|
+        if value.nil?
+          raise ArgumentError, "Required parameter #{_name} cannot be nil."
+        end
+      end
+    end
+
+    def execute_request(request, binary: false, name: nil)
+      @logger.info("Calling the on_before_request method of http_call_back for #{name}.") if @http_call_back
+      @http_call_back.on_before_request(request) if @http_call_back
+
+      @logger.info("Merging global headers with endpoint headers for #{name}.")
+      APIHelper.clean_hash(request.headers)
+      request.headers = @global_headers.clone.merge(request.headers)
+
+      @logger.debug("Raw request for #{name} is: #{request.inspect}")
+      response = if binary
+                   @http_client.execute_as_binary(request)
+                 else
+                   @http_client.execute_as_string(request)
+                 end
+      @logger.debug("Raw response for #{name} is: #{response.inspect}")
+      @logger.info("Wrapping request and response in a context object for #{name}.")
+      context = HttpContext.new(request, response)
+
+      @logger.info("Calling on_after_response method of http_call_back for #{name}.") if @http_call_back
+      @http_call_back.on_after_response(context) if @http_call_back
+
+      context
+    end
+
+    def validate_response(context)
+      raise APIException.new 'The account is not provisioned.', context if
+      context.response.status_code == 400
+      raise APIException.new 'HTTP Response Not OK', context unless
+        context.response.status_code.between?(200, 208) # [200,208] = HTTP OK
+    end
+  end
+end

data/lib/message_media_conversations/controllers/configuration_controller.rb

@@ -0,0 +1,90 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaConversations
+  # ConfigurationController
+  class ConfigurationController < BaseController
+    @instance = ConfigurationController.new
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def instance
+      self.class.instance
+    end
+
+    # Configures your existing MessageMedia account to use the Conversations API
+    # by giving it a human readable name (for reference later on), and also by
+    # specifying a callback URL which is where any Inbound Messages and/or
+    # Notifications will be pushed to. The request would have the following
+    # structure:
+    # ```
+    # {
+    #   "name": "Rainbow Serpent Festival",
+    #   "callback_url": "http://accounts-domain.com/callback"
+    # }
+    # ```
+    # * `name` is a required property and is a customer friendly name to
+    # identify your provisioned account
+    # * `callback_url` is an optional property is the callback URL to forward
+    # inbound messages to.
+    # *Note: We are currently NOT using our Webhooks functionality for this
+    # while it's in beta, when we make this production ready we will look at
+    # switching to having these webhooks managed via the Webhooks Management
+    # API*
+    # @param [ConfigureAccountRequest] body Required parameter: Example:
+    # @return ConfigureAccountResponse response from the API call
+    def create_configure_account(body)
+      begin
+        @logger.info("create_configure_account called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for create_configure_account.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/beta/conversations/provision'
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for create_configure_account.")
+        _headers = {
+          'accept' => 'application/json',
+          'content-type' => 'application/json; charset=utf-8'
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for create_configure_account.')
+        _request = @http_client.post(
+          _query_url,
+          headers: _headers,
+          parameters: body.to_json
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'create_configure_account')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for create_configure_account.")
+        if _context.response.status_code == 400
+          raise APIException.new(
+            'Not a valid request body.',
+            _context
+          )
+        elsif _context.response.status_code == 409
+          raise APIException.new(
+            'The account has already been provisioned.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for create_configure_account.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        ConfigureAccountResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+  end
+end