synapse_api 1.0.0

data/lib/synapse_api/error.rb

@@ -0,0 +1,114 @@
+module Synapse
+  # Custom class for handling HTTP and API errors.
+  class Error < StandardError
+    # Raised on a 4xx HTTP status code
+    ClientError = Class.new(self)
+
+    # Raised on the HTTP status code 202
+    Accepted = Class.new(ClientError)
+
+    # Raised on the HTTP status code 400
+    BadRequest = Class.new(ClientError)
+
+    # Raised on the HTTP status code 401
+    Unauthorized = Class.new(ClientError)
+
+    # Raised on the HTTP status code 402
+    RequestDeclined = Class.new(ClientError)
+
+    # Raised on the HTTP status code 404
+    NotFound = Class.new(ClientError)
+
+    # Raised on the HTTP status code 409
+    Conflict = Class.new(ClientError)
+
+    # Raised on the HTTP status code 429
+    TooManyRequests = Class.new(ClientError)
+
+    # Raised on a 5xx HTTP status code
+    ServerError = Class.new(self)
+
+    # Raised on the HTTP status code 500
+    InternalServerError = Class.new(ServerError)
+
+    # Raised on the HTTP status code 503
+    ServiceUnavailable = Class.new(ServerError)
+
+    # Raised on unexpected HTTP status codes
+    Unknown = Class.new(self)
+
+    # HTTP status code to Error subclass mapping
+    ERRORS = {
+      '202' => Synapse::Error::Accepted,
+      '400' => Synapse::Error::BadRequest,
+      '401' => Synapse::Error::Unauthorized,
+      '402' => Synapse::Error::RequestDeclined,
+      '404' => Synapse::Error::NotFound,
+      '409' => Synapse::Error::Conflict,
+      '429' => Synapse::Error::TooManyRequests,
+      '500' => Synapse::Error::InternalServerError,
+      '503' => Synapse::Error::ServiceUnavailable,
+    }.freeze
+
+    # The SynapsePay API Error Code
+    #
+    # @return [Integer]
+    attr_reader :code, :http_code
+
+    # The JSON HTTP response in Hash form
+    # @return [Hash]
+    attr_reader :response, :message
+
+    class << self
+      # Create a new error from an HTTP response
+      # @param body [String]
+      # @param code [Integer]
+      # @param http_code [Integer]
+      # @return [Synapse::Error]
+      def from_response(body)
+        message, error_code, http_code = parse_error(body)
+        http_code = http_code.to_s
+        klass = ERRORS[http_code] || Synapse::Error::Unknown
+        klass.new(message: message, code: error_code, response: body, http_code: http_code)
+      end
+
+      private
+
+      def parse_error(body)
+
+        if body.nil? || body.empty?
+          ['', nil, nil]
+
+        elsif body['mfa'] && body.is_a?(Hash)
+          ["#{body['mfa']["message"] } acces_token: #{body['mfa']["access_token"]}", body['error_code'], body['http_code']]
+        elsif body[:mfa] && body.is_a?(Hash)
+          ["#{body[:mfa][:message] } acces_token: #{body[:mfa][:access_token]}", body[:error_code], body[:http_code]]
+
+        elsif body['message'] && body.is_a?(Hash)
+          [body["message"]["en"], body['error_code'], body['http_code']]
+         elsif body[:message] && body.is_a?(Hash)
+          [body[:message][:en], body[:error_code], body[:http_code]]
+
+        elsif body.is_a?(Hash) && body['error'].is_a?(Hash)
+          [body['error']['en'], body['error_code'], body['http_code']]
+        elsif body.is_a?(Hash) && body[:error].is_a?(Hash)
+          [body[:error][:en], body[:error_code], body[:http_code]]
+
+        end
+      end
+    end
+
+    # Initializes a new Error object
+    # @param message [Exception, String]
+    # @param code [Integer]
+    # @param response [Hash]
+    # @return [Synapse::Error]
+    def initialize(message: '', code: nil, response: {}, http_code:)
+      super(message)
+      @code     = code
+      @response = response
+      @message = message
+      @http_code = http_code
+    end
+  end
+end

data/lib/synapse_api/http_request.rb

@@ -0,0 +1,237 @@
+require 'rest-client'
+require 'open-uri'
+require 'json'
+
+module Synapse
+	# Wrapper for HTTP requests using RestClient.
+	class HTTPClient
+
+		# @!attribute [rw] base_url
+		#   @return [String] the base url of the API (production or sandbox)
+		# @!attribute [rw] config
+		#   @return [Hash] various settings related to request headers
+        # @!attribute [rw] raise_for_202
+        #   @return [Boolean] relating to how to handle 202 exception
+		attr_accessor :base_url, :config, :raise_for_202
+
+		# @param base_url [String] the base url of the API (production or sandbox)
+      	# @param client_id [String]
+      	# @param client_secret [String]
+      	# @param fingerprint [String]
+      	# @param ip_address [String]
+        # @param raise_for_202 [String]
+      	# @param logging [Boolean] (optional) logs to stdout when true
+      	# @param log_to [String] (optional) file path to log to file (logging must be true)
+		def initialize(base_url:, client_id:, client_secret:, fingerprint:, ip_address:, raise_for_202:false, **options)
+            @raise_for_202 = raise_for_202
+			log_to         = options[:log_to] || 'stdout'
+			RestClient.log = log_to if options[:logging]
+			@logging       = options[:logging]
+
+			@config = {
+				client_id: client_id,
+				client_secret: client_secret,
+				fingerprint: fingerprint,
+				ip_address: ip_address,
+				oauth_key:  '',
+			}
+			@base_url = base_url
+		end
+
+		# Returns headers for HTTP requests.
+	    # @return [Hash]
+		def headers
+			user    = "#{config[:oauth_key]}|#{config[:fingerprint]}"
+			gateway = "#{config[:client_id]}|#{config[:client_secret]}"
+			headers = {
+				content_type: :json,
+				accept: :json,
+				'X-SP-GATEWAY' => gateway,
+			    'X-SP-USER'    => user,
+			    'X-SP-USER-IP' => config[:ip_address],
+			}
+            if config[:idemopotency_key]
+                headers['X-SP-IDEMPOTENCY-KEY'] = config[:idemopotency_key]
+            end
+            headers
+		end
+
+		# Alias for headers (copy of current headers)
+		alias_method :get_headers, :headers
+
+		# Updates current HTPP headers
+        # @param fingerprint [String]
+        # @param oauth_key [String]
+        # @param fingerprint [String]
+        # @param client_id [String]
+        # @param client_secret [String]
+        # @param ip_address [String]
+        # @param idemopotency_key [String]
+		def update_headers(oauth_key: nil, fingerprint: nil, client_id: nil, client_secret: nil, ip_address: nil, idemopotency_key: nil)
+			config[:fingerprint]   = fingerprint if fingerprint
+			config[:oauth_key]     = oauth_key if oauth_key
+			config[:client_id]     = client_id if client_id
+			config[:client_secret] = client_secret if client_secret
+			config[:ip_address]    = ip_address if ip_address
+            config[:idemopotency_key] = idemopotency_key if idemopotency_key
+			nil
+		end
+
+		# Send a POST request to the given path with the given payload
+		# @param path [String]
+		# @param payload [HASH]
+		# @param **options payload = idempotency_key [String] (optional) avoid accidentally performing the same operation twice
+	    # @return [Hash] API response
+        # @raise [Synapse::Error] subclass depends on HTTP response
+        def post(path, payload, **options)
+            #copy of current headers
+            headers = get_headers
+
+            # update the headers with idempotency_key
+            if options[:idempotency_key]
+                headers = headers.merge({'X-SP-IDEMPOTENCY-KEY' => options[:idempotency_key]})
+            end
+
+    	    response = with_error_handling { RestClient::Request.execute(:method =>  :post,
+                                                                   :url =>     full_url(path),
+                                                                   :payload => payload.to_json,
+                                                                   :headers => headers,
+                                                                   :timeout => 300
+                                                                   ) }
+    	    puts 'RESPONSE:', JSON.parse(response) if @logging
+    	    response = JSON.parse(response)
+
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
+         end
+
+        # Sends a GET request to the given path with the given payload.
+		# @param path [String]
+		# @return [Hash] API response
+		# @raise [Synapse::Error] subclass depends on HTTP response
+		def get(path)
+			response = with_error_handling {RestClient.get(full_url(path), headers)}
+			puts 'RESPONSE:', JSON.parse(response) if @logging
+			response = JSON.parse(response)
+
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
+		end
+
+        # Sends a DELETE request to the given path
+        # @param path [String]
+        # @return [Hash] API response
+        # @raise [Synapse::Error] subclass depends on HTTP response
+        def delete(path)
+            response = with_error_handling {RestClient.delete(full_url(path), headers)}
+            puts 'RESPONSE:', JSON.parse(response) if @logging
+            response = JSON.parse(response)
+
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
+        end
+
+		# Sends a PATCH request to the given path with the given payload.
+        # @param path [String]
+        # @param payload [Hash]
+        # @return [Hash] API response
+        # @raise [Synapse::Error] subclass depends on HTTP response
+		def patch(path, payload)
+			response = with_error_handling {RestClient::Request.execute(:method =>  :patch,
+                                                                  :url =>     full_url(path),
+                                                                  :payload => payload.to_json,
+                                                                  :headers => headers,
+                                                                  :timeout => 300
+                                                                  )}
+			p 'RESPONSE:', JSON.parse(response) if @logging
+			response = JSON.parse(response)
+
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
+		end
+
+        def oauthenticate(user_id:)
+            refresh_token = refresh_token(user_id: user_id)
+        end
+
+		private
+
+        # get user
+        # get refresh_token
+        # send refresh_token to oauth path
+        # grabs the refresh token and formats a refresh token payload
+        def refresh_token(user_id:)
+            path = "/users/#{user_id}"
+            response = get(path)
+            refresh_token = response["refresh_token"]
+
+            refresh_token = {"refresh_token" => refresh_token}
+            oauth_path = oauth_path(user_id)
+            authenticate(refresh_token, oauth_path)
+        end
+
+        # options payload to change scope of oauth
+        def authenticate(refresh_token, oauth_path)
+            oauth_key = post(oauth_path, refresh_token)
+            oauth_key = oauth_key['oauth_key']
+            update_headers(oauth_key: oauth_key)
+            nil
+        end
+
+        def oauth_path(user_id)
+            "/oauth/#{user_id}"
+        end
+
+		def full_url(path)
+            "#{base_url}#{path}"
+		end
+
+        # raising an exception based on http_request
+        # yeilds if http_request raises an exception
+		def with_error_handling
+			yield
+		    rescue RestClient::Exceptions::Timeout
+    			body = {
+    				error: {
+    					en: "Request Timeout"
+    				},
+    				http_code: 504
+    			}
+			    raise Error.from_response(body)
+		    rescue RestClient::Exception => e
+                if e.response.headers[:content_type] == 'application/json'
+                    body = JSON.parse(e.response.body)
+                else
+    				body = {
+    					error: {
+    						en: e.response.body
+    					},
+    					http_code: e.response.code
+    				}
+			    end
+			   raise Error.from_response(body)
+		end
+	end
+end
+
+

data/lib/synapse_api/node.rb

@@ -0,0 +1,19 @@
+module Synapse
+
+	class Node
+
+		attr_reader :node_id, :user_id, :payload, :full_dehydrate, :type
+
+		attr_accessor
+
+		def initialize(node_id:, user_id:,payload:, full_dehydrate:, type:nil)
+			@node_id = node_id
+			@full_dehydrate = full_dehydrate
+			@user_id = user_id
+			@payload = payload
+      @type = type
+		end
+	end
+end
+
+

data/lib/synapse_api/nodes.rb

@@ -0,0 +1,19 @@
+module Synapse
+
+	class Nodes
+
+		attr_reader :page, :page_count, :limit, :payload, :nodes_count
+
+		attr_accessor
+
+		def initialize(page:,limit:, page_count:, nodes_count:, payload:)
+			@page = page
+			@limit = limit
+			@nodes_count = nodes_count
+			@page_count = page_count
+			@payload = payload
+		end
+	end
+end
+
+

data/lib/synapse_api/subnet.rb

@@ -0,0 +1,15 @@
+module Synapse
+
+  class Subnet
+
+    attr_accessor  :subnet_id, :payload, :node_id
+
+    def initialize(subnet_id:, payload:, node_id:)
+      @subnet_id = subnet_id
+      @payload = payload
+      @node_id = node_id
+    end
+  end
+end
+
+

data/lib/synapse_api/subnets.rb

@@ -0,0 +1,16 @@
+module Synapse
+
+  class Subnets
+
+    attr_accessor  :page, :page_count, :limit, :payload, :subnets_count, :node_id
+
+    def initialize(limit:, page:, page_count:, subnets_count:, payload:, node_id:)
+      @page = page
+      @limit = limit
+      @subnets_count = subnets_count
+      @payload = payload
+      @page_count = page_count
+      @node_id = node_id
+    end
+  end
+end

data/lib/synapse_api/subscription.rb

@@ -0,0 +1,15 @@
+module Synapse
+
+	class Subscription
+
+		attr_reader :subscription_id, :url, :payload
+
+		attr_accessor
+
+		def initialize(subscription_id:, url:, payload:)
+			@subscription_id = subscription_id
+			@url = url
+      @payload = payload
+		end
+	end
+end

data/lib/synapse_api/subscriptions.rb

@@ -0,0 +1,17 @@
+module Synapse
+
+	class Subscriptions
+
+		attr_reader :subscriptions_count, :page, :limit, :payload, :page_count
+
+		attr_accessor
+
+		def initialize(page:,limit:, subscriptions_count:, payload:, page_count:)
+			@subscriptions_count = subscriptions_count
+			@page = page
+      @limit = limit
+      @payload = payload
+      @page_count = page_count
+		end
+	end
+end