mangopay 3.0.31 → 3.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73c15899898b7b234b4acf3ce46155a7a206bd629b5ef98d682e6125d3c5cd52
-  data.tar.gz: f2e564568a12d93c36eb1fc42b70c21b6cf5753c18810b5cef5d28e8f1e1ae93
+  metadata.gz: 12dc8e2f6ecc5798628cbc487075f3d9bf7100d0d5c17e1ec2bdb6c6ab4d0592
+  data.tar.gz: 87aff78311a7331e52898938ce4824b5ce72f0b6338898a5b5f163ea012201bf
 SHA512:
-  metadata.gz: df581e3dd8afa4312a20388604c2b1f907908898e92d26db4cd3bab264e5ac11ea2a2448cccac73b55054fcdb68bbed07b58bff7e5ab99996dd0a378fce3d819
-  data.tar.gz: 48e91bdd987927f105cd7fea1ef4863211b78e1f2728106cd0ab2618049db67988cd6d445e542ece17915c829a4c29f88995e05d480434e712fb40cb9ceecbea
+  metadata.gz: a5c90e91c9dee7eb80e250d0f46d04b4af4995ae5cbe25e743eb5870e09b0dd6fa5f4055e5faa4770659a8b5296ba2421dc1d9883aaf4e31d841792ee3260fc8
+  data.tar.gz: e93958461b0ee968f492d79ae4b7b2402364d9bf7657c07162dac3558a409ce44f6d1706c29b8bed3b623535680e92452cde44a801f3aad844291532eba5a147

data/README.md

@@ -96,8 +96,8 @@ Along with each request, the rate limiting headers are automatically updated in
   MangoPay.ratelimit
 
   {
-    :limit=>["74", "74", "75", "908"], 
-    :remaining=>["2226", "4426", "8725", "104692"], 
+    :limit=>["74", "74", "75", "908"],
+    :remaining=>["2226", "4426", "8725", "104692"],
     :reset=>["1495615620", "1495616520", "1495618320", "1495701060"]
   }
 ```

data/lib/generators/mangopay/install_generator.rb

@@ -17,7 +17,7 @@ module Mangopay
           client = client_id_valid?
           remove_file 'config/initializers/mangopay.rb'
           @client_id = client_id
-          @client_passphrase = client['Passphrase']
+          @client_apiKey = client['APIKey']
           template 'mangopay.rb.erb', 'config/initializers/mangopay.rb'
         rescue => e
           puts e.message

data/lib/generators/templates/mangopay.rb.erb

@@ -1,5 +1,5 @@
 MangoPay.configure do |c|
   c.preproduction = <%= options[:preproduction] %>
   c.client_id = '<%= @client_id %>'
-  c.client_passphrase = '<%= @client_passphrase %>'
+  c.client_apiKey = '<%= @client_apiKey %>'
 end

data/lib/mangopay.rb

@@ -41,13 +41,14 @@ module MangoPay
   autoload :BankingAliases, 'mangopay/bankingaliases'
   autoload :BankingAliasesIBAN, 'mangopay/bankingaliases_iban'
   autoload :UboDeclaration, 'mangopay/ubo_declaration'
+  autoload :Ubo, 'mangopay/ubo'
 
   # temporary
   autoload :Temp, 'mangopay/temp'
 
   class Configuration
     attr_accessor :preproduction, :root_url,
-                  :client_id, :client_passphrase,
+                  :client_id, :client_apiKey,
                   :temp_dir, :log_file, :http_timeout
 
     def preproduction

data/lib/mangopay/authorization_token.rb

@@ -19,7 +19,7 @@ module MangoPay
           if token.nil? || token['timestamp'].nil? || token['timestamp'] <= Time.now || token['environment_key'] != env_key
             token = MangoPay.request(:post, "/#{MangoPay.version_code}/oauth/token", {}, {}, {}, Proc.new do |req|
               cfg = MangoPay.configuration
-              req.basic_auth cfg.client_id, cfg.client_passphrase
+              req.basic_auth cfg.client_id, cfg.client_apiKey
               req.body = 'grant_type=client_credentials'
               req.add_field('Content-Type', 'application/x-www-form-urlencoded')
             end)
@@ -32,7 +32,7 @@ module MangoPay
 
         def get_environment_key_for_token
           cfg = MangoPay.configuration
-          key = "#{cfg.root_url}|#{cfg.client_id}|#{cfg.client_passphrase}"
+          key = "#{cfg.root_url}|#{cfg.client_id}|#{cfg.client_apiKey}"
           key = Digest::MD5.hexdigest(key)
           key
         end

data/lib/mangopay/legal_user.rb

@@ -13,14 +13,6 @@ module MangoPay
     end
 
     class << self
-
-      # Create a UBO declaration.
-      # @param +user_id+ ID of the legal user owning the declaration
-      # @param +ubo_declaration+ Object containing UBO declaration data
-      # @return Newly-created UBO declaration entity data
-      def create_ubo_declaration(user_id, ubo_declaration)
-        MangoPay.request(:post, "#{url(user_id)}/ubodeclarations", ubo_declaration)
-      end
     end
   end
 end

data/lib/mangopay/ubo.rb

@@ -0,0 +1,26 @@
+module MangoPay
+  # Provides API methods for the UBO entity.
+  class Ubo < Resource
+    class << self
+      def url(user_id, ubo_declaration_id, id = nil)
+        if id
+          "#{MangoPay.api_path}/users/#{user_id}/kyc/ubodeclarations/#{ubo_declaration_id}/ubos/#{id}"
+        else
+          "#{MangoPay.api_path}/users/#{user_id}/kyc/ubodeclarations/#{ubo_declaration_id}/ubos"
+        end
+      end
+
+      def create(user_id, ubo_declaration_id, params)
+        MangoPay.request(:post, url(user_id, ubo_declaration_id), params)
+      end
+
+      def fetch(user_id, ubo_declaration_id, ubo_id)
+        MangoPay.request(:get, url(user_id, ubo_declaration_id, ubo_id))
+      end
+
+      def update(user_id, ubo_declaration_id, ubo_id, params)
+        MangoPay.request(:put, url(user_id, ubo_declaration_id, ubo_id), params)
+      end
+    end
+  end
+end

data/lib/mangopay/ubo_declaration.rb

@@ -1,19 +1,30 @@
 module MangoPay
-
   # Provides API methods for the UBO declaration entity.
   class UboDeclaration < Resource
-    include HTTPCalls::Fetch
-
     class << self
-
-      def update(id = nil, params = {})
-        declared_ubo_ids = []
-        params['DeclaredUBOs'].each do |ubo|
-          declared_ubo_ids << (ubo.key?('UserId') ? ubo['UserId'] : ubo)
+      def url(user_id, id = nil)
+        if id
+          "#{MangoPay.api_path}/users/#{user_id}/kyc/ubodeclarations/#{id}"
+        else
+          "#{MangoPay.api_path}/users/#{user_id}/kyc/ubodeclarations"
         end
-        params['DeclaredUBOs'] = declared_ubo_ids
-        MangoPay.request(:put, url(id), params)
+      end
+
+      def create(user_id)
+        MangoPay.request(:post, url(user_id))
+      end
+
+      def fetch(user_id, id)
+        MangoPay.request(:get, url(user_id, id))
+      end
+
+      def update(user_id, id, params = {})
+        request_params = {
+            Status: params['Status'],
+            Ubos: params['Ubos']
+        }
+        MangoPay.request(:put, url(user_id, id), request_params)
       end
     end
   end
-end
+end

data/lib/mangopay/version.rb

@@ -1,3 +1,3 @@
 module MangoPay
-  VERSION = '3.0.31'
+  VERSION = '3.0.32'
 end

data/spec/mangopay/client_spec.rb

@@ -7,6 +7,13 @@ describe MangoPay::Client do
     end
   end
 
+  describe 'FETCH' do
+    it "fetches the client headquarter's phone number" do
+      client = MangoPay::Client.fetch
+      expect(client['HeadquartersPhoneNumber']).to_not be_nil
+    end
+  end
+
   describe 'UPDATE' do
     it 'updates the current client details' do
       clnt = MangoPay::Client.fetch
@@ -14,22 +21,25 @@ describe MangoPay::Client do
       after = before == '#aaaaaa' ? '#bbbbbb' : '#aaaaaa' # change the color
       clnt['PrimaryThemeColour'] = after
       clnt['HeadquartersAddress'] = {
-        AddressLine1: 'Rue Dandelion, n. 17',
-        City: 'Lyon',
-        Country: 'FR',
-        PostalCode: '150770'
+          AddressLine1: 'Rue Dandelion, n. 17',
+          City: 'Lyon',
+          Country: 'FR',
+          PostalCode: '150770'
       }
+      phoneNumber = rand(99999999).to_s
+      clnt['HeadquartersPhoneNumber'] = phoneNumber
 
       updated = MangoPay::Client.update(clnt)
       expect(updated['ClientId']).to eq(MangoPay.configuration.client_id)
       expect(updated['PrimaryThemeColour']).to eq(after)
+      expect(updated['HeadquartersPhoneNumber']).to eq(phoneNumber)
     end
   end
 
   describe 'UPLOAD LOGO' do
     it 'accepts Base64 encoded file content' do
       fnm = __FILE__.sub('.rb', '.png')
-      bts = File.open(fnm, 'rb') { |f| f.read }
+      bts = File.open(fnm, 'rb') {|f| f.read}
       b64 = Base64.encode64(bts)
       ret = MangoPay::Client.upload_logo(b64)
       expect(ret).to be_nil
@@ -43,7 +53,7 @@ describe MangoPay::Client do
 
     it 'fails when input string is not base64-encoded' do
       file = 'any file content...'
-      expect { MangoPay::Client.upload_logo(file) }.to raise_error { |err|
+      expect {MangoPay::Client.upload_logo(file)}.to raise_error {|err|
         expect(err).to be_a MangoPay::ResponseError
         expect(err.code).to eq '400'
         expect(err.type).to eq 'param_error'

data/spec/mangopay/configuration_spec.rb

@@ -4,7 +4,7 @@ describe MangoPay::Configuration do
     expect {
       c = MangoPay.configuration
       c.client_id = 'test_asd'
-      c.client_passphrase = '00000'
+      c.client_apiKey = '00000'
       MangoPay::User.fetch()
     }.to raise_error(MangoPay::ResponseError)
   end

data/spec/mangopay/event_spec.rb

@@ -11,21 +11,23 @@ describe MangoPay::Event do
       payin = new_payin_card_direct
       create_new_payout_bankwire(payin)
 
-      # get all # TODO: Uncomment this test once Events are fixed on the server
-      # events = MangoPay::Event.fetch()
-      # expect(events).to be_kind_of(Array)
-      # expect(events.count).to be >= 2
+      # get all #
+      events = MangoPay::Event.fetch
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to be >= 2
 
-      # only one per page # TODO: Uncomment this test once Events are fixed on the server
-      # events = MangoPay::Event.fetch({'per_page' => 1})
-      # expect(events).to be_kind_of(Array)
-      # expect(events.count).to eq 1
+      # only one per page #
+      events = MangoPay::Event.fetch({'per_page' => 1})
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to eq 1
 
       # filter by date
-      events = MangoPay::Event.fetch({'AfterDate' => payin['CreationDate'], 'BeforeDate' => payin['CreationDate']})
+      eventDate = events[0]["Date"]
+      resourceId=events[0]["ResourceId"]
+      events = MangoPay::Event.fetch({'AfterDate' => eventDate - 1, 'BeforeDate' => eventDate + 1})
       expect(events).to be_kind_of(Array)
       expect(events.count).to be >= 1
-      expect(events.count { |e| e['ResourceId'] == payin['Id'] }).to be >= 1
+      expect(events.count {|e| e['ResourceId'] == resourceId}).to be >= 1
     end
   end
 end

data/spec/mangopay/payin_bankwire_external_instruction_spec.rb

@@ -1,7 +1,8 @@
 describe MangoPay::PayIn::BankWire::ExternalInstruction, type: :feature do
   include_context 'wallets'
   include_context 'payins'
-  
+
+
   def check_type_and_status(payin)
     expect(payin['Type']).to eq('PAYIN')
     expect(payin['Nature']).to eq('REGULAR')
@@ -11,18 +12,20 @@ describe MangoPay::PayIn::BankWire::ExternalInstruction, type: :feature do
 
   describe 'FETCH' do
     it 'fetches a payin' do
+      backupConfig = MangoPay.configuration.clone
       MangoPay.configure do |c|
         c.preproduction = true
         c.client_id = 'sdk-unit-tests'   
-        c.root_url = 'https://api-test.mangopay.com'
-        c.client_passphrase = '9RMGpwVUwFLK0SurxObJ2yaadDcO0zeKFKxWmthjB93SQjFzy0'
+        c.root_url = 'https://api.sandbox.mangopay.com'
+        c.client_apiKey = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
         c.http_timeout = 10000
       end
 
-      id = "2826947"
+      id = "66142029"
       payIn = MangoPay::PayIn.fetch(id)
       expect(payIn['Id']).to eq(id)
       check_type_and_status(payIn)
+      MangoPay.configuration = backupConfig
     end
   end
 

data/spec/mangopay/payin_paypal_web_spec.rb

@@ -13,7 +13,7 @@ describe MangoPay::PayIn::PayPal::Web, type: :feature do
     expect(payin['ResultMessage']).to be_nil
     expect(payin['ExecutionDate']).to be_nil
   end
-  
+
   describe 'CREATE' do
     it 'creates a paypal web payin' do
       created = new_payin_paypal_web
@@ -22,6 +22,18 @@ describe MangoPay::PayIn::PayPal::Web, type: :feature do
     end
   end
 
+  describe "FETCH" do
+    it 'FETCHES a payIn with PayPal account email' do
+      payin_id = "54088959"
+      buyer_account_email = "paypal-buyer-user@mangopay.com"
+      payin = MangoPay::PayIn.fetch(id = payin_id)
+
+      expect(payin).not_to be_nil
+      expect(payin["PaypalBuyerAccountEmail"]).not_to be_nil
+      expect(payin["PaypalBuyerAccountEmail"]).to eq(buyer_account_email)
+    end
+  end
+
   describe 'FETCH' do
     it 'fetches a payin' do
       created = new_payin_paypal_web

data/spec/mangopay/refund_spec.rb

@@ -19,16 +19,16 @@ describe MangoPay::Refund do
     end
   end
 
-  describe 'FETCH for Repudiation' do
-    it "fetches a repudiation's refunds" do
-      disputes = MangoPay::Dispute.fetch
-      dispute = disputes.find do |dispute|
-        dispute['DisputeType'] == 'NOT_CONTESTABLE'\
-           && !dispute['InitialTransactionId'].nil?
-      end
-      repudiation_id = MangoPay::Dispute.transactions(dispute['Id'])[0]['Id']
-      refunds = MangoPay::Refund.of_repudiation(repudiation_id)
-      expect(refunds).to be_an(Array)
-    end
-  end
+  #describe 'FETCH for Repudiation' do
+  #  it "fetches a repudiation's refunds" do
+  #    disputes = MangoPay::Dispute.fetch
+  #   dispute = disputes.find do |dispute|
+  #      dispute['DisputeType'] == 'NOT_CONTESTABLE'\
+  #         && !dispute['InitialTransactionId'].nil?
+  #   end
+  #    repudiation_id = MangoPay::Dispute.transactions(dispute['Id'])[0]['Id']
+  #    refunds = MangoPay::Refund.of_repudiation(repudiation_id)
+  #    expect(refunds).to be_an(Array)
+  #  end
+  # end
 end

data/spec/mangopay/shared_resources.rb

@@ -1,15 +1,15 @@
 ###############################################
 shared_context 'users' do
-###############################################
+  ###############################################
 
   let(:new_natural_user) { create_new_natural_user }
   def define_new_natural_user
     {
-      Tag: 'Test natural user',
-      Email: 'my@email.com',
-      FirstName: 'John',
-      LastName: 'Doe',
-      Address: {
+        Tag: 'Test natural user',
+        Email: 'my@email.com',
+        FirstName: 'John',
+        LastName: 'Doe',
+        Address: {
         AddressLine1: 'Le Palais Royal',
         AddressLine2: '8 Rue de Montpensier',
         City: 'Paris',
@@ -17,34 +17,35 @@ shared_context 'users' do
         PostalCode: '75001',
         Country: 'FR'
       },
-      Birthday: 1300186358,
-      Birthplace: 'Paris',
-      Nationality: 'FR',
-      CountryOfResidence: 'FR',
-      Occupation: 'Worker',
-      IncomeRange: 1
+        Birthday: 1_300_186_358,
+        Birthplace: 'Paris',
+        Nationality: 'FR',
+        CountryOfResidence: 'FR',
+        Occupation: 'Worker',
+        IncomeRange: 1
     }
   end
+
   def create_new_natural_user
     MangoPay::NaturalUser.create(define_new_natural_user)
   end
 
-  let(:new_legal_user) {
-    MangoPay::LegalUser.create({
-      Name: 'Super',
-      Email: 'super@email.com',
-      LegalPersonType: 'BUSINESS',
-      HeadquartersAddress: {
-        AddressLine1: '6 Parvis Notre-Dame',
-        AddressLine2: 'Pl. Jean-Paul II',
-        City: 'Paris',
-        Region: '',
-        PostalCode: '75004',
-        Country: 'FR'
+  let(:new_legal_user) do
+    MangoPay::LegalUser.create(
+        Name: 'Super',
+        Email: 'super@email.com',
+        LegalPersonType: 'BUSINESS',
+        HeadquartersAddress: {
+            AddressLine1: '6 Parvis Notre-Dame',
+            AddressLine2: 'Pl. Jean-Paul II',
+            City: 'Paris',
+            Region: 'FR',
+            PostalCode: '75004',
+            Country: 'FR'
       },
-      LegalRepresentativeFirstName: 'John',
-      LegalRepresentativeLastName: 'Doe',
-      LegalRepresentativeAdress: {
+        LegalRepresentativeFirstName: 'John',
+        LegalRepresentativeLastName: 'Doe',
+        LegalRepresentativeAdress: {
         AddressLine1: '38 Rue de Montpensier',
         AddressLine2: '',
         City: 'Paris',
@@ -52,31 +53,31 @@ shared_context 'users' do
         PostalCode: '75001',
         Country: 'FR'
       },
-      LegalRepresentativeEmail: 'john@doe.com',
-      LegalRepresentativeBirthday: 1300186358,
-      LegalRepresentativeNationality: 'FR',
-      LegalRepresentativeCountryOfResidence: 'FR',
-      Statute: '',
-      ProofOfRegistration: '',
-      ShareholderDeclaration: ''
-    })
-  }
+        LegalRepresentativeEmail: 'john@doe.com',
+        LegalRepresentativeBirthday: 1_300_186_358,
+        LegalRepresentativeNationality: 'FR',
+        LegalRepresentativeCountryOfResidence: 'FR',
+        Statute: '',
+        ProofOfRegistration: '',
+        ShareholderDeclaration: ''
+    )
+  end
 end
 
 ###############################################
 shared_context 'wallets' do
-###############################################
+  ###############################################
   include_context 'users'
 
   let(:new_wallet) { create_new_wallet(new_natural_user) }
   let(:new_wallet_legal) { create_new_wallet(new_legal_user) }
   def create_new_wallet(user)
-    MangoPay::Wallet.create({
+    MangoPay::Wallet.create(
       Owners: [user['Id']],
       Description: 'A test wallet',
       Currency: 'EUR',
       Tag: 'Test wallet'
-    })
+    )
   end
 
   def wallets_check_amounts(wlt1, amnt1, wlt2 = nil, amnt2 = nil)
@@ -85,69 +86,92 @@ shared_context 'wallets' do
   end
 
   def wallets_reload_and_check_amounts(wlt1, amnt1, wlt2 = nil, amnt2 = nil)
-    wlt1 = MangoPay::Wallet::fetch(wlt1['Id'])
-    wlt2 = MangoPay::Wallet::fetch(wlt2['Id']) if wlt2
+    wlt1 = MangoPay::Wallet.fetch(wlt1['Id'])
+    wlt2 = MangoPay::Wallet.fetch(wlt2['Id']) if wlt2
     wallets_check_amounts(wlt1, amnt1, wlt2, amnt2)
   end
 end
 
+shared_context 'ubo' do
+  def new_ubo(user, ubo_declaration)
+    ubo = {
+        FirstName: 'John',
+        LastName: 'Doe',
+        Address: {
+            AddressLine1: '6 Parvis Notre-Dame',
+            AddressLine2: 'Pl. Jean-Paul II',
+            City: 'Paris',
+            Region: '',
+            PostalCode: '75004',
+            Country: 'FR'
+        },
+        Nationality: 'FR',
+        Birthday: 1_300_186_358,
+        Birthplace: {
+            City: 'Paris',
+            Country: 'FR'
+        }
+    }
+    MangoPay::Ubo.create(user['Id'], ubo_declaration['Id'], ubo)
+  end
+end
+
 ###############################################
 shared_context 'bank_accounts' do
-###############################################
+  ###############################################
   include_context 'users'
 
-  let(:new_bank_account) {
-    MangoPay::BankAccount.create(new_natural_user['Id'], {
-      Type: 'IBAN',
-      OwnerName: 'John',
-      OwnerAddress: {
-        AddressLine1: 'Le Palais Royal',
-        AddressLine2: '8 Rue de Montpensier',
-        City: 'Paris',
-        Region: '',
-        PostalCode: '75001',
-        Country: 'FR'
-      },
-      IBAN: 'FR7618829754160173622224154',
-      BIC: 'CMBRFR2BCME',
-      Tag: 'Test bank account'
-    })
-  }
+  let(:new_bank_account) do
+    MangoPay::BankAccount.create(new_natural_user['Id'],
+                                 Type: 'IBAN',
+                                 OwnerName: 'John',
+                                 OwnerAddress: {
+                                     AddressLine1: 'Le Palais Royal',
+                                     AddressLine2: '8 Rue de Montpensier',
+                                     City: 'Paris',
+                                     Region: '',
+                                     PostalCode: '75001',
+                                     Country: 'FR'
+                                 },
+                                 IBAN: 'FR7618829754160173622224154',
+                                 BIC: 'CMBRFR2BCME',
+                                 Tag: 'Test bank account')
+  end
 end
 
 ###############################################
 shared_context 'mandates' do
-###############################################
+  ###############################################
   include_context 'bank_accounts'
 
-  let(:new_mandate) { create_new_mandate() }
-  def create_new_mandate()
-    MangoPay::Mandate.create({
+  let(:new_mandate) {create_new_mandate}
+
+  def create_new_mandate
+    MangoPay::Mandate.create(
       BankAccountId: new_bank_account['Id'],
       Culture: 'FR',
       ReturnURL: MangoPay.configuration.root_url,
       Tag: 'Test mandate'
-    })
+    )
   end
 end
 
 ###############################################
 shared_context 'kyc_documents' do
-###############################################
+  ###############################################
   include_context 'users'
 
   let(:new_document) { create_new_document(new_natural_user) }
   def create_new_document(user)
-    MangoPay::KycDocument.create(user['Id'], {
-      Type: 'IDENTITY_PROOF',
-      Tag: 'Test document'
-    })
+    MangoPay::KycDocument.create(user['Id'],
+                                 Type: 'IDENTITY_PROOF',
+                                 Tag: 'Test document')
   end
 end
 
 ###############################################
 shared_context 'payins' do
-###############################################
+  ###############################################
   include_context 'users'
   include_context 'wallets'
   include_context 'mandates'
@@ -156,8 +180,8 @@ shared_context 'payins' do
   # directdebit/web
   ###############################################
 
-  let(:new_payin_directdebit_web) {
-    MangoPay::PayIn::DirectDebit::Web.create({
+  let(:new_payin_directdebit_web) do
+    MangoPay::PayIn::DirectDebit::Web.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: new_wallet['Owners'][0],
       CreditedWalletId: new_wallet['Id'],
@@ -167,15 +191,15 @@ shared_context 'payins' do
       ReturnURL: MangoPay.configuration.root_url,
       Culture: 'FR',
       Tag: 'Test PayIn/DirectDebit/Web'
-    })
-  }
+    )
+  end
 
   ###############################################
   # paypal/web
   ###############################################
 
-  let(:new_payin_paypal_web) {
-    MangoPay::PayIn::PayPal::Web.create({
+  let(:new_payin_paypal_web) do
+    MangoPay::PayIn::PayPal::Web.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: new_wallet['Owners'][0],
       CreditedWalletId: new_wallet['Id'],
@@ -183,15 +207,15 @@ shared_context 'payins' do
       Fees: { Currency: 'EUR', Amount: 0 },
       ReturnURL: MangoPay.configuration.root_url,
       Tag: 'Test PayIn/PayPal/Web'
-    })
-  }
-  
-    ###############################################
+    )
+  end
+
+  ###############################################
   # directdebit/direct
   ###############################################
 
-  let(:new_payin_directdebit_direct) {
-    MangoPay::PayIn::DirectDebit::Direct.create({
+  let(:new_payin_directdebit_direct) do
+    MangoPay::PayIn::DirectDebit::Direct.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: new_wallet['Owners'][0],
       CreditedWalletId: new_wallet['Id'],
@@ -200,15 +224,15 @@ shared_context 'payins' do
       MandateId: new_mandate['Id'],
       ReturnURL: MangoPay.configuration.root_url,
       Tag: 'Test PayIn/DirectDebit/Direct'
-    })
-  }
-  
+    )
+  end
+
   ###############################################
   # card/web
   ###############################################
 
-  let(:new_payin_card_web) {
-    MangoPay::PayIn::Card::Web.create({
+  let(:new_payin_card_web) do
+    MangoPay::PayIn::Card::Web.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: new_wallet['Owners'][0],
       CreditedWalletId: new_wallet['Id'],
@@ -218,22 +242,22 @@ shared_context 'payins' do
       ReturnURL: MangoPay.configuration.root_url,
       Culture: 'FR',
       Tag: 'Test PayIn/Card/Web'
-    })
-  }
+    )
+  end
 
   ###############################################
   # card/direct
   ###############################################
 
-  let(:new_card_registration) {
-    MangoPay::CardRegistration.create({
+  let(:new_card_registration) do
+    MangoPay::CardRegistration.create(
       UserId: new_natural_user['Id'],
       Currency: 'EUR',
       Tag: 'Test Card Registration'
-    })
-  }
+    )
+  end
 
-  let(:new_card_registration_completed) {
+  let(:new_card_registration_completed) do
     # 1st step: create
     cardreg = new_card_registration
 
@@ -242,22 +266,23 @@ shared_context 'payins' do
       data: cardreg['PreregistrationData'],
       accessKeyRef: cardreg['AccessKey'],
       cardNumber: 4970100000000154,
-      cardExpirationDate: 1218,
+      cardExpirationDate: 1226,
       cardCvx: 123}
+
     res = Net::HTTP.post_form(URI(cardreg['CardRegistrationURL']), data)
-    raise Exception, [res, res.body] unless (res.is_a?(Net::HTTPOK) && res.body.start_with?('data='))
+    raise Exception, [res, res.body] unless res.is_a?(Net::HTTPOK) && res.body.start_with?('data=')
+
     cardreg['RegistrationData'] = res.body
 
     # 3rd step: update (fills-in CardId) and return it
-    MangoPay::CardRegistration.update(cardreg['Id'], {
-      RegistrationData: cardreg['RegistrationData']
-    })
-  }
+    MangoPay::CardRegistration.update(cardreg['Id'],
+                                      RegistrationData: cardreg['RegistrationData'])
+  end
 
   let(:new_payin_card_direct) { create_new_payin_card_direct(new_wallet) }
   def create_new_payin_card_direct(to_wallet, amnt = 1000)
     cardreg = new_card_registration_completed
-    MangoPay::PayIn::Card::Direct.create({
+    MangoPay::PayIn::Card::Direct.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: to_wallet['Owners'][0],
       CreditedWalletId: to_wallet['Id'],
@@ -267,7 +292,7 @@ shared_context 'payins' do
       CardId: cardreg['CardId'],
       SecureModeReturnURL: 'http://test.com',
       Tag: 'Test PayIn/Card/Direct'
-    })
+    )
   end
 
   ###############################################
@@ -276,20 +301,20 @@ shared_context 'payins' do
 
   let(:new_card_preauthorization) { create_new_card_preauthorization(new_card_registration_completed) }
   def create_new_card_preauthorization(cardreg, amnt = 1000)
-    MangoPay::PreAuthorization.create({
+    MangoPay::PreAuthorization.create(
       AuthorId: new_natural_user['Id'],
       DebitedFunds: { Currency: 'EUR', Amount: amnt },
       CardId: cardreg['CardId'],
       SecureMode: 'DEFAULT',
       SecureModeReturnURL: 'http://test.com',
       Tag: 'Test Card PreAuthorization'
-    })
+    )
   end
 
   let(:new_payin_preauthorized_direct) { create_new_payin_preauthorized_direct(new_wallet) }
   def create_new_payin_preauthorized_direct(to_wallet, amnt = 1000)
     preauth = new_card_preauthorization
-    MangoPay::PayIn::PreAuthorized::Direct.create({
+    MangoPay::PayIn::PreAuthorized::Direct.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: to_wallet['Owners'][0],
       CreditedWalletId: to_wallet['Id'],
@@ -297,7 +322,7 @@ shared_context 'payins' do
       Fees: { Currency: 'EUR', Amount: 0 },
       PreauthorizationId: preauth['Id'],
       Tag: 'Test PayIn/PreAuthorized/Direct'
-    })
+    )
   end
 
   ###############################################
@@ -306,26 +331,25 @@ shared_context 'payins' do
 
   let(:new_payin_bankwire_direct) { create_new_payin_bankwire_direct(new_wallet) }
   def create_new_payin_bankwire_direct(to_wallet, amnt = 1000)
-    MangoPay::PayIn::BankWire::Direct.create({
+    MangoPay::PayIn::BankWire::Direct.create(
       AuthorId: new_natural_user['Id'],
       CreditedUserId: to_wallet['Owners'][0],
       CreditedWalletId: to_wallet['Id'],
       DeclaredDebitedFunds: { Currency: 'EUR', Amount: amnt },
       DeclaredFees: { Currency: 'EUR', Amount: 0 },
       Tag: 'Test PayIn/BankWire/Direct'
-    })
+    )
   end
-
 end
 
 ###############################################
 shared_context 'payouts' do
-###############################################
+  ###############################################
   include_context 'bank_accounts'
 
   let(:new_payout_bankwire) { create_new_payout_bankwire(new_payin_card_direct) }
   def create_new_payout_bankwire(payin, amnt = 500)
-    MangoPay::PayOut::BankWire.create({
+    MangoPay::PayOut::BankWire.create(
       AuthorId: payin['CreditedUserId'],
       DebitedWalletId: payin['CreditedWalletId'],
       DebitedFunds: { Currency: 'EUR', Amount: amnt },
@@ -333,65 +357,65 @@ shared_context 'payouts' do
       BankAccountId: new_bank_account['Id'],
       Communication: 'This is a test',
       Tag: 'Test PayOut/Bank/Wire'
-    })
+    )
   end
 end
 
 ###############################################
 shared_context 'transfers' do
-###############################################
+  ###############################################
   include_context 'users'
   include_context 'wallets'
   include_context 'payins'
 
-  let(:new_transfer) {
+  let(:new_transfer) do
     wlt1 = new_wallet
     wlt2 = new_wallet_legal
     create_new_payin_card_direct(wlt1, 1000) # feed wlt1 with money
     create_new_transfer(wlt1, wlt2, 500) # transfer wlt1 => wlt2
-  }
+  end
   def create_new_transfer(from_wallet, to_wallet, amnt = 500)
-    MangoPay::Transfer.create({
-      AuthorId: from_wallet['Owners'][0],
-      DebitedWalletId: from_wallet['Id'],
-      CreditedUserId: to_wallet['Owners'][0],
-      CreditedWalletId: to_wallet['Id'],
-      DebitedFunds: { Currency: 'EUR', Amount: amnt},
-      Fees: { Currency: 'EUR', Amount: 0},
-      Tag: 'Test transfer'
-    })
+    MangoPay::Transfer.create(
+        AuthorId: from_wallet['Owners'][0],
+        DebitedWalletId: from_wallet['Id'],
+        CreditedUserId: to_wallet['Owners'][0],
+        CreditedWalletId: to_wallet['Id'],
+        DebitedFunds: {Currency: 'EUR', Amount: amnt},
+        Fees: {Currency: 'EUR', Amount: 0},
+        Tag: 'Test transfer'
+    )
   end
 end
 
 ###############################################
 shared_context 'hooks' do
-###############################################
-  let(:new_hook) {
-    hooks = MangoPay::Hook.fetch({'page' => 1, 'per_page' => 1})
-    if hooks.length == 0
-      MangoPay::Hook.create({
+  ###############################################
+  let(:new_hook) do
+    hooks = MangoPay::Hook.fetch('page' => 1, 'per_page' => 1)
+    if hooks.empty?
+      MangoPay::Hook.create(
         EventType: 'PAYIN_NORMAL_CREATED',
         Url: 'http://test.com',
         Tag: 'Test hook'
-      })
+      )
     else
       hooks[0]
     end
-  }
+  end
 end
 
 ###############################################
 shared_context 'bankigaliases' do
-###############################################
+  ###############################################
   include_context 'users'
   include_context 'wallets'
 
-  let(:new_banking_alias) {
+  let(:new_banking_alias) do
     MangoPay::BankingAliasesIBAN.create({
-                                        CreditedUserId: new_natural_user['Id'],
-                                        WalletId: new_wallet['Id'],
-                                        OwnerName: new_natural_user['FirstName'],
-                                        Country: 'LU'
-                                    }, new_wallet['Id'])
-  }
+                                            CreditedUserId: new_natural_user['Id'],
+                                            WalletId: new_wallet['Id'],
+                                            OwnerName: new_natural_user['FirstName'],
+                                            Country: 'LU'
+                                        }, new_wallet['Id'])
+  end
 end

data/spec/mangopay/ubo_declaration_spec.rb

@@ -1,17 +1,14 @@
 describe MangoPay::UboDeclaration do
   include_context 'users'
+  include_context 'ubo'
 
   describe 'FETCH' do
     it 'can fetch a UBO declaration' do
       legal_user = new_legal_user
-      natural_user = define_new_natural_user
-      natural_user['Capacity'] = 'DECLARATIVE'
-      natural_user = MangoPay::NaturalUser.create(natural_user)
-      ubo_declaration = {
-        DeclaredUBOs: [natural_user['Id']]
-      }
-      ubo_declaration = MangoPay::LegalUser.create_ubo_declaration(legal_user['Id'], ubo_declaration)
-      ubo_declaration = MangoPay::UboDeclaration.fetch(ubo_declaration['Id'])
+
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+
+      ubo_declaration = MangoPay::UboDeclaration.fetch(legal_user['Id'], ubo_declaration['Id'])
 
       expect(ubo_declaration).not_to be_nil
     end
@@ -19,19 +16,17 @@ describe MangoPay::UboDeclaration do
     describe 'UPDATE' do
       it 'can update a UBO declaration' do
         legal_user = new_legal_user
-        natural_user = define_new_natural_user
-        natural_user['Capacity'] = 'DECLARATIVE'
-        natural_user = MangoPay::NaturalUser.create(natural_user)
-        ubo_declaration = {
-          DeclaredUBOs: [natural_user['Id']]
-        }
-        ubo_declaration = MangoPay::LegalUser.create_ubo_declaration(legal_user['Id'], ubo_declaration)
+        ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
         ubo_declaration['Status'] = 'VALIDATION_ASKED'
-        ubo_declaration = MangoPay::UboDeclaration.update(ubo_declaration['Id'], ubo_declaration)
+
+        ubo = new_ubo(legal_user, ubo_declaration)
+
+        ubo_declaration['Ubos'] = [ubo]
+        ubo_declaration = MangoPay::UboDeclaration.update(legal_user['Id'], ubo_declaration['Id'], ubo_declaration)
 
         expect(ubo_declaration).not_to be_nil
         expect(ubo_declaration['Status']).to eq 'VALIDATION_ASKED'
       end
     end
   end
-end
+end

data/spec/mangopay/ubo_spec.rb

@@ -0,0 +1,39 @@
+describe MangoPay::Ubo do
+  include_context 'users'
+  include_context 'ubo'
+
+  describe 'FETCH' do
+    it 'can fetch a Ubo' do
+      legal_user = new_legal_user
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+      ubo = new_ubo(legal_user, ubo_declaration)
+      result = MangoPay::Ubo.fetch(legal_user['Id'], ubo_declaration['Id'], ubo['Id'])
+      expect(result).not_to be_nil
+      expect(result['Id']).equal? ubo['Id']
+    end
+  end
+
+  describe 'CREATE' do
+    it 'can create a new Ubo' do
+      legal_user = new_legal_user
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+      result = new_ubo(legal_user, ubo_declaration)
+      expect(result).not_to be_nil
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'can update a Ubo' do
+      legal_user = new_legal_user
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+      ubo = new_ubo(legal_user, ubo_declaration)
+      ubo['FirstName'] = 'Santa'
+      ubo['LastName'] = 'Clause'
+
+      result = MangoPay::Ubo.update(legal_user['Id'], ubo_declaration['Id'], ubo['Id'], ubo)
+      expect(result).not_to be_nil
+      expect(result['FirstName']).equal? ubo['FirstName']
+      expect(result['LastName']).equal? ubo['LastName']
+    end
+  end
+end

data/spec/mangopay/user_spec.rb

@@ -173,23 +173,20 @@ describe MangoPay::User do
     end
   end
 
-  describe 'CREATE UBO DECLARATION' do
-    it 'creates a UBO declaration' do
-      legal_user = new_legal_user
-      natural_user = define_new_natural_user
-      natural_user['Capacity'] = 'DECLARATIVE'
-      natural_user = MangoPay::NaturalUser.create(natural_user)
-      ubo_declaration = {
-        DeclaredUBOs: [natural_user['Id']]
-      }
-      ubo_declaration = MangoPay::LegalUser.create_ubo_declaration(legal_user['Id'], ubo_declaration)
-
-      expect(ubo_declaration).not_to be_nil
-      expect(ubo_declaration['Status']).to eq 'CREATED'
-      expect(ubo_declaration['UserId']).to eq legal_user['Id']
-      expect(ubo_declaration['DeclaredUBOs'][0]['UserId']).to eq natural_user['Id']
-    end
-  end
+  #describe 'CREATE UBO DECLARATION' do
+  #  it 'creates a UBO declaration' do
+  #    legal_user = new_legal_user
+  #    natural_user = define_new_natural_user
+  #    natural_user['Capacity'] = 'DECLARATIVE'
+  #    natural_user = MangoPay::NaturalUser.create(natural_user)
+  #    ubo_declaration = MangoPay::LegalUser.create_ubo_declaration(legal_user['Id'])
+
+  #   expect(ubo_declaration).not_to be_nil
+  #    expect(ubo_declaration['Status']).to eq 'CREATED'
+  #    expect(ubo_declaration['UserId']).to eq legal_user['Id']
+  #    expect(ubo_declaration['DeclaredUBOs'][0]['UserId']).to eq natural_user['Id']
+  #  end
+  #end
 
   describe 'FETCH Pre-Authorizations' do
     it "fetches list of user's pre-authorizations belonging" do

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ def reset_mangopay_configuration
 
     # sandbox environment:
     c.root_url = 'https://api.sandbox.mangopay.com'
-    c.client_passphrase = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+    c.client_apiKey = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
 
     c.temp_dir = File.expand_path('../tmp', __FILE__)
     require 'fileutils'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mangopay
 version: !ruby/object:Gem::Version
-  version: 3.0.31
+  version: 3.0.32
 platform: ruby
 authors:
 - Geoffroy Lorieux
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2019-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -99,6 +99,7 @@ files:
 - lib/mangopay/resource.rb
 - lib/mangopay/transaction.rb
 - lib/mangopay/transfer.rb
+- lib/mangopay/ubo.rb
 - lib/mangopay/ubo_declaration.rb
 - lib/mangopay/user.rb
 - lib/mangopay/version.rb
@@ -138,6 +139,7 @@ files:
 - spec/mangopay/transaction_spec.rb
 - spec/mangopay/transfer_spec.rb
 - spec/mangopay/ubo_declaration_spec.rb
+- spec/mangopay/ubo_spec.rb
 - spec/mangopay/user_spec.rb
 - spec/mangopay/wallet_spec.rb
 - spec/spec_helper.rb
@@ -161,8 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for the version 2 of the MANGOPAY API
@@ -201,6 +202,7 @@ test_files:
 - spec/mangopay/transaction_spec.rb
 - spec/mangopay/transfer_spec.rb
 - spec/mangopay/ubo_declaration_spec.rb
+- spec/mangopay/ubo_spec.rb
 - spec/mangopay/user_spec.rb
 - spec/mangopay/wallet_spec.rb
 - spec/spec_helper.rb