mangopay 2.0.0 → 3.0.0

data/lib/mangopay/strong_authentication.rb

@@ -1,28 +0,0 @@
-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/withdrawal.rb

@@ -1,40 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

data/spec/lib/mangopay/operation_spec.rb

@@ -1,8 +0,0 @@
-require_relative '../../spec_helper'
-
-describe MangoPay::Operation do
-
-    it "gets the operation" do
-        operation = MangoPay::Operation.get(1)
-    end
-end

data/spec/lib/mangopay/recurrent_contribution_spec.rb

@@ -1,55 +0,0 @@
-require_relative '../../spec_helper'
-
-describe MangoPay::RecurrentContribution do
-
-    let(:new_user) {
-        MangoPay::User.create({
-            'Tag' => 'test',
-            'Email' => 'my@email.com',
-            'FirstName' => 'John',
-            'LastName' => 'Doe',
-            'CanRegisterMeanOfPayment' => true
-            })
-    }
-
-    let(:new_recurrent_contribution) {
-        MangoPay::RecurrentContribution.create({
-            'Tag' => 'test-recurrent-contribution',
-            'UserID' => new_user['ID'],
-            'WalletID' => 0,
-            'Amount' => 4200,
-            'StartDate' => '1388534400',
-            'FrequencyCode' => 'TwiceMonthly',
-            'NumberOfExecutions' => 10,
-            'ReturnURL' => 'http://leetchi.com'
-            })
-    }
-
-    describe "CREATE" do
-        it "create a new recurrent contribution and return a PaymentURL" do
-            expect(new_recurrent_contribution['PaymentURL']).not_to be_empty
-        end
-    end
-
-    describe "GET" do
-        it "get a recurrent contribution" do
-            recurrent_contribution = MangoPay::RecurrentContribution.get(new_recurrent_contribution["ID"])
-            expect(recurrent_contribution["ID"]).to eq(new_recurrent_contribution["ID"])
-        end
-    end
-
-    describe "UPDATE" do
-        it "updates a recurrent contribution" do
-            recurrent_contribution = MangoPay::RecurrentContribution.update(new_recurrent_contribution["ID"], { :IsEnabled => false })
-            expect(recurrent_contribution["IsEnabled"]).to be_false
-        end
-    end
-
-    describe "GET_EXECUTIONS" do
-        it "get a list of the recurrent contribution executions" do
-            recurrent_contribution_executions = MangoPay::RecurrentContribution.get_executions(new_recurrent_contribution["ID"])
-            expect(recurrent_contribution_executions).to be_a_kind_of(Array)
-            expect(recurrent_contribution_executions).to be_empty
-        end
-    end
-end