mangopay4-nodejs-sdk 1.64.0

package/test/services/VirtualAccounts.js

@@ -0,0 +1,105 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('VirtualAccounts', function() {
+    var john = helpers.data.getUserNatural();
+    var wallet;
+    var virtualAccount;
+
+    before(function(done){
+        api.Users.create(john).then(function(){
+            wallet  = {
+                Owners: [john.Id],
+                Currency: 'EUR',
+                Description: 'WALLET IN EUR'
+            };
+            api.Wallets.create(wallet).then(function(){
+                done();
+            });
+        });
+    });
+
+    describe('Create', function () {
+        before(function(done){
+            var virtualAccountCreate = {
+                Country: 'FR',
+                VirtualAccountPurpose: 'Collection',
+                Tag: 'create virtual account tag'
+            };
+
+            api.VirtualAccounts.create(wallet.Id, virtualAccountCreate).then(function(data){
+                virtualAccount = data;
+                done();
+            });
+        });
+
+        it('should be correctly created', function () {
+            expect(virtualAccount.Id).to.not.be.null;
+            expect(wallet.Id).to.equal(virtualAccount.WalletId);
+        });
+    });
+
+    describe('Get', function () {
+        var getVirtualAccount;
+
+        before(function(done){
+            api.VirtualAccounts.get(wallet.Id, virtualAccount.Id).then(function(data){
+                getVirtualAccount = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(virtualAccount.Id).to.equal(getVirtualAccount.Id);
+        });
+    });
+
+    describe('Get All', function () {
+        var allVirtualAccounts;
+
+        before(function(done){
+            api.VirtualAccounts.getAll(wallet.Id).then(function(data){
+                allVirtualAccounts = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(allVirtualAccounts.length).to.equal(1);
+        });
+    });
+
+    describe('Deactivate', function () {
+        var deactivatedVirtualAccount;
+
+        before(function(done){
+            api.VirtualAccounts.deactivate(wallet.Id, virtualAccount.Id).then(function(data){
+                deactivatedVirtualAccount = data;
+                done();
+            });
+        });
+
+        it('should be correctly created', function () {
+            expect(deactivatedVirtualAccount.Active).to.equal(false);
+        });
+    });
+
+    describe.skip('Get Availabilities', function () {
+        // TODO
+        console.warn("Skipped because of API issues. To be enabled after API is fixed.");
+        var availabilities;
+
+        before(function(done){
+            api.VirtualAccounts.getAvailabilities().then(function(data){
+                availabilities = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(availabilities.Collection.length).to.greaterThan(0);
+            expect(availabilities.UserOwned.length).to.greaterThan(0);
+        });
+    });
+});

package/test/services/Wallets.js

@@ -0,0 +1,132 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Wallets', function() {
+    var john = helpers.data.getUserNatural();
+    var wallet;
+
+    before(function(done){
+        api.Users.create(john).then(function(){
+            wallet  = {
+                Owners: [john.Id],
+                Currency: 'EUR',
+                Description: 'WALLET IN EUR'
+            };
+            api.Wallets.create(wallet).then(function(){
+                done();
+            });
+        });
+    });
+
+    describe('Create', function () {
+        it('should exist', function () {
+            expect(wallet.Id).to.exist;
+            expect(wallet.Owners).to.contain(john.Id);
+        });
+    });
+
+    describe('Get', function () {
+        var getWallet;
+
+        before(function(done){
+            api.Wallets.get(wallet.Id).then(function(data){
+                getWallet = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(wallet.Id).to.equal(getWallet.Id);
+            expect(wallet.CreationDate).to.equal(getWallet.CreationDate);
+        });
+    });
+
+    describe('Get Sca', function () {
+        var responseError;
+
+        before(function (done) {
+            api.Wallets.get(wallet.Id, function (data) {},
+                {
+                    parameters: {
+                        ScaContext: 'USER_PRESENT'
+                    },
+                    resolveWithFullResponse: true
+                })
+                .catch(function (error) {
+                    responseError = error;
+                    done();
+                });
+        });
+
+        it('redirectUrl should be present on response headers', function () {
+            expect(responseError.headers['www-authenticate']).to.contain("PendingUserAction RedirectUrl");
+        });
+    });
+
+    describe('Save', function () {
+        var NEW_DESCRIPTION = 'New description to test';
+
+        before(function(done){
+            wallet.description = NEW_DESCRIPTION;
+            api.Wallets.update(wallet).then(function(data){
+                wallet = data;
+                done();
+            });
+        });
+
+        it('should be correctly updated', function () {
+            expect(wallet.Description).to.equal(NEW_DESCRIPTION);
+        });
+    });
+
+    describe('Transactions', function () {
+        var transactions;
+
+        before(function(done){
+            helpers.getNewPayInCardWeb(api, john, async function(data){
+                // wait 2 seconds for the transactions to be created by the API
+                const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+                await delay(2000);
+
+                api.Wallets.getTransactions(data.CreditedWalletId, function(data, response){
+                    transactions = data;
+                    done();
+                }, {
+                    // parameters: {
+                    //     TYPE: 'PAYIN'
+                    // },
+                    page: 1,
+                    per_page: 50,
+                    TYPE: 'PAYIN'
+                });
+            });
+        });
+
+        it('should be correctly updated', function () {
+            expect(transactions.length).to.equal(1);
+            expect(transactions[0].AuthorId).to.equal(john.Id);
+        });
+    });
+
+    describe('Transactions Sca', function () {
+        var responseError;
+
+        before(function(done){
+            api.Wallets.getTransactions(wallet.Id, function(data, response) {}, {
+                page: 1,
+                per_page: 50,
+                ScaContext: 'USER_PRESENT',
+                resolveWithFullResponse: true
+            })
+                .catch(function (error) {
+                    responseError = error;
+                    done();
+                });
+        });
+
+        it('redirectUrl should be present on response headers', function () {
+            expect(responseError.headers['www-authenticate']).to.contain("PendingUserAction RedirectUrl");
+        });
+    });
+});

package/test/settlement_sample.csv

@@ -0,0 +1,8 @@
+IntentId,ExternalProviderReference,ExternalPaymentMethod,ExternalTransactionType,ExternalTransactionStatus,ExternalProcessingDate,Amount,Currency,ExternalInitialReference,ExternalProviderFees
+int_0197b19d-ee51-7b60-84cb-207491cf383a,6TU984332A894613W,PAYPAL,PAYMENT,SETTLED,19-06-2025,1000,EUR,,0
+,,,,,,,,,
+SettlementDate,19-06-2025,,,,,,,,
+ExternalProviderName,Paypal,,,,,,,,
+TotalSettlementFeesAmount,0,,,,,,,,
+TotalSettlementAmount,1000,,,,,,,,
+SettlementCurrency,EUR,,,,,,,,

package/typings/base.d.ts

@@ -0,0 +1,308 @@
+import { DeepPartial, Timestamp } from "./types";
+import { Models } from "./models";
+
+export namespace base {
+    type WithToJson<T extends object> = T & { toJSON(): any };
+
+    interface Config {
+        /**
+         * API Client Id
+         */
+        clientId: string;
+
+        /**
+         * API Client Api Key
+         */
+        clientApiKey: string;
+
+        /**
+         * API Base URL.The fault base value points to sandbox.
+         * Production is 'https://api.mangopay.com'
+         *
+         * @default "https://api.sandbox.mangopay.com"
+         */
+        baseUrl?: string;
+
+        /**
+         * Active debugging
+         * @default false
+         */
+        debugMode?: boolean;
+
+        /**
+         * Log function to be used for debug
+         * @default `console.log`
+         */
+        logClass?(...args: any[]): void;
+
+        /**
+         * Set the connection timeout limit(in milliseconds)
+         * @default 30000
+         */
+        connectionTimeout?: number;
+
+        /**
+         * Set the response timeout limit(in milliseconds)
+         * @default 30000
+         */
+        responseTimeout?: number;
+
+        /**
+         * API Version
+         * @default 'v2.01'
+         */
+        apiVersion?: string;
+
+        /**
+         * Set to true for uk traffic
+         * @default 'false'
+         */
+        ukHeaderFlag?: boolean
+
+        /**
+         * Set a custom error handler
+         * @default `console.error`
+         */
+        errorHandler?(options: any, err: any): void;
+    }
+
+    interface RequestOptions {
+        /**
+         * Path options are replacing the ${placeholders} from apiMethods
+         */
+        path: {
+            clientId: string;
+            apiVersion: string;
+            readonly id: string;
+        };
+
+        headers: Partial<Headers>;
+    }
+
+    interface Headers {
+        "Content-Type": string;
+
+        "User-Agent": string;
+
+        "Idempotency-Key": string;
+
+        Authorization: string;
+
+        [header: string]: string | undefined;
+    }
+
+    interface AuthorizationData {
+        access_token: string;
+
+        token_type: string;
+
+        expires_in: number;
+    }
+
+    interface PaginationOptions {
+        /**
+         * The page number of results you wish to return
+         * @default 1
+         */
+        Page?: number;
+
+        /**
+         * The number of results to return per page: Max 100;
+         * @default 10
+         */
+        Per_Page?: number;
+    }
+
+    interface FilterOptions extends Record<string, any> {
+        /**
+         * The column to sort against and direction - only CreationDate (or Date for the events) is available and ASC or DESC for the direction. E.g. "CreationDate:ASC"
+         */
+        Sort?: string;
+
+        /**
+         * To return only resources that have CreationDate BEFORE this date
+         */
+        BeforeDate?: Timestamp;
+
+        /**
+         * To return only resources that have CreationDate AFTER this date
+         */
+        AfterDate?: Timestamp;
+    }
+
+    interface DependsObject {
+        dependsPropertyName: string;
+
+        propertyName: string;
+
+        propertyValueMapping: Record<string, Models.Model>;
+    }
+
+    interface BrowserInfoData {
+        AcceptHeader: string;
+
+        JavaEnabled: boolean;
+
+        Language: string;
+
+        ColorDepth: number;
+
+        ScreenHeight: number;
+
+        ScreenWidth: number;
+
+        JavascriptEnabled: boolean;
+
+        TimeZoneOffset: string;
+
+        UserAgent: string;
+    }
+
+    interface FallbackReasonData {
+        Code: string;
+
+        Message: string;
+    }
+
+    interface PayoutPaymentRefData {
+        ReasonType: string;
+
+        ReferenceId: string;
+    }
+
+    interface WithResponse<T> {
+        status: number;
+
+        statusText: string;
+
+        body: T;
+
+        headers: Headers;
+    }
+
+    interface NoArgMethodOverload<R> {
+        (options: MethodOptionWithResponse): Promise<WithResponse<R>>;
+
+        (options?: MethodOptionWithoutResponse): Promise<R>;
+
+        (
+            callback: (data: WithResponse<R>) => void,
+            options?: MethodOptionWithResponse
+        ): void;
+
+        (callback: (data: R) => void, options?: MethodOptionWithoutResponse): void;
+    }
+
+    interface MethodOverload<T, R> {
+        (data: T, options: MethodOptionWithResponse): Promise<WithResponse<R>>;
+
+        (data: T, options?: MethodOptionWithoutResponse): Promise<R>;
+
+        (
+            data: T,
+            callback: (data: WithResponse<R>) => void,
+            options: MethodOptionWithResponse
+        ): void;
+
+        (
+            data: T,
+            callback: (data: R) => void,
+            options?: MethodOptionWithoutResponse
+        ): void;
+    }
+
+    interface TwoArgsMethodOverload<T, U, R> {
+        (data: T, extra: U, options: MethodOptionWithResponse): Promise<WithResponse<R>>;
+
+        (data: T, extra: U, options?: MethodOptionWithoutResponse): Promise<R>;
+
+        (
+            data: T,
+            extra: U,
+            callback: (data: WithResponse<R>) => void,
+            options?: MethodOptionWithResponse
+        ): void;
+
+        (
+            data: T,
+            extra: U,
+            callback: (data: R) => void,
+            options?: MethodOptionWithoutResponse
+        ): void;
+    }
+
+    interface ThreeArgsMethodOverload<T, U, V, R> {
+        (data: T, extra: U, lastArg: V, options: MethodOptionWithResponse): Promise<WithResponse<R>>;
+
+        (
+            data: T,
+            extra: U,
+            lastArg: V,
+            options?: MethodOptionWithoutResponse
+        ): Promise<R>;
+
+        (
+            data: T,
+            extra: U,
+            lastArg: V,
+            callback: (data: WithResponse<R>) => void,
+            options?: MethodOptionWithResponse
+        ): void;
+
+        (
+            data: T,
+            extra: U,
+            lastArg: V,
+            callback: (data: R) => void,
+            options?: MethodOptionWithoutResponse
+        ): void;
+    }
+
+    interface FourArgsMethodOverload<T, U, V, Q, R> {
+        (data: T, extra: U, arg: V, lastArg: Q, options: MethodOptionWithResponse): Promise<WithResponse<R>>;
+
+        (
+            data: T,
+            extra: U,
+            arg: V,
+            lastArg: Q,
+            options?: MethodOptionWithoutResponse
+        ): Promise<R>;
+
+        (
+            data: T,
+            extra: U,
+            arg: V,
+            lastArg: Q,
+            callback: (data: WithResponse<R>) => void,
+            options?: MethodOptionWithResponse
+        ): void;
+
+        (
+            data: T,
+            extra: U,
+            arg: V,
+            lastArg: Q,
+            callback: (data: R) => void,
+            options?: MethodOptionWithoutResponse
+        ): void;
+    }
+
+    // Determines the shape of the response
+    interface resolveWithFullResponse {
+        resolveWithFullResponse: true;
+    }
+
+    interface MethodOptions extends DeepPartial<RequestOptions> {
+        data?: WithToJson<object> | string;
+        parameters?: FilterOptions & PaginationOptions;
+    }
+
+    interface MethodOptionWithResponse extends MethodOptions {
+        resolveWithFullResponse: true;
+    }
+
+    interface MethodOptionWithoutResponse extends MethodOptions {
+        resolveWithFullResponse?: false;
+    }
+}