teamv-sdk-node/lib/services/payments.js

Decidir SDK NODEJS ===============

const functions = require('../utils/functions');
const Client = require('node-rest-client').Client;
const constants = require('../utils/constants')
const logger = require('../utils/logger')
const { generateRetailData } = require('../services/fraud_detection/cs_retail');
const { generateTicketingData } = require('../services/fraud_detection/cs_ticketing');
const { generatedigitalGoodsData } = require('../services/fraud_detection/cs_digitalGoods');
const { generateServicesData } = require('../services/fraud_detection/cs_services');


const getFraudDetectionArgs = (fraudDetection) => {
    if (!fraudDetection) return null;

    const verticalMap = {
        ticketing_transaction_data: 'ticketing',
        retail_transaction_data: 'retail',
        digital_goods_transaction_data: 'dgs',
        services_transaction_data: 'services'
    };

    const verticalConfig = {
        retail: (data) => generateRetailData(data),
        ticketing: (data) => generateTicketingData(data),
        dgs: (data) => generatedigitalGoodsData(data),
        services: (data) => generateServicesData(data)
    };

    for (const key in verticalMap) {
        if (fraudDetection[key]) {
            const vertical = verticalMap[key];
            const sdkFunction = verticalConfig[vertical];
            if (sdkFunction) {
                return sdkFunction(fraudDetection);
            }
        }
    }

    return null;
};

module.exports = {
    getAllPayments: (args, offset, pageSize, siteOperationId, merchantId, callback) => {
        client = new Client();
        var queryString = "";
        if (offset !== "" && offset !== undefined) {
            queryString += "offset=" + offset + "&";
        }
        if (pageSize !== "" && pageSize !== undefined) {
            queryString += "pageSize=" + pageSize + "&";
        }
        if (siteOperationId !== "" && siteOperationId !== undefined) {
            queryString += "siteOperationId=" + siteOperationId + "&";
        }
        if (merchantId !== "" && merchantId !== undefined) {
            queryString += "merchantId=" + merchantId + "&";
        }

        client.get(constants.ENDPOINT_DEVELOPER + "/payments?" + queryString, args, (data, response) => {
            data.getLimit = function () {
                return this.limit;
            };
            data.getOffset = function (data, response) {
                return this.offset;
            };
            data.getResults = function () {
                return this.site_transaction_id;
            };
            data.hasMore = function () {
                return this.hasMore;
            };

            ret = data;
            err = "no se detectaron errores en la petición.";
            if (Buffer.isBuffer(data)) {
                data = data.toString('utf8');
                err = data;
                ret = "Ha ocurrido un error.";
            }
            callback(ret, err);
        });
    },
    payment: (endpoint, apikey, args, callback, grouper, developer) => {
        client = new Client();

        logger.info(` - payment request with payload: ${JSON.stringify(args, null, 2)}`);

        const fraudDetectionArgs = getFraudDetectionArgs(args.fraud_detection);

        const requestOptions = {
            data: {
                ...args,
                ...(fraudDetectionArgs ? { "fraud_detection": fraudDetectionArgs } : {})
            },
            headers: {
                apikey: apikey,
                'Content-Type': "application/json",
                'X-Source': functions.generateXsourceHeader(grouper, developer),
            }
        };

        logger.info(`Payment Request - Endpoint: ${endpoint}/payments`);
        logger.info(`Headers: ${JSON.stringify({
            apikey: apikey,
            'Content-Type': "application/json",
            'X-Source': functions.generateXsourceHeader(grouper, developer),
        }, null, 2)}`);

        client.post(`${endpoint}/payments`, requestOptions, (data, response) => {
            const ret = data;
            const err = "";
            logger.info(JSON.stringify(data));
            callback(ret, err);
        });
    },

    tokenizedPCIPayment: (endpoint, apikey, args, callback, grouper, developer) => {
        client = new Client();

        logger.info(` - tokenizedPCIPayment request with payload: ${JSON.stringify(args, null, 2)}`);

        arg = {
            data: args,
            headers: {
                apikey: apikey,
                'Content-Type': "application/json",
                'X-Source': functions.generateXsourceHeader(grouper, developer)
            }
        };
        client.post(endpoint + "/payments", arg, function (data, response) {
            ret = data;
            err = "";
            logger.info(JSON.stringify(data));
            callback(ret, err);
        });
    },
    threeDSchallenge: (endpoint, apikey, args, callback, grouper, developer, consumer) => {
        client = new Client();

        logger.info(` - threeDSchallenge request with payload: ${JSON.stringify(args, null, 2)}`);

        arg = {
            data: args,
            headers: {
                'apikey': apikey,
                'Content-Type': "application/json",
                'X-Source': functions.generateXsourceHeader(grouper, developer),
                'X-Consumer-Username': consumer
            }
        };

        client.post(endpoint + "/threeds/instruction", arg, function (data, response) {
            ret = data;
            err = "";
            logger.info(JSON.stringify(data));
            callback(ret, err);
        });
    },

    confirmPayment: (id, endpoint, apikey, args, callback, grouper, developer) => {
        client = new Client();

        logger.info(` - confirmPayment request with payload: ${JSON.stringify(args, null, 2)}`);

        arg = {
            data: args,
            headers: {
                apikey: apikey,
                'Content-Type': "application/json",
                'X-Source': functions.generateXsourceHeader(grouper, developer)
            }
        };

        client.put(`${endpoint}/payments/${id}`, arg, function (data, response) {
            ret = data;
            err = "";
            logger.info(JSON.stringify(data));
            callback(ret, err);
        });
    }
}