synapse_fi 0.0.1

data/lib/synapse_api/http_request.rb

@@ -0,0 +1,228 @@
+require 'rest-client'
+require 'open-uri'
+require 'json'
+require_relative './error'
+
+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)
+      path = "/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, :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,13 @@
+module Synapse
+
+  class Subnet
+
+    attr_accessor  :subnet_id, :payload
+
+    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

data/lib/synapse_api/transaction.rb

@@ -0,0 +1,21 @@
+module Synapse
+
+	class Transaction
+
+
+		attr_accessor  :trans_id, :payload, :node_id, :user
+
+		def initialize(trans_id:, payload:, node_id:nil, user:nil)
+			@trans_id = trans_id
+			@payload = payload
+      @node_id = node_id
+      @user = user
+		end
+	end
+end
+
+
+
+
+
+

data/lib/synapse_api/transactions.rb

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