mangopay 2.0.0

data/lib/mangopay/immediate_contribution.rb

@@ -0,0 +1,58 @@
+module MangoPay
+  # An immediate contribution is a request to process directly a payment with a payment card already registred by the user.
+  class ImmediateContribution < MangoPay::Ressource
+
+    # Create an immediate contribution
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * UserID
+    #               * WalletID
+    #               * Amount
+    #               * PaymentCardID
+    #               * [ClientFeeAmount]
+    # * *Returns* :
+    #   - An immediate contribution object
+    #
+    def self.create(data)
+      post_request('immediate-contributions', data)
+    end
+
+    # Get an immediate contribution
+    #
+    # * *Args*    :
+    #   - +immediate_contribution_id+ -> The id of the immediate contribution you want to retrieve
+    # * *Returns* :
+    #   - An immediate contribution object
+    #
+    def self.details(immediate_contribution_id)
+      get_request(File.join('immediate-contributions', immediate_contribution_id.to_s))
+    end
+
+    # Refund a given immediate contribution
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * ImmediateContributionID
+    #               * UserID
+    # * *Returns* :
+    #   - A refund object
+    #
+    def self.refund(data)
+      post_request(File.join('refunds'), data)
+    end
+
+    # Get a refund object
+    #
+    # * *Args*    :
+    #   - +immediate_contribution_refund_id+ -> The id of the refund you want to retrieve
+    # * *Returns* :
+    #   - A refund object
+    #
+    def self.get_refund(immediate_contribution_refund_id)
+      get_request(File.join('refunds', immediate_contribution_refund_id.to_s))
+    end
+  end
+end

data/lib/mangopay/operation.rb

@@ -0,0 +1,16 @@
+module MangoPay
+    # Operation
+    class Operation < MangoPay::Ressource
+
+        # Get an operation
+        #
+        # * *Args*    :
+        #   - +operation_id+ -> The id of the operation you want to retrieve
+        # * *Returns* :
+        #   - An operation object
+        #
+        def self.get(operation_id)
+            get_request(File.join('operations', operation_id.to_s))
+        end
+    end
+end

data/lib/mangopay/recurrent_contribution.rb

@@ -0,0 +1,62 @@
+module MangoPay
+
+  # Recurrent Contribution are available in test environment only, soon in production.
+  class RecurrentContribution < MangoPay::Ressource
+
+    # Create a recurrent contribution
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * UserID
+    #               * WalletID
+    #               * Amount
+    #               * [ClientFeeAmount]
+    #               * ReturnURL
+    #               * [TemplateURL]
+    #               * StartDate
+    #               * FrequencyCode
+    #               * NumberOfExecutions
+    # * *Returns* :
+    #   - A recurrent contribution object
+    #
+    def self.create(data)
+      post_request('recurrent-contributions', data)
+    end
+
+    # Get a recurrent contribution
+    #
+    # * *Args*    :
+    #   - +recurrent_contributions_id+ -> The id of the recurrent contribution you want to retrieve
+    # * *Returns* :
+    #   - A recurrent contribution object
+    #
+    def self.get(recurrent_contributions_id)
+      get_request(File.join('recurrent-contributions', recurrent_contributions_id.to_s))
+    end
+
+    # Update a recurrent contribution
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * IsEnabled
+    #               * [Tag]
+    # * *Returns* :
+    #   - A recurrent contribution object
+    #
+    def self.update(recurrent_contributions_id, data)
+      put_request(File.join('recurrent-contributions', recurrent_contributions_id.to_s), data)
+    end
+
+    # Fetch the list of a recurrent contribution executions
+    #
+    # * *Args*    :
+    #   - +recurrent_contributions_id+ -> The id of the recurrent contribution you want to retrieve operations from
+    # * *Returns* :
+    #   - An array of payment execution
+    #
+    def self.get_executions(recurrent_contributions_id)
+      get_request(File.join('recurrent-contributions', recurrent_contributions_id.to_s, 'executions'))
+    end
+  end
+end

data/lib/mangopay/ressource.rb

@@ -0,0 +1,96 @@
+module MangoPay
+  class Ressource
+
+    protected
+
+    def self.post_request(route, data)
+      request('POST', route, data)
+    end
+
+    def self.get_request(route, options=nil)
+      request('GET', route, nil, options)
+    end
+
+    def self.put_request(route, data)
+      request('PUT', route, data)
+    end
+
+    def self.delete_request(route)
+      request('DELETE', route)
+    end
+
+    def self.form_request(upload_url, file_name, file_path)
+      url = URI(upload_url)
+      File.open(file_path) do |file|
+        req = Net::HTTP::Post::Multipart.new(url.request_uri, :file => UploadIO.new(file, file_type(file_path), file_name))
+        res = Net::HTTP.start(url.host, url.port, :use_ssl => url.scheme == 'https') do |http|
+          http.request(req)
+        end
+        res.code == "200" ? true : false
+      end
+    end
+
+    private
+
+    def self.request(method, route, data=nil, options=nil)
+      path = path_for(route, options)
+      uri = uri_for(path)
+      method = method.upcase
+      data = data.to_json unless data.nil?
+      headers = header_for(method, path, data)
+      res = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        case method
+        when 'POST'   then request = Net::HTTP::Post.new(uri.request_uri, headers)
+        when 'GET'    then request = Net::HTTP::Get.new(uri.request_uri, headers)
+        when 'PUT'    then request = Net::HTTP::Put.new(uri.request_uri, headers)
+        when 'DELETE' then request = Net::HTTP::Delete.new(uri.request_uri, headers)
+        else
+          return {}
+        end
+        request.body = data unless data.nil?
+        http.request request
+      end
+      begin
+        JSON.parse(res.body)
+      rescue JSON::ParserError
+        res.body.is_a?(String) ? res.body : {' ErrorCode' => -1 }
+      end
+    end
+
+    def self.key
+      OpenSSL::PKey::RSA.new(File.read(MangoPay.configuration.key_path), MangoPay.configuration.key_password)
+    end
+
+    def self.path_for(route, options)
+      File.join('', 'v1', 'partner', MangoPay.configuration.partner_id, route.to_s) + "?ts=#{Time.now.to_i.to_s}" + (options.nil? ? '' : ('&' + options))
+    end
+
+    def self.uri_for(path)
+      URI(File.join(MangoPay.configuration.base_url, path))
+    end
+
+    def self.sign(data)
+      Base64.encode64(key.sign('sha1', data)).to_s.chomp.gsub(/\n/, '')
+    end
+
+    def self.signature_for(method, path, data)
+      sign("#{method}|#{path}|" + (data.nil? ? '' : "#{data}|"))
+    end
+
+    def self.header_for(method, path, data)
+      { 'X-Leetchi-Signature' => signature_for(method, path, data), 'Content-Type' => 'application/json' }
+    end
+
+    def self.file_type(file_path)
+      file_types = {
+        'jpg' => 'image/jpeg',
+        'jpeg' => 'image/jpeg',
+        'gif' => 'image/gif',
+        'png' => 'image/png',
+        'pdf' => 'image/pdf'
+      }
+      file_types[file_path.gsub(/^[^\.]+\./, "")]
+    end
+  end
+end
+

data/lib/mangopay/strong_authentication.rb

@@ -0,0 +1,28 @@
+module MangoPay
+    # Get all the strongAuthentication created who need to be validated.
+    # It's important to understand that MangoPay can create himself the request of strongAuthentication, if a user reaches some limits.
+    class StrongAuthentication < MangoPay::Ressource
+
+        # Get all the strongAuthentication created who need to be validated
+        #
+        # * *Returns* :
+        #   - A array of strongAuthentication objects
+        #
+        def self.get
+            get_request(File.join('strongAuthentication'))
+        end
+
+        # Upload your Strong Authentication required files using the MangoPay API
+        #
+        # * *Args*    :
+        #   - +upload_url+ -> The url to where the StrongAuthentication documents need to be uploaded
+        #   - +file_path+ -> Local path to the file
+        # * *Returns* :
+        #   - true if the request is done
+        #   - false if the request failed
+        #
+        def self.upload(upload_url, file_path)
+            form_request(upload_url, "StrongValidationDto.Picture", file_path)
+        end
+    end
+end

data/lib/mangopay/transfer.rb

@@ -0,0 +1,58 @@
+module MangoPay
+  # The Transfer class if you want to make any transfer between two wallets
+  class Transfer < MangoPay::Ressource
+
+    # Create a transfer from one personal wallet to another wallet
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * [PayerID]
+    #               * [BeneficiaryID]
+    #               * Amount
+    #               * [ClientFeeAmount] (In preproduction environnment only, soon in production)
+    #               * [PayerWalletID]
+    #               * [BeneficiaryWalletID]
+    # * *Returns* :
+    #   - A transfer object
+    #
+    def self.create(data)
+      post_request('transfers', data)
+    end
+
+    # Get a transfer
+    #
+    # * *Args*    :
+    #   - +tranfer_id+ -> The id of the transfer you want to retrieve
+    # * *Returns* :
+    #   - A transfer object
+    #
+    def self.details(transfer_id)
+      get_request(File.join('transfers', transfer_id.to_s))
+    end
+
+    # Refund a contribution from a personal wallet to a shared walletTransferID
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * TransfertID
+    #               * UserID
+    # * *Returns* :
+    #   - A transfer refund object
+    #
+    def self.refund(data)
+      post_request(File.join('transfer-refunds'), data)
+    end
+
+    # Get a refund transfer object
+    #
+    # * *Args*    :
+    #   - +transfer_refund_id+ -> The id of the transfer refund you want to retrieve
+    # * *Returns* :
+    #   - A transfer refund object
+    #
+    def self.get_refund(transfer_refund_id)
+      get_request(File.join('transfer-refunds', transfer_refund_id.to_s))
+    end
+  end
+end

data/lib/mangopay/user.rb

@@ -0,0 +1,148 @@
+module MangoPay
+  # Use the User class for any operations related to the user
+  class User < MangoPay::Ressource
+
+    # Create a new user
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * [Email]
+    #               * [FirstName]
+    #               * [LastName]
+    #               * [CanRegisterMeanOfPayment] true by default
+    #               * IP
+    #               * [Birthday]
+    #               * [Password]
+    # * *Returns* :
+    #   - A user object
+    #
+    def self.create(data)
+      post_request('users', data)
+    end
+
+    # Get a user
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve
+    # * *Returns* :
+    #   - A user object
+    #
+    def self.details(user_id)
+      get_request(File.join('users', user_id.to_s))
+    end
+
+    # Update a given user
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to update
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * [Email]
+    #               * [FirstName]
+    #               * [LastName]
+    #               * [CanRegisterMeanOfPayment]
+    #               * [Password]
+    # * *Returns* :
+    #   - A user object
+    #
+    def self.update(user_id, data)
+      put_request(File.join('users', user_id.to_s), data)
+    end
+
+    # Get a list of the given user wallets
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve wallets from
+    # * *Returns* :
+    #   - An array of wallets objects
+    #
+    def self.get_wallets(user_id)
+      get_request(File.join('users', user_id.to_s, 'wallets'))
+    end
+
+    # Get a list of the given user payment cards
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve cards from
+    # * *Returns* :
+    #   - An array of registered payment cards objects
+    #
+    def self.cards(user_id)
+      get_request(File.join('users', user_id.to_s, 'cards'))
+    end
+
+    # Get operations associated with a user
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve operations from
+    # * *Returns* :
+    #   - An array of operations objects
+    #
+    def self.operations(user_id)
+      get_request(File.join('users', user_id.to_s, 'operations'))
+    end
+
+    # Get operations from the given user personal account
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve operations from
+    # * *Returns* :
+    #   - An array of operations objects
+    #
+    def self.personal_operations(user_id)
+      get_request(File.join('users', user_id.to_s, 'operations', 'personal'))
+    end
+
+    # Create a request of strong user authentication.
+    # If a strongAuthentication object already exist for the user, this request returns the existing object.
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to strongly authenticate
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    # * *Returns* :
+    #   - A Strong Authentication object
+    #
+    def self.create_strong_authentication(user_id, data)
+      post_request(File.join('users', user_id.to_s, 'strongAuthentication'), data)
+    end
+
+    # Get a Strong Authentication object
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve the strong authentication object from
+    # * *Returns* :
+    #   - A Strong Authentication object
+    #
+    def self.get_strong_authentication(user_id)
+      get_request(File.join('users', user_id.to_s, 'strongAuthentication'))
+    end
+
+    # Update a Strong Authentication object
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to update the strong authentication object from
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * [IsDocumentsTransmitted]
+    # * *Returns* :
+    #   - A Strong Authentication object
+    #
+    def self.update_strong_authentication(user_id, data)
+      put_request(File.join('users', user_id.to_s, 'strongAuthentication'), data)
+    end
+
+    # Get the expense sites for a given user
+    #
+    # * *Args*    :
+    #   - +user_id+ -> The id of the user you want to retrieve the expense sites from
+    #   - +wallet_id+ -> The id of the wallet you want to retrieve the expense sites from
+    # * *Returns* :
+    #   - An array of expense site objects
+    #
+    def self.expense_sites(user_id, wallet_id)
+      get_request(File.join('expense-sites'), "userID=#{user_id.to_s}&walletID=#{wallet_id.to_s}")
+    end
+  end
+end