synapse_client 0.0.1

data/lib/synapse_client/bank_account.rb

@@ -0,0 +1,83 @@
+
+module SynapseClient
+  class BankAccount < APIResource
+    include SynapseClient::APIOperations::List
+
+    attr_accessor :name_on_account, :nickname
+    attr_accessor :date, :bank_name, :resource_uri
+    attr_accessor :account_class, :account_type
+    attr_accessor :routing_number_string, :account_number_string
+    attr_accessor :is_active, :is_buyer_default, :is_seller_default, :is_verified
+
+    def initialize(options = {})
+      options = Map.new(options)
+
+      @account_class         = options[:account_class]
+      @account_number_string = options[:account_number_string]
+      @account_type          = options[:account_type]
+      @bank_name             = options[:bank_name]
+      @date                  = options[:date]
+      @id                    = options[:id] || options[:bank_id]
+      @is_active             = options[:is_active]
+      @is_buyer_default      = options[:is_buyer_default]
+      @is_seller_default     = options[:is_seller_default]
+      @is_verified           = options[:is_verified]
+      @name_on_account       = options[:name_on_account]
+      @nickname              = options[:nickname]
+      @resource_uri          = options[:resource_uri]
+      @routing_number_string = options[:routing_number_string]
+    end
+
+    def self.api_resource_name
+      "bank"
+    end
+
+    def self.all(params={})
+      bank_accounts = list(params).banks
+      bank_accounts.map{|ba| BankAccount.new(ba)}
+    end
+
+    def self.add(params={})
+      response = SynapseClient.request(:post, url + "add", params)
+      return response unless response.successful?
+      BankAccount.new(response.data.bank)
+    end
+
+    def self.link(params={})
+      response = SynapseClient.request(:post, url + "login", params)
+      return response unless response.successful?
+
+      if response.data["is_mfa"]
+        MFA.new(response.data.response)
+      else
+        response.data.banks.map do |bank|
+          BankAccount.new(bank)
+        end
+      end
+    end
+
+    def self.finish_linking(params={})
+      unless params[:bank]
+        raise ArgumentError.new("You must include the bank name when responding to an MFA question.")
+      end
+      unless params[:bank_account_token]
+        raise ArgumentError.new("You must include the bank account token when responding to an MFA question.")
+      end
+      unless params[:mfa]
+        raise ArgumentError.new("You must include the answer(s) when responding to an MFA question.")
+      end
+
+      response = SynapseClient.request(:post, url + "mfa", params)
+      return response unless response.successful?
+
+      if response.data["is_mfa"]
+        MFA.new(response.data.response)
+      else
+        response.data.banks.map do |bank|
+          BankAccount.new(bank)
+        end
+      end
+    end
+
+  end
+end

data/lib/synapse_client/customer.rb

@@ -0,0 +1,140 @@
+
+module SynapseClient
+  class Customer < APIResource
+
+    attr_accessor :email, :fullname, :phonenumber, :ip_address
+    attr_accessor :access_token, :refresh_token, :expires_in
+    attr_accessor :username
+
+    def initialize(options = {})
+      options = Map.new(options)
+
+      @id            = options[:id]            || options[:user_id]
+      @email         = options[:email]
+      @fullname      = options[:fullname]      || options[:name]
+      @phonenumber   = options[:phonenumber]   || options[:phone_number]
+      @ip_address    = options[:ip_address]
+
+      @access_token  = options[:access_token]
+      @refresh_token = options[:refresh_token]
+      @expires_in    = options[:expires_in]
+      @username      = options[:username]
+    end
+
+    def self.api_resource_name
+      "user" # see README.md
+    end
+
+    def self.create(opts={})
+      Customer.new(opts).create
+    end
+
+    def create
+      headers  = {"REMOTE_ADDR" => @ip_address}
+      response = SynapseClient.request(:post, url + "create", to_hash, headers)
+
+      return response unless response.successful?
+      update_attributes(response.data)
+    end
+
+    def self.retrieve(access_token)
+      response = SynapseClient.request(:post, url + "show", {:access_token => access_token})
+
+      return response unless response.successful?
+      Customer.new(response.data.user)
+    end
+
+    # TODO
+    def login
+      # use http://synapsepay.readme.io/v1.0/docs/authentication-login
+    end
+
+  #
+    def bank_accounts
+      BankAccount.all({:access_token => @access_token})
+    end
+    def primary_bank_account
+      @bank_accounts.select{|ba| ba.is_buyer_default}.first
+    end
+
+    def add_bank_account(params={})
+      BankAccount.add(params.merge({
+        :access_token => @access_token,
+        :fullname     => @fullname
+      }))
+    end
+
+    def link_bank_account(params={})
+      BankAccount.link(params.merge({
+        :access_token => @access_token
+      }))
+    end
+
+    def finish_linking_bank_account(params={})
+      BankAccount.finish_linking(params.merge({
+        :access_token => @access_token
+      }))
+    end
+
+  #
+    def orders
+      Order.all({:access_token => @access_token})
+    end
+
+    def add_order(params={})
+      if SynapseClient.merchant_synapse_id.nil?
+        raise ArgumentError.new("You need to set SynapseClient.merchant_synapse_id before you can submit orders.")
+      else
+        Order.create(params.merge({
+          :access_token => @access_token,
+          :seller_id    => SynapseClient.merchant_synapse_id,
+          :bank_pay     => "yes"        # see README.md
+        }))
+      end
+    end
+
+=begin
+    def link_account(options = {}, client)
+      options.to_options!.compact
+
+      data = {
+        :bank               => options[:bank_name],
+        :password           => options[:password],
+        :pin                => options[:pin] || "1234",
+        :username           => options[:username]
+      }
+
+      request  = SynapseClient::Request.new("/api/v2/bank/login/", data, client)
+      response = request.post
+
+      if response.instance_of?(SynapseClient::Error)
+        response
+      elsif response["is_mfa"]
+        SynapseClient::MFA.new(response["response"])
+      else
+        add_bank_accounts response["banks"]
+        @bank_accounts
+      end
+    end
+    def unlink_account(options = {}, client)
+      data = {
+        :bank_id => options.delete(:bank_id),
+      }
+
+      request  = SynapseClient::Request.new("/api/v2/bank/delete/", data, client)
+      request.post
+    end
+=end
+
+
+private
+    def update_attributes(data)
+      @access_token  = data.access_token
+      @refresh_token = data.refresh_token
+      @expires_in    = data.expires_in
+      @username      = data.username
+      return self
+    end
+
+  end
+end

data/lib/synapse_client/error.rb

@@ -0,0 +1,42 @@
+
+module SynapseClient
+  class Error
+
+    attr_reader :message
+    attr_reader :title
+    attr_reader :code
+    attr_reader :exception
+    attr_reader :request
+
+    def initialize(exception, request)
+      @exception = exception
+      @request   = request
+
+      #
+        begin
+          @message = @exception["reason"] || @exception["message"]
+          @title   = @exception["title"]
+        rescue => e
+          # FIXME
+          # Rails.logger.error("Something went wrong with interacting with Synapse: #{ @exception.message }")
+          return
+        end
+
+      #
+        if @message.present? && @message.match(/error.*oauth.*authentication/i).present?
+          refreshed_tokens = SynapseClient::RefreshedTokens.new({
+              :old_access_token => @request.customer_access_token,
+              :old_refresh_token => @request.customer_refresh_token
+            })
+
+          refreshed_tokens.refresh_old_tokens
+        end
+
+    end
+
+    def msg
+      (title || message).to_s
+    end
+
+  end
+end

data/lib/synapse_client/merchant.rb

@@ -0,0 +1,24 @@
+
+
+module SynapseClient
+  class Merchant
+
+    attr_accessor :client_id
+    attr_accessor :client_secret
+    attr_accessor :oauth_merchant_key
+    attr_accessor :merchant_email
+    attr_accessor :device_id
+
+    def initialize(options ={})
+      options = Map.new(options)
+
+      @client_id          = options[:client_id]          || ENV["SYNAPSE_CLIENT_ID"]
+      @client_secret      = options[:client_secret]      || ENV["SYNAPSE_CLIENT_SECRET"]
+      @oauth_merchant_key = options[:oauth_merchant_key] || ENV["SYNAPSE_OAUTH_MERCHANT_KEY"]
+      @merchant_email     = options[:merchant_email]     || ENV["SYNAPSE_MERCHANT_EMAIL"]
+      @device_id          = options[:device_id]          || ENV["SYNAPSE_DEVICE_ID"]
+    end
+
+  end
+end
+

data/lib/synapse_client/mfa.rb

@@ -0,0 +1,26 @@
+
+module SynapseClient
+  class MFA
+
+    attr_reader :type
+    attr_reader :questions
+    attr_reader :bank_access_token
+
+    def initialize(options={})
+      options = Map.new(options)
+
+      @bank_access_token = options[:access_token]
+      @type              = options[:type]
+
+      if @type == "questions"
+        @questions = []
+        questions  = options[:mfa]
+        questions.each do |q|
+          @questions.push q["question"]
+        end
+      end
+    end
+
+  end
+end
+

data/lib/synapse_client/order.rb

@@ -0,0 +1,65 @@
+
+module SynapseClient
+  class Order < APIResource
+    include SynapseClient::APIOperations::List
+
+    attr_reader :status
+    attr_reader :amount
+    attr_reader :seller_email
+    attr_reader :seller_id
+    attr_reader :bank_pay
+    attr_reader :bank_id
+    attr_reader :note
+    attr_reader :date_settled
+    attr_reader :date
+    attr_reader :ticket_number
+    attr_reader :resource_uri
+    attr_reader :account_type
+    attr_reader :fee
+
+    def initialize(options = {})
+      options = Map.new(options)
+
+      update_attributes(options)
+    end
+
+    def self.all(params={})
+      orders = list(params, "recent").orders
+      orders.map{|order| Order.new(order)}
+    end
+
+    def self.create(params={})
+      response = SynapseClient.request(:post, url + "add", params)
+
+      return response unless response.successful?
+      Order.new(response.data.order)
+    end
+
+    def self.retrieve_endpoint
+      "poll"
+    end
+
+    def retrieve_params
+      {:order_id => @id}
+    end
+
+    def update_attributes(options)
+      @status        = options[:status]
+      @amount        = options[:amount]
+      @seller_email  = options[:seller_email]
+      @bank_pay      = options[:bank_pay]
+      @bank_id       = options[:bank_id]
+      @note          = options[:note]
+      @date_settled  = options[:date_settled]
+      @date          = options[:date]
+      @id            = options[:id]
+      @ticket_number = options[:ticket_number]
+      @resource_uri  = options[:resource_uri]
+      @account_type  = options[:account_type]
+      @fee           = options[:fee]
+      @seller_id     = options[:seller_id] || options[:seller].delete("seller_id") rescue nil
+    end
+
+  end
+end
+

data/lib/synapse_client/refreshed_tokens.rb

@@ -0,0 +1,39 @@
+
+module SynapseClient
+  class RefreshedTokens
+
+    attr_reader :old_access_token
+    attr_reader :old_refresh_token
+    attr_reader :new_access_token
+    attr_reader :new_refresh_token
+
+    def initialize(options = {})
+      options = Map.new(options)
+
+      @old_access_token = options[:old_access_token]
+      @old_refresh_token = options[:old_refresh_token]
+    end
+
+    def refresh_old_tokens
+      data = {
+        :grant_type => "refresh_token",
+        :refresh_token => @old_refresh_token
+      }
+
+      request = SynapseClient::Request.new("/oauth2/access_token", data)
+      response = request.post
+
+      unless response.instance_of?(SynapseClient::Error)
+        self.new_access_token  = response["access_token"]
+        self.new_refresh_token = response["refresh_token"]
+
+        return self
+      else
+        return response
+      end
+
+    end
+
+  end
+end
+

data/lib/synapse_client/security_question.rb

@@ -0,0 +1,17 @@
+
+module SynapseClient
+  class SecurityQuestion
+
+    attr_reader :id
+    attr_reader :text
+
+    def initialize(options={})
+      options = Map.new(options)
+
+      @id   = options[:id]
+      @text = options[:questions]
+    end
+
+  end
+end
+