mangopay 2.0.0

data/lib/mangopay/wallet.rb

@@ -0,0 +1,93 @@
+module MangoPay
+  class Wallet < MangoPay::Ressource
+
+    # Create a Wallet
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * Owners (an array of user IDs, but only one is supported now)
+    #               * [Name]
+    #               * [Description]
+    #               * [RaisingGoalAmount]
+    #               * [ContributionLimitDate]
+    # * *Returns* :
+    #   - A wallet object
+    #
+    def self.create(data)
+      post_request('wallets', data)
+    end
+
+    # Get a wallet
+    #
+    # * *Args*    :
+    #   - +wallet_id+ -> The id of the wallet you want to retrieve
+    # * *Returns* :
+    #   - A wallet object
+    #
+    def self.details(wallet_id)
+      get_request(File.join('wallets', wallet_id.to_s))
+    end
+
+    # Update a wallet
+    #
+    # * *Args*    :
+    #   - +wallet_id+ -> The id of the wallet you want to update
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Name]
+    #               * [Description]
+    #               * [RaisingGoalAmount]
+    #               * [SuggestedAmount]
+    #               * [ExpirationDate] [Tag]
+    # * *Returns* :
+    #   - A wallet object
+    #
+    def self.update(wallet_id, data)
+      put_request(File.join('wallets', wallet_id.to_s), data)
+    end
+
+    # Get the owners of a wallet
+    #
+    # * *Args*    :
+    #   - +wallet_id+ -> The id of the wallet you want to retrieve the owners from
+    # * *Returns* :
+    #   - An array of users objects
+    #
+    def self.get_owners(wallet_id)
+      get_request(File.join('wallets', wallet_id.to_s, 'users'), 'owners=1')
+    end
+
+    # Get the contributors of a wallet
+    #
+    # * *Args*    :
+    #   - +wallet_id+ -> The id of the wallet you want to retrieve the contributors from
+    # * *Returns* :
+    #   - An array of users objects
+    #
+    def self.get_contributors(wallet_id)
+      get_request(File.join('wallets', wallet_id.to_s, 'users'), 'contributors=1')
+    end
+
+    # Get the refunded users of a wallet
+    #
+    # * *Args*    :
+    #   - +wallet_id+ -> The id of the wallet you want to refunded users the owners from
+    # * *Returns* :
+    #   - An array of users objects
+    #
+    def self.get_refunded(wallet_id)
+      get_request(File.join('wallets', wallet_id.to_s, 'users'), 'refunded=1')
+    end
+
+    # Get the operations for a given wallet
+    #
+    # * *Args*    :
+    #   - +wallet_id+ -> The is of the wallet you want to retrieve operations from
+    # * *Returns* :
+    #   - An array of operations objects
+    #
+    def self.operations(wallet_id)
+      get_request(File.join('wallets', wallet_id.to_s, 'operations'))
+    end
+  end
+end

data/lib/mangopay/withdrawal.rb

@@ -0,0 +1,40 @@
+module MangoPay
+  # A withdrawal is a request to get the money from a wallet or a personal account to a bank account.
+  class Withdrawal < MangoPay::Ressource
+
+    # Create a withdrawal
+    # Only one amount can be present in the withdrawal request: either AmountWithoutFees or Amount (that is amount with fees).
+    # Amount = AmountWithoutFees + ClientFeeAmount
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * UserID
+    #               * WalletID
+    #               * AmountWithoutFees
+    #               * Amount
+    #               * BeneficiaryID
+    #               * [ClientFeeAmount]
+    # * *Returns* :
+    #   - A withdrawal object
+    # * *Raises* :
+    #   - +2001+ -> Invalid withdrawal amount
+    #   - +2002+ -> Both parameters are specified: Amount and AmountWithoutFees
+    #   - +2003+ -> Invalid withdrawal ClientFeeAmount
+    #
+    def self.create(data)
+      post_request('withdrawals', data)
+    end
+
+    # Get a withdrawal
+    #
+    # * *Args*    :
+    #   - +withdrawal_id+ -> The id of the withdrawal you want to retrieve
+    # * *Returns* :
+    #   - A withdrawal object
+    #
+    def self.details(withdrawal_id)
+      get_request(File.join('withdrawals', withdrawal_id.to_s))
+    end
+  end
+end

data/lib/mangopay/withdrawal_contribution.rb

@@ -0,0 +1,32 @@
+module MangoPay
+
+  class WithdrawalContribution < MangoPay::Ressource
+
+    # Create a withdrawal contribution
+    #
+    # * *Args*    :
+    #   - +data+ -> A JSON with the following attributes (Square brackets for optionals):
+    #               * [Tag]
+    #               * UserID
+    #               * WalletID
+    #               * AmountDeclared
+    # * *Returns* :
+    #   - A withdrawal contribution object
+    #
+    def self.create(data)
+      post_request('contributions-by-withdrawal', data)
+    end
+
+
+    # Get a withdrawal contribution
+    #
+    # * *Args*    :
+    #   - +withdrawal_contribution_id+ -> The id of the withdrawal contribution you want to retrieve
+    # * *Returns* :
+    #   - A withdrawal contribution object
+    #
+    def self.get(withdrawal_contribution_id)
+      get_request(File.join('contributions-by-withdrawal', withdrawal_contribution_id.to_s))
+    end
+  end
+end

data/spec/lib/mangopay/beneficiary_spec.rb

@@ -0,0 +1,124 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Beneficiary do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_beneficiary) {
+        MangoPay::Beneficiary.create({
+            'Tag' => 'test',
+            'UserID' => new_user['ID'],
+            'BankAccountOwnerName' => new_user['FirstName'],
+            'BankAccountOwnerAddress' => '1 bis cite paradis',
+            'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+            'BankAccountBIC' => 'AGRIFRPP879'
+            })
+    }
+
+    let(:new_strong_authentication) {
+        MangoPay::Beneficiary.create_strong_authentication(new_beneficiary['ID'], {
+            'Tag' => 'test_beneficiary_strong_authentication'
+            })
+    }
+
+    describe "CREATE" do
+
+        it "create a beneficiary" do
+            expect(new_beneficiary['ID']).not_to be_nil
+            expect(new_beneficiary['UserID']).to eq(new_user['ID'])
+        end
+
+        it "fails and returns a 2004 error code" do
+            fail_beneficiary = MangoPay::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+                'BankAccountBIC' => 'AGRIFRPP879'
+                })
+            expect(fail_beneficiary["ErrorCode"]).to eq(2004)
+        end
+
+        it "fails and returns a 2005 error code" do
+            fail_beneficiary = MangoPay::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+                'BankAccountBIC' => 'AGRIFRPP879'
+                })
+            expect(fail_beneficiary["ErrorCode"]).to eq(2005)
+        end
+
+        it "fail and returns a 2006 error code" do
+            fail_beneficiary = MangoPay::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+                'BankAccountBIC' => 'RPPdsakdnsajkdna79'
+                })
+            expect(fail_beneficiary["ErrorCode"]).to eq(2006)
+        end
+
+        it "fail and returns a 2007 error code" do
+            fail_beneficiary = MangoPay::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'OIJDSAOIJDSAOIDJSAOIJDSA',
+                'BankAccountBIC' => 'AGRIFRPP879'
+                })
+            expect(fail_beneficiary["ErrorCode"]).to eq(2007)
+        end
+
+        it "fail and returns a 2008 error code" do
+            fail_beneficiary = MangoPay::Beneficiary.create({
+                'Tag' => 'test',
+                'UserID' => new_user['ID'],
+                'BankAccountOwnerName' => new_user['FirstName'],
+                'BankAccountOwnerAddress' => '1 bis cite paradis',
+                'BankAccountIBAN' => 'GB87 BARC 2065 8244 9716 55',
+                'BankAccountBIC' => 'CRLYFRPP'
+                })
+            expect(fail_beneficiary["ErrorCode"]).to eq(2008)
+        end
+    end
+
+    describe "GET" do
+        it "it gets a beneficiary" do
+            beneficiary = MangoPay::Beneficiary.details(new_beneficiary["ID"])
+            expect(beneficiary["ID"]).to eq(new_beneficiary['ID'])
+        end
+    end
+
+    describe "StrongAuthentication" do
+        it "creates the beneficiary strong authentication request" do
+            expect(new_strong_authentication).not_to be_nil
+            expect(new_strong_authentication['BeneficiaryID']).to eq(new_beneficiary['ID'])
+        end
+        it "gets the beneficiary strong authentication request" do
+            strong_authentication = MangoPay::Beneficiary.get_strong_authentication(new_strong_authentication['BeneficiaryID'])
+            expect(strong_authentication['ID']).to eq(new_strong_authentication['ID'])
+        end
+        it "updated the beneficiary strong authentication request" do
+            strong_authentication = MangoPay::Beneficiary.update_strong_authentication(new_strong_authentication['BeneficiaryID'], {
+                'Tag' => 'test_beneficiary_strong_authentication2',
+                'IsDocumentsTransmitted' => true
+                })
+            expect(strong_authentication['ID']).to eq(new_strong_authentication['ID'])
+            expect(strong_authentication['Tag']).to eq('test_beneficiary_strong_authentication2')
+            expect(strong_authentication['IsDocumentsTransmitted']).to be_true
+        end
+    end
+end

data/spec/lib/mangopay/card_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Card, :type => :feature do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_card) do
+        card = MangoPay::Card.create({
+            'Tag' => 'test-card',
+            'OwnerID' => new_user['ID'],
+            'ReturnURL' => 'http://leetchi.com'
+            })
+        visit(card['RedirectURL'])
+        fill_in('number', :with => '4970100000000154')
+        fill_in('cvv', :with => '123')
+        click_button('paybutton')
+        card = MangoPay::Card.details(card['ID'])
+        while (card["CardNumber"] || []).length != 16 do
+            card = MangoPay::Card.details(card['ID'])
+        end
+        card
+    end
+
+    describe "CREATE" do
+        it "create a new card and return a redirect url" do
+            expect(new_card['RedirectURL']).not_to be_empty
+        end
+    end
+
+    describe "GET" do
+        it "get the users card" do
+            card = MangoPay::Card.details(new_card["ID"])
+            expect(card["ID"]).to eq(new_card["ID"])
+        end
+    end
+
+    describe "DELETE" do
+        it "delete the card" do
+            deleted_card = MangoPay::Card.delete(new_card["ID"])
+            expect(deleted_card).to eq("\"OK\"")
+        end
+    end
+
+end

data/spec/lib/mangopay/contribution_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Contribution, :type => :feature do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_contribution) do
+        contribution = MangoPay::Contribution.create({
+            'Tag' => 'test_contribution',
+            'UserID' => new_user['ID'],
+            'WalletID' => 0,
+            'Amount' => 10000,
+            'ReturnURL' => 'https://leetchi.com'
+            })
+        visit(contribution['PaymentURL'])
+        fill_in('number', :with => '4970100000000154')
+        fill_in('cvv', :with => '123')
+        click_button('paybutton')
+        contribution = MangoPay::Contribution.details(contribution['ID'])
+        while contribution["IsSucceeded"] == false do
+            contribution = MangoPay::Contribution.details(contribution['ID'])
+        end
+        contribution
+    end
+
+    let(:new_contribution_refund) {
+        MangoPay::Contribution.refund({
+            'ContributionID' => new_contribution['ID'],
+            'UserID' => new_user['ID'],
+            'Tag' => 'test_contribution_refund'
+            })
+    }
+
+    describe "CREATE" do
+        it "creates a contribution" do
+            expect(new_contribution['ID']).not_to be_nil
+            expect(new_contribution['PaymentURL']).not_to be_nil
+        end
+    end
+
+    describe "GET" do
+        it "get the contribution" do
+            contribution = MangoPay::Contribution.details(new_contribution['ID'])
+            expect(contribution['ID']).to eq(new_contribution['ID'])
+        end
+    end
+
+    describe "REFUND" do
+        it "creates a refund request for the contribution" do
+            expect(new_contribution_refund['ID']).not_to be_nil
+        end
+        it "gets the refund request" do
+            contribution_refund = MangoPay::Contribution.get_refund(new_contribution_refund['ID'])
+            expect(contribution_refund['ID']).to eq(new_contribution_refund['ID'])
+        end
+    end
+end

data/spec/lib/mangopay/expense_spec.rb

@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Expense do
+
+    describe "GET" do
+        it "get the expense" do
+            card = MangoPay::Expense.get(1)
+        end
+    end
+end

data/spec/lib/mangopay/immediate_contribution_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::ImmediateContribution, :type => :feature do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_card) do
+        card = MangoPay::Card.create({
+            'Tag' => 'test-card',
+            'OwnerID' => new_user['ID'],
+            'ReturnURL' => 'http://leetchi.com'
+            })
+        visit(card['RedirectURL'])
+        fill_in('number', :with => '4970100000000154')
+        fill_in('cvv', :with => '123')
+        click_button('paybutton')
+        card = MangoPay::Card.details(card['ID'])
+        while (card["CardNumber"] || []).length != 16 do
+            card = MangoPay::Card.details(card['ID'])
+        end
+        card
+    end
+
+    let(:new_immediate_contribution) do
+        c = MangoPay::ImmediateContribution.create({
+            'Tag' => 'test_contribution',
+            'UserID' => new_user['ID'],
+            'PaymentCardID' => new_card['ID'],
+            'WalletID' => 0,
+            'Amount' => 33300
+            })
+    end
+
+    let(:new_immediate_contribution_refund) {
+        MangoPay::ImmediateContribution.refund({
+            'ContributionID' => new_immediate_contribution['ID'],
+            'UserID' => new_user['ID'],
+            'Tag' => 'test_immediate_contribution_refund'
+            })
+    }
+
+    describe "CREATE" do
+        it "creates an immediate contribution" do
+            expect(new_immediate_contribution['ID']).not_to be_nil
+        end
+    end
+
+    describe "GET" do
+        it "get the immediate contribution" do
+            immediate_contribution = MangoPay::ImmediateContribution.details(new_immediate_contribution['ID'])
+            expect(immediate_contribution['ID']).to eq(new_immediate_contribution['ID'])
+        end
+    end
+
+    describe "REFUND" do
+        it "creates a refund request for the immediate contribution" do
+            expect(new_immediate_contribution_refund['ID']).not_to be_nil
+        end
+        it "gets the refund request" do
+            immediate_contribution_refund = MangoPay::ImmediateContribution.get_refund(new_immediate_contribution_refund['ID'])
+            expect(immediate_contribution_refund['ID']).to eq(new_immediate_contribution_refund['ID'])
+        end
+    end
+
+end