mangopay4-nodejs-sdk 1.64.0

package/lib/models/UserNaturalPut.js

@@ -0,0 +1,49 @@
+var _ = require('underscore');
+
+var PersonType = require('./PersonType');
+
+var User = require('./User');
+var Address = require('./Address');
+
+var UserNaturalPut = User.extend({
+    defaults: _.extend({}, User.prototype.defaults, {
+        FirstName: null,
+        LastName: null,
+        Address: null,
+        Birthday: null,
+        Nationality: null,
+        CountryOfResidence: null,
+        Occupation: null,
+        IncomeRange: null,
+        Capacity: null
+    }),
+
+    initialize: function() {
+        User.prototype.initialize.apply(this, arguments);
+        this.setPersonType(PersonType.Natural);
+    },
+
+    /**
+     * Get object with key as object type and value the object class
+     * @return {Object} Mapping of sub-objects
+     */
+    getSubObjects: function() {
+        var subObjects = User.prototype.getSubObjects();
+
+        return _.extend({}, subObjects, {
+            Address: Address
+        });
+    },
+
+    /**
+     * Get array with read-only properties
+     * @return {Array}
+     */
+    getReadOnlyProperties: function() {
+        var properties = User.prototype.getReadOnlyProperties();
+        properties.push('PersonType');
+        return properties;
+    }
+});
+
+module.exports = UserNaturalPut;

package/lib/models/UserNaturalSca.js

@@ -0,0 +1,56 @@
+var _ = require('underscore');
+
+var PersonType = require('./PersonType');
+
+var User = require('./User');
+var Address = require('./Address');
+var PendingUserAction = require('./PendingUserAction');
+
+var UserNaturalSca = User.extend({
+    defaults: _.extend({}, User.prototype.defaults, {
+        FirstName: null,
+        LastName: null,
+        Address: null,
+        Birthday: null,
+        Nationality: null,
+        CountryOfResidence: null,
+        Occupation: null,
+        IncomeRange: null,
+        ProofOfIdentity: null,
+        ProofOfAddress: null,
+        PhoneNumber: null,
+        PhoneNumberCountry: null,
+        PendingUserAction: null,
+        ScaContext: null
+    }),
+
+    initialize: function() {
+        User.prototype.initialize.apply(this, arguments);
+        this.setPersonType(PersonType.Natural);
+    },
+
+    /**
+     * Get object with key as object type and value the object class
+     * @return {Object} Mapping of sub-objects
+     */
+    getSubObjects: function() {
+        var subObjects = User.prototype.getSubObjects();
+
+        return _.extend({}, subObjects, {
+            Address: Address,
+            PendingUserAction: PendingUserAction
+        });
+    },
+
+    /**
+     * Get array with read-only properties
+     * @return {Array}
+     */
+    getReadOnlyProperties: function() {
+        var properties = User.prototype.getReadOnlyProperties();
+        properties.push('PersonType', 'ProofOfIdentity', 'ProofOfAddress', 'PendingUserAction');
+        return properties;
+    }
+});
+
+module.exports = UserNaturalSca;

package/lib/models/VirtualAccount.js

@@ -0,0 +1,22 @@
+var EntityBase = require('./EntityBase');
+
+var VirtualAccount = EntityBase.extend({
+
+    defaults: {
+        WalletId: null,
+        CreditedUserId: null,
+        VirtualAccountPurpose: null,
+        Country: null,
+        Status: null,
+        Active: null,
+        AccountOwner: null,
+        LocalAccountsDetails: null,
+        InternationalAccountDetails: null,
+        Capabilities: null,
+        ResultCode: null,
+        ResultMessage: null
+    }
+
+});
+
+module.exports = VirtualAccount;

package/lib/models/Wallet.js

@@ -0,0 +1,32 @@
+var EntityBase = require('./EntityBase');
+var Money = require('./Money');
+
+var Wallet = EntityBase.extend({
+    defaults: {
+        /**
+         * Array with owners identities
+         */
+        Owners: null,
+        Description: null,
+        Balance: null,
+        Currency: null
+    },
+
+    getSubObjects: function() {
+        return {
+            'Balance': Money
+        }
+    },
+
+    /**
+     * Get array with read-only properties
+     * @return {Array} List of string properties
+     */
+    getReadOnlyProperties: function() {
+        var properties = EntityBase.prototype.getReadOnlyProperties();
+        properties.push('Balance');
+        return properties;
+    }
+});
+
+module.exports = Wallet;

package/lib/models/index.js

@@ -0,0 +1,102 @@
+module.exports = {
+    Address: require('./Address'),
+    BankAccount: require('./BankAccount'),
+    BankAccountDetails: require('./BankAccountDetails'),
+    BankAccountDetailsCA: require('./BankAccountDetailsCA'),
+    BankAccountDetailsGB: require('./BankAccountDetailsGB'),
+    BankAccountDetailsIBAN: require('./BankAccountDetailsIBAN'),
+    BankAccountDetailsOTHER: require('./BankAccountDetailsOTHER'),
+    BankAccountDetailsUS: require('./BankAccountDetailsUS'),
+    BankAccountType: require('./BankAccountType'),
+    BankingAlias: require('./BankingAlias'),
+    BankingAliasIBAN: require('./BankingAliasIBAN'),
+    Billing: require('./Billing'),
+    Birthplace: require('./Birthplace'),
+    BrowserInfo: require('./BrowserInfo'),
+    Card: require('./Card'),
+    CardPreAuthorization: require('./CardPreAuthorization'),
+    CardRegistration: require('./CardRegistration'),
+    Client: require('./Client'),
+    ClientWallet: require('./ClientWallet'),
+    DebitedBankAccount: require('./DebitedBankAccount'),
+    DeclaredUbo: require('./DeclaredUbo'),
+    DeclaredUboStatus: require('./DeclaredUboStatus'),
+    Dispute: require('./Dispute'),
+    DisputeDocument: require('./DisputeDocument'),
+    DisputeDocumentPage: require('./DisputeDocumentPage'),
+    DisputeReason: require('./DisputeReason'),
+    Document: require('./Document'),
+    DocumentPageConsult: require('./DocumentPageConsult'),
+    EMoney: require('./EMoney'),
+    EntityBase: require('./EntityBase'),
+    Hook: require('./Hook'),
+    IdempotencyResponse: require('./IdempotencyResponse'),
+    KycDocument: require('./KycDocument'),
+    KycDocumentStatus: require('./KycDocumentStatus'),
+    KycDocumentType: require('./KycDocumentType'),
+    KycPage: require('./KycPage'),
+    LegalPersonType: require('./LegalPersonType'),
+    Mandate: require('./Mandate'),
+    MandateStatus: require('./MandateStatus'),
+    Money: require('./Money'),
+    PayIn: require('./PayIn'),
+    PayInExecutionDetails: require('./PayInExecutionDetails'),
+    PayInExecutionDetailsBankingAlias: require('./PayInExecutionDetailsBankingAlias'),
+    PayInExecutionDetailsDirect: require('./PayInExecutionDetailsDirect'),
+    PayInExecutionDetailsWeb: require('./PayInExecutionDetailsWeb'),
+    PayInExecutionType: require('./PayInExecutionType'),
+    PayInPaymentDetails: require('./PayInPaymentDetails'),
+    PayInPaymentDetailsApplePay: require('./PayInPaymentDetailsApplePay'),
+    PayInPaymentDetailsBankWire: require('./PayInPaymentDetailsBankWire'),
+    PayInPaymentDetailsBankingAlias: require('./PayInPaymentDetailsBankingAlias'),
+    PayInPaymentDetailsCard: require('./PayInPaymentDetailsCard'),
+    PayInPaymentDetailsCardDirect: require('./PayInPaymentDetailsCardDirect'),
+    PayInPaymentDetailsCardWeb: require('./PayInPaymentDetailsCardWeb'),
+    PayInPaymentDetailsDirectDebitDirect: require('./PayInPaymentDetailsDirectDebitDirect'),
+    PayInPaymentDetailsDirectDebitWeb: require('./PayInPaymentDetailsDirectDebitWeb'),
+    PayInPaymentDetailsGooglePay: require('./PayInPaymentDetailsGooglePay'),
+    PayInPaymentDetailsPayPal: require('./PayInPaymentDetailsPayPal'),
+    PayInPaymentDetailsPreAuthorized: require('./PayInPaymentDetailsPreAuthorized'),
+    PayInPaymentDetailsBancontact: require('./PayInPaymentDetailsBancontact'),
+    PayInPaymentDetailsBizum: require('./PayInPaymentDetailsBizum'),
+    PayInPaymentType: require('./PayInPaymentType'),
+    PayInRecurringRegistration: require('./PayInRecurringRegistration'),
+    PayInTemplateURLOptions: require('./PayInTemplateURLOptions'),
+    PayOut: require('./PayOut'),
+    PayOutPaymentDetails: require('./PayOutPaymentDetails'),
+    PayOutPaymentDetailsBankWire: require('./PayOutPaymentDetailsBankWire'),
+    PayOutPaymentType: require('./PayOutPaymentType'),
+    PaymentData: require('./PaymentData'),
+    PersonType: require('./PersonType'),
+    PlatformCategorization: require('./PlatformCategorization'),
+    PlatformType: require('./PlatformType'),
+    Refund: require('./Refund'),
+    RefundReasonDetails: require('./RefundReasonDetails'),
+    Report: require('./Report'),
+    ReportFilter: require('./ReportFilter'),
+    Repudiation: require('./Repudiation'),
+    SecurityInfo: require('./SecurityInfo'),
+    SettlementTransfer: require('./SettlementTransfer'),
+    Shipping: require('./Shipping'),
+    ShippingAddress: require('./ShippingAddress'),
+    Transaction: require('./Transaction'),
+    Transfer: require('./Transfer'),
+    Ubo: require('./Ubo'),
+    UboDeclaration: require('./UboDeclaration'),
+    UboDeclarationRefusedReasonType: require('./UboDeclarationRefusedReasonType'),
+    UboDeclarationStatus: require('./UboDeclarationStatus'),
+    UboRefusedReasonType: require('./UboRefusedReasonType'),
+    UserCategory: require('./UserCategory'),
+    User: require('./User'),
+    UserLegal: require('./UserLegal'),
+    UserNatural: require('./UserNatural'),
+    UserNaturalPayer: require('./UserNaturalPayer'),
+    UserNaturalOwner: require('./UserNaturalOwner'),
+    UserLegalPayer: require('./UserLegalPayer'),
+    UserLegalOwner: require('./UserLegalOwner'),
+    UserNaturalCapacity: require('./UserNaturalCapacity'),
+    UserNaturalPut: require('./UserNaturalPut'),
+    Wallet: require('./Wallet'),
+    CountryAuthorizations: require('./CountryAuthorization'),
+    Deposit: require('./Deposit')
+};

package/lib/service.js

@@ -0,0 +1,14 @@
+var _ = require('underscore');
+
+function Service() {
+    _.bindAll(this, 'initialize');
+    this.initialize();
+}
+
+Service.prototype = {
+    initialize: function() {}
+};
+
+Service.extend = require('./utils').extend;
+
+module.exports = Service;

package/lib/services/BankAccounts.js

@@ -0,0 +1,31 @@
+/**
+ * @module BankAccounts
+ */
+
+var Service = require('../service');
+var Transaction = require('../models/Transaction');
+
+var BankAccounts = Service.extend({
+
+    /**
+     * Retrieve list of transactions for a bank account
+     * @param   {number}    bankAccountId   Bank Account Id
+     * @param   {Function}  callback        Callback function
+     * @param   {Object}    options         Request options
+     * @return  {Object}                    Request promise
+     */
+    getTransactions: function (bankAccountId, callback, options) {
+        if (options && !options.hasOwnProperty('parameters'))
+            Object.assign(options, {parameters: {...options}});
+        options = this._api._getOptions(callback, options, {
+            path: {
+                bankAccountId: bankAccountId
+            },
+            dataClass: Transaction
+        });
+
+        return this._api.method('transactions_get_for_bank_account', callback, options);
+    }
+});
+
+module.exports = BankAccounts;

package/lib/services/BankingAliases.js

@@ -0,0 +1,137 @@
+/**
+ * @module BankingAliases
+ */
+
+var Service = require('../service');
+var BankingAlias = require('../models/BankingAlias');
+var BankingAliasIBAN = require('../models/BankingAliasIBAN');
+
+var BankingAliases = Service.extend({
+    /**
+     * Create a banking alias
+     * @param {Object}      bankingAlias    Banking Alias Data
+     * @param {Function}    callback        Callback function
+     * @param {Object}      options         Request options
+     * @return {Object}                     Request promise
+     */
+    create: function(bankingAlias, callback, options) {
+
+        var bankingAliasKey = this.getBankingAliasKey(bankingAlias);
+        var bankingAliasClass = this.getBankingAliasClass(bankingAlias);
+
+        options = this._api._getOptions(callback, options, {
+            data: bankingAlias,
+            dataClass: bankingAliasClass,
+            path: {
+                walletId: bankingAlias.WalletId
+            }
+        });
+
+        return this._api.method('banking_aliases_' + bankingAliasKey + '_create', callback, options);
+    },
+
+    /**
+     * Get a banking alias
+     * @param {number}      bankingAliasId  Banking Alias Id
+     * @param {Function}    callback        Callback function
+     * @param {Object}      options         Request options
+     * @return {Object}                     Request promise
+     */
+    get: function(bankingAliasId, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            path: {
+                id: bankingAliasId
+            },
+            dataClass: BankingAlias
+        });
+
+        return this._api.method('banking_aliases_get', callback, options);
+    },
+
+    /**
+     * Get all banking aliases
+     * @param {Number}      walletId    Wallet Id
+     * @param {Function}    callback    Callback function
+     * @param {Object}      options     Request options
+     * @return {Object}                 Request promise
+     */
+    getAll: function(walletId, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            path: {
+                walletId: walletId
+            },
+            dataClass: BankingAlias
+        });
+        return this._api.method('banking_aliases_all', callback, options);
+    },
+
+    /**
+     * Update banking alias
+     * @param {number}      bankingAliasId  Banking Alias Id
+     * @param {Function}    callback        Callback function
+     * @param {Object}      options         Request options
+     * @return {Object}                     Request promise
+     */
+    update: function(bankingAlias, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            path: {
+                id: bankingAlias.Id
+            },
+            data: bankingAlias,
+            dataClass: BankingAlias
+        });
+
+        return this._api.method('banking_aliases_update', callback, options);
+    },
+
+    /**
+     * Deactivate banking alias
+     * @param {number}      bankingAliasId  Banking Alias Id
+     * @param {Function}    callback        Callback function
+     * @param {Object}      options         Request options
+     * @return {Object}                     Request promise
+     */
+    deactivate: function(bankingAliasId, callback, options) {
+        var bankingAlias = new BankingAlias({
+            Id: bankingAliasId,
+            Active: false
+        });
+
+        return this.update(bankingAlias, callback, options);
+    },
+
+    /**
+     * Activate banking alias
+     * @param {number}      bankingAliasId  Banking Alias Id
+     * @param {Function}    callback        Callback function
+     * @param {Object}      options         Request options
+     * @return {Object}                     Request promise
+     */
+    activate: function(bankingAliasId, callback, options) {
+        var bankingAlias = new BankingAlias({
+            Id: bankingAliasId,
+            Active: true
+        });
+
+        return this.update(bankingAlias, callback, options);
+    },
+
+    getBankingAliasKey: function(bankingAlias) {
+        if (bankingAlias.Type) {
+            return bankingAlias.Type.toLowerCase();
+        }
+        if (bankingAlias instanceof BankingAliasIBAN) return 'iban';
+
+        throw new Error('BankingAlias needs to have a Type');
+    },
+
+    getBankingAliasClass: function(bankingAlias) {
+        if (bankingAlias.Type) {
+            if (bankingAlias.Type === 'IBAN') return BankingAliasIBAN;
+        }
+        if (bankingAlias instanceof BankingAliasIBAN) return BankingAliasIBAN;
+        throw new Error('BankingAlias needs to have a Type');
+    }
+});
+
+module.exports = BankingAliases;

package/lib/services/CardPreAuthorizations.js

@@ -0,0 +1,75 @@
+/**
+ * @module CardPreAuthorizations
+ * @desc [MangoPay Card Pre-Authorizations API Reference](https://docs.mangopay.com/endpoints/v2.01/preauthorizations)
+ */
+var _ = require('underscore');
+var Service = require('../service');
+var CardPreAuthorization = require('../models/CardPreAuthorization');
+var Transaction = require('../models/Transaction');
+
+var CardPreAuthorizations = Service.extend({
+    /**
+     * Create new pre-authorization
+     * @param {Object}  cardPreAuthorization    CardPreAuthorization object or properties hash
+     * @param {Function} callback    Callback function
+     * @param {Object} options    Request options
+     * @return {Object}                         Promise of the request
+     */
+    create: function(cardPreAuthorization, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            data: cardPreAuthorization,
+            dataClass: CardPreAuthorization
+        });
+
+        return this._api.method('preauthorization_create', callback, options);
+    },
+
+    /**
+     * Get pre-authorization object
+     * @param {number}  cardPreAuthorizationId  PreAuthorization identifier
+     * @param {Function} callback    Callback function
+     * @param {Object} options    Request options
+     * @return {Object}                        Request promise
+     */
+    get: function(cardPreAuthorizationId, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            path: {
+                id: cardPreAuthorizationId
+            },
+            dataClass: CardPreAuthorization
+        });
+
+        return this._api.method('preauthorization_get', callback, options);
+    },
+
+    /**
+     * Update pre-authorization object
+     * @param {Object}      cardPreAuthorization        CardPreAuthorization object of properties hash
+     * @param {function}    callback
+     * @param {Object}      options
+     * @return {Object}                                 Request promise
+     */
+    update: function(cardPreAuthorization, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            data: cardPreAuthorization,
+            path: {
+                id: cardPreAuthorization.Id
+            },
+            dataClass: CardPreAuthorization
+        });
+
+        return this._api.method('preauthorization_save', callback, options);
+    },
+
+    getTransactions: function(cardPreAuthorizationId, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            path: {
+                id: cardPreAuthorizationId
+            }
+        });
+
+        return this._api.method('preauthorization_transactions_get', callback, options);
+    },
+});
+
+module.exports = CardPreAuthorizations;

package/lib/services/CardRegistrations.js

@@ -0,0 +1,64 @@
+/**
+ * @module CardRegistrations
+ * @desc [MangoPay Card Registration API Reference](https://docs.mangopay.com/endpoints/v2.01/cards)
+ */
+var _ = require('underscore');
+var Service = require('../service');
+var CardRegistration = require('../models/CardRegistration');
+
+var CardRegistrations = Service.extend({
+    /**
+     * Create new card registration
+     * @param {Object}  cardRegistration    CardRegistration object or properties hash
+     * @param {Function} callback    Callback function
+     * @param {Object} options    Request options
+     * @return {Object}                     Promise of the request
+     */
+    create: function(cardRegistration, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            data: cardRegistration,
+            dataClass: CardRegistration
+        });
+
+        return this._api.method('cardregistration_create', callback, options);
+    },
+
+    /**
+     * Get registration
+     * @param {number}  cardRegistrationId  Registration identifier
+     * @param {Function} callback    Callback function
+     * @param {Object} options    Request options
+     * @return {Object}                    Request promise
+     */
+    get: function(cardRegistrationId, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            path: {
+                id: cardRegistrationId
+            },
+            dataClass: CardRegistration
+        });
+
+        return this._api.method('cardregistration_get', callback, options);
+    },
+
+    /**
+     * Update card registration
+     * @param {Object}      cardRegistration        CardPreAuthorization object of properties hash
+     * @param {function}    callback                Callback function
+     * @param {Object}      options                 Request options
+     * @return {Object}                             Request promise
+     */
+    update: function(cardRegistration, callback, options) {
+        options = this._api._getOptions(callback, options, {
+            data: cardRegistration,
+            path: {
+                id: cardRegistration.Id
+            },
+            dataClass: CardRegistration
+        });
+
+        return this._api.method('cardregistration_save', callback, options);
+    }
+});
+
+module.exports = CardRegistrations;