mangopay-v4 4.0.0

data/bin/mangopay

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs = ' -r irb/completion'
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/mangopay'}"
+
+puts 'Loading MangoPay gem'
+exec "#{irb} #{libs}"

data/lib/mangopay.rb

@@ -0,0 +1,133 @@
+require_relative '../lib/mangopay/common/log_provider'
+require_relative 'mangopay/environment'
+require_relative 'mangopay/configuration'
+require_relative 'mangopay/model/model'
+require_relative 'mangopay/api/api'
+
+# Holds top-level configuration.
+module MangoPay
+  LOG = LogProvider.provide(self)
+
+  VERSION = '4.0.0'.freeze
+
+  SANDBOX_API_URL = 'https://api.sandbox.mangopay.com'.freeze
+  MAIN_API_URL = 'https://api.mangopay.com'.freeze
+
+  # ID of the environment in which to run MangoPay operations
+  @global_env_id = :default
+  # Mapping of MangoPay environments by ID
+  @environments = {
+    default: MangoPay::Environment.new(:default)
+  }
+  # Mapping of thread object IDs to MangoPay environment IDs
+  @env_id = {}
+
+  class << self
+
+    # Allows to specify environment in which to run MangoPay operations.
+    # All subsequent threads will automatically run in that environment.
+    #
+    # @param +env_id+ ID of the required environment
+    #
+    # noinspection RubyResolve
+    def use_environment(env_id)
+      @global_env_id = env_id || :default
+      unless @environments[@global_env_id]
+        LOG.debug 'Creating new environment :{}', env_id
+        env = MangoPay::Environment.new(@global_env_id)
+        @environments[@global_env_id] = env
+      end
+      LOG.info 'Using environment :{}', env_id
+      put_thread_local_environment
+    end
+
+    # Sets MangoPay to run under the default environment.
+    def use_default
+      use_environment :default
+    end
+
+    # Returns the environment currently being used.
+    #
+    # noinspection RubyResolve
+    def environment
+      @environments[thread_local_env_id]
+    end
+
+    private
+
+    # Returns the ID of the environment to be used for current thread.
+    #
+    # noinspection RubyResolve
+    def thread_local_env_id
+      thread_id = Thread.current.object_id
+      @env_id[thread_id] || put_thread_local_environment
+    end
+
+    # Saves currently-set global environment as the one to be used
+    # for current thread.
+    #
+    # noinspection RubyResolve
+    def put_thread_local_environment
+      thread = Thread.current
+      thread_id = thread.object_id
+      LOG.debug 'Mapping thread {} to environment :{}',
+                thread_id, @global_env_id
+      initiate_mapping_removal(thread) unless @env_id[thread_id]
+      @env_id[thread_id] = @global_env_id
+    end
+
+    # Starts another thread which will delete current thread's
+    # environment hash entry as soon as current thread terminates.
+    #
+    # noinspection RubyResolve
+    def initiate_mapping_removal(thread)
+      thread_id = thread.object_id
+      LOG.debug 'Initiating removal task for thread-to-environment mapping '\
+                  '{ {} => :{} }', thread_id, @global_env_id
+      Thread.new do
+        thread.join
+        deleted = @env_id.delete thread_id
+        LOG.debug 'Removed thread-to-environment mapping '\
+                    '{ {} => :{} }', thread_id, deleted
+      end
+    end
+
+    public
+
+    # Provides MangoPay configuration object for current environment.
+    #
+    # noinspection RubyResolve
+    def configuration
+      env = environment
+      env.configuration ||
+        raise("MangoPay.configure() was not called for environment #{env.id}")
+    end
+
+    # Allows configuration of the current MangoPay environment.
+    # Yields configuration object to a provided block.
+    #
+    # noinspection RubyResolve
+    def configure
+      env = environment
+      LOG.info 'Configuring environment :{}', env.id
+      config = env.configuration || MangoPay::Configuration.new
+      yield config
+      validate config
+      LOG.info 'Successfully configured environment :{} for client {}',
+               env.id, config.client_id
+      env.configuration = config
+    end
+
+    private
+
+    # Validates a provided MangoPay configuration.
+    def validate(config)
+      cause_message = 'You must specify your client ID'
+      raise cause_message unless config.client_id
+      cause_message = 'You must specify your client passphrase'
+      raise cause_message unless config.client_passphrase
+      config.root_url = config.preproduction? ? SANDBOX_API_URL : MAIN_API_URL\
+                          unless config.root_url
+    end
+  end
+end

data/lib/mangopay/api/api.rb

@@ -0,0 +1,9 @@
+require_relative 'http_client'
+require_relative 'service/oauth_tokens'
+require_relative 'service/users'
+require_relative 'auth_token_manager'
+require_relative '../common/response_error'
+
+# Module for service classes
+module MangoApi
+end

data/lib/mangopay/api/api_methods.rb

@@ -0,0 +1,137 @@
+require 'forwardable'
+
+module MangoApi
+
+  # Declares API method URLs.
+  class ApiMethods
+    class << self
+      extend Forwardable
+
+      @hash = {
+        create_token: %w[POST oauth/token],
+
+        create_user: %w[POST %(users/#{_param1.person_type.to_s.downcase})],
+        update_user: %w[PUT %(users/#{_param1}/#{_param2})],
+        get_user: %w[GET %(users/#{_param1})],
+        get_users: %w[GET users],
+
+        create_account: %w[POST %(users/#{_param1.user_id}/bankaccounts/#{_param1.type.to_s.downcase})],
+        deactivate_account: %w[PUT %(users/#{_param1}/bankaccounts/#{_param2})],
+        get_account: %w[GET %(users/#{_param1}/bankaccounts/#{_param2})],
+        get_accounts: %w[GET %(users/#{_param1}/bankaccounts)],
+
+        create_wallet: %w[POST wallets],
+        update_wallet: %w[PUT %(wallets/#{_param1.id})],
+        get_wallet: %w[GET %(wallets/#{_param1})],
+        get_users_wallets: %w[GET %(users/#{_param1}/wallets)],
+
+        update_client: %w[PUT clients],
+        get_client: %w[GET clients],
+        upload_client_logo: %w[PUT clients/logo],
+
+        get_client_wallet: %w[GET %(clients/wallets/#{_param1.to_s}/#{_param2.to_s})],
+        get_client_wallets: %w[GET clients/wallets],
+        get_client_wallets_funds_type: %w[GET %(clients/wallets/#{_param1.to_s})],
+
+        get_users_e_money: %w[GET %(users/#{_param1}/emoney)],
+
+        create_transfer: %w[POST transfers],
+        get_transfer: %w[POST %(transfers/#{_param1})],
+
+        create_card_web_pay_in: %w[POST payins/card/web],
+        create_card_direct_pay_in: %w[POST payins/card/direct],
+        create_card_pre_authorized_pay_in: %w[POST payins/preauthorized/direct],
+        create_bank_wire_direct_pay_in: %w[POST payins/bankwire/direct],
+        create_client_bank_wire_direct_pay_in: %w[POST clients/payins/bankwire/direct],
+        create_direct_debit_web_pay_in: %w[POST payins/directdebit/web],
+        create_direct_debit_direct_pay_in: %w[POST payins/directdebit/direct],
+        get_pay_in: %w[GET %(payins/#{_param1})],
+
+        get_extended_card_view: %w[GET %(payins/card/web/#{_param1}/extended)],
+
+        create_card_registration: %w[POST cardregistrations],
+        complete_card_registration: %w[PUT %(cardregistrations/#{_param1})],
+        get_card_registration: %w[GET %(cardregistrations/#{_param1})],
+
+        get_card: %w[GET %(cards/#{_param1})],
+        get_users_cards: %w[GET %(users/#{_param1}/cards)],
+        get_cards_by_fingerprint: %w[GET %(cards/fingerprints/#{_param1})],
+        deactivate_card: %w[PUT %(cards/#{_param1})],
+
+        get_users_transactions: %w[GET %(users/#{_param1}/transactions)],
+        get_wallets_transactions: %w[GET %(wallets/#{_param1}/transactions)],
+        get_disputes_transactions: %w[GET %(disputes/#{_param1}/transactions)],
+        get_clients_transactions: %w[GET %(clients/transactions)],
+        get_client_wallets_transactions: %w[GET %(clients/wallets/#{_param1.to_s}/#{_param2.to_s}/transactions)],
+        get_pre_authorizations_transactions: %w[GET %(preauthorizations/#{_param1}/transactions)],
+
+        create_pre_authorization: %w[POST preauthorizations/card/direct],
+        get_pre_authorization: %w[GET %(preauthorizations/#{_param1})],
+        cancel_pre_authorization: %w[PUT %(preauthorizations/#{_param1})],
+
+        create_mandate: %w[POST mandates/directdebit/web],
+        get_mandate: %w[GET %(mandates/#{_param1})],
+        cancel_mandate: %w[PUT %(mandates/#{_param1}/cancel)],
+        get_mandates: %w[GET mandates],
+        get_users_mandates: %w[GET %(users/#{_param1}/mandates)],
+        get_accounts_mandates: %w[GET %(users/#{_param1}/bankaccounts/#{_param2}/mandates)],
+
+        create_pay_out: %w[POST payouts/bankwire],
+        get_pay_out: %w[GET %(payouts/#{_param1})],
+
+        create_kyc_document: %w[POST %(users/#{_param1}/kyc/documents)],
+        upload_kyc_document_page: %w[POST %(users/#{_param1}/kyc/documents/#{_param2}/pages)],
+        submit_kyc_document: %w[PUT %(users/#{_param1}/kyc/documents/#{_param2})],
+        get_users_kyc_documents: %w[GET %(users/#{_param1}/kyc/documents)],
+        get_kyc_documents: %w[GET kyc/documents],
+        consult_kyc_document: %w[POST %(kyc/documents/#{_param1}/consult)],
+
+        create_ubo_declaration: %w[POST %(users/legal/#{_param1}/ubodeclarations)],
+        update_ubo_declaration: %w[PUT %(ubodeclarations/#{_param1})],
+        submit_ubo_declaration: %w[PUT %(ubodeclarations/#{_param1})],
+
+        create_hook: %w[POST hooks],
+        update_hook: %w[PUT %(hooks/#{_param1})],
+        get_hook: %w[GET %(hooks/#{_param1})],
+        get_hooks: %w[GET hooks],
+
+        get_events: %w[GET events],
+
+        create_pay_in_refund: %w[POST %(payins/#{_param1}/refunds)],
+        create_transfer_refund: %w[POST %(transfers/#{_param1}/refunds)],
+
+        update_dispute: %w[PUT %(disputes/#{_param1})],
+        close_dispute: %w[PUT %(disputes/#{_param1}/close)],
+        submit_dispute: %w[PUT %(disputes/#{_param1}/submit)],
+        resubmit_dispute: %w[PUT %(disputes/#{_param1}/submit)],
+        get_dispute: %w[GET %(disputes/#{_param1})],
+        get_users_disputes: %w[GET %(users/#{_param1}/disputes)],
+        get_wallets_disputes: %w[GET %(wallets/#{_param1}/disputes)],
+        get_disputes_pending_settlement: %w[GET disputes/pendingsettlement],
+        get_disputes: %w[GET disputes],
+
+        create_dispute_document: %w[POST %(disputes/#{_param1}/documents)],
+        upload_dispute_document_page: %w[POST %(disputes/#{_param1}/documents/#{_param2}/pages)],
+        submit_dispute_document: %w[PUT %(disputes/#{_param1}/documents/#{_param2})],
+        get_dispute_document: %w[GET %(dispute-documents/#{_param1})],
+        get_disputes_documents: %w[GET %(disputes/#{_param1}/documents)],
+        get_dispute_documents: %w[GET dispute-documents],
+        consult_dispute_document: %w[POST %(dispute-documents/#{_param1}/consult)],
+
+        get_repudiation: %w[GET %(repudiations/#{_param1})],
+
+        create_settlement_transfer: %w[POST %(repudiations/#{_param1}/settlementtransfer)],
+        get_settlement_transfer: %w[GET %(settlements/#{_param1})],
+
+        create_transaction_report: %w[POST reports/transactions],
+        create_wallet_report: %w[POST reports/wallets],
+        get_report: %w[GET %(reports/#{_param1})],
+        get_reports: %w[GET reports],
+
+        replicate_response: %w[GET %(responses/#{_param1})]
+      }
+
+      def_delegators @hash, :[]
+    end
+  end
+end

data/lib/mangopay/api/auth_token_manager.rb

@@ -0,0 +1,173 @@
+require 'fileutils'
+require_relative '../common/log_provider'
+
+module MangoApi
+
+  # Manages acquisition and storage of API authorization token.
+  module AuthTokenManager
+    LOG = MangoPay::LogProvider.provide(self)
+
+    class << self
+
+      # Provides a valid authorization token for API calls.
+      def token
+        client_id = MangoPay.configuration.client_id
+        token_valid? && storage.retrieve_for(client_id) || refresh_token
+      end
+
+      private
+
+      # Retrieves authorization token storage object.
+      def storage
+        return @storage if @storage
+        init_storage
+      end
+
+      # Initializes storage strategy for OAuth tokens.
+      # Returns the storage object.
+      def init_storage
+        client_id = MangoPay.configuration.client_id
+        dir = MangoPay.configuration.temp_dir
+        @storage = dir ? FileStorage.new : MemoryStorage.new
+        strategy = @storage.class.name.split('::').last
+        location_if_file = dir ? " at '/#{dir}'" : ''
+        LOG.info 'Using {}{} for {} client\'s OAuth tokens',
+                 strategy, location_if_file, client_id
+        @storage
+      end
+
+      # Returns true if the current client's
+      # authorization token is valid
+      def token_valid?
+        !token_invalid?
+      end
+
+      # Returns true if the current client's
+      # stored token is no longer valid.
+      def token_invalid?
+        token = storage.retrieve_for MangoPay.configuration.client_id
+        token.nil? ||
+          token['expire_time'].nil? ||
+          token['expire_time'] <= Time.now ||
+          token['environment_key'] != environment_key
+      end
+
+      # Provides a configuration-specific hash key.
+      def environment_key
+        config = MangoPay.configuration
+        key = [config.root_url, config.client_id, config.client_passphrase]
+              .join('|')
+        Digest::MD5.hexdigest(key)
+      end
+
+      # Refreshes the stored authorization token.
+      def refresh_token
+        LOG.info 'Refreshing OAuth token'
+        config = MangoPay.configuration
+        unless config.client_id && config.client_passphrase
+          raise 'You must specify your client ID and passphrase'
+        end
+        token = MangoApi::OAuthTokens.create(config)
+        append_data token
+        store_token token
+        token
+      end
+
+      # Appends some useful data to the token object.
+      #
+      # @param +token+ the token object
+      def append_data(token)
+        token['expire_time'] = Time.now + token['expires_in'].to_i
+        token['environment_key'] = environment_key
+      end
+
+      # Stores the OAuth token.
+      #
+      # @param +token+ the OAuth token to be stored
+      def store_token(token)
+        client_id = MangoPay.configuration.client_id
+        storage.store_for client_id, token
+        LOG.info 'OAuth token stored in {} for client {}',
+                 storage.class.name.split('::').last, client_id
+      end
+    end
+  end
+
+  # Stores client-specific OAuth tokens in-memory.
+  class MemoryStorage
+    def initialize
+      @token = {}
+    end
+
+    # Retrieves a client-specific OAuth token.
+    #
+    # @param +client_id+ ID of the client whose token to retrieve
+    def retrieve_for(client_id)
+      @token[client_id]
+    end
+
+    # Stores a client-specific OAuth token.
+    #
+    # @param +client_id+ ID of the client for which token is being stored
+    # @param +token+ OAuth token for this client
+    def store_for(client_id, token)
+      @token[client_id] = token
+    end
+  end
+
+  # Stores client-specific OAuth tokens in temporary files
+  # in the user-specified directory.
+  class FileStorage
+    require 'yaml'
+
+    def initialize
+      @temp_dir = MangoPay.configuration.temp_dir
+      raise 'Path to temporary folder is not defined' unless @temp_dir
+    end
+
+    # Retrieves a client's OAuth token from its storage file.
+    #
+    # @param +client_id+ ID of the client whose OAuth token to retrieve
+    #
+    # noinspection RubyResolve
+    def retrieve_for(client_id)
+      path = file_path(client_id)
+      return nil unless File.exist? path
+      File.open(path, 'r') do |file|
+        file.flock File::LOCK_SH
+        oauth_data = file.read
+        YAML.load oauth_data || nil
+      end
+    end
+
+    # Generates the file path to a certain client's OAuth token file.
+    #
+    # @param +client_id+ ID of the client whose file path to generate
+    def file_path(client_id)
+      File.join(@temp_dir, "mangopay_oauth_token_#{client_id}.tmp")
+    end
+
+    # Stores client-specific OAuth token in its own file.
+    #
+    # @param +client_id+ ID of the client whose token is being stored
+    # @param +token+ OAuth token for this client
+    #
+    # noinspection RubyResolve
+    def store_for(client_id, token)
+      ensure_folder_exists MangoPay.configuration.temp_dir
+      File.open(file_path(client_id), 'w') do |file|
+        file.flock File::LOCK_EX
+        file.truncate(0)
+        file.rewind
+        file.puts YAML.dump(token)
+      end
+    end
+
+    # Creates a folder at the given path if none exists.
+    #
+    # @param +folder+ path at which folder should exist
+    def ensure_folder_exists(folder)
+      FileUtils.mkdir_p folder unless File.directory?(folder)
+    end
+  end
+end