Salesforce B2C カートリッジ実装

var argOrderUpdate = {
        orderNumber: orderNumber,
        updateAttempt: 1
    },
    forterCall = require('*/cartridge/scripts/pipelets/forter/forterValidate'),
    forterDecision = forterCall.postAuthOrderStatusUpdate(argOrderUpdate, "PROCESSING");
if (forterDecision.result === false && forterDecision.updateAttempt == 2) {
    forterDecision.updateAttempt = 2;
    forterCall.postAuthOrderStatusUpdate(argOrderUpdate, "PROCESSING");
}

{
  "message": "",
  "action": "decline",
  "recommendations": [
    [
      "VERIFICATION_REQUIRED_3DS_CHALLENGE"
    ]
  ],
  "transaction": "123456",
  "status": "success"
}

function Authorize(orderNumber, paymentInstrument, paymentProcessor) {
    var serverErrors = [],
        fieldErrors = {},
        error = false;
    try {
        Transaction.wrap(function() {
            paymentInstrument.paymentTransaction.setTransactionID(orderNumber);
            paymentInstrument.paymentTransaction.setPaymentProcessor(paymentProcessor);
        });
        var argCCAuth = {
                orderNumber: orderNumber,
                PaymentInstrument: paymentInstrument
            },
            authResponse = doAuth(argCCAuth);
        if (authResponse.result === false) {
            var argOrderValidate = {
                    orderNumber: orderNumber,
                    orderValidateAttemptInput: 1,
                    request: request
                },
                forterCall = require('int_forter_sfra/cartridge/scripts/pipelets/forter/ForterValidate'),
                forterDecision = forterCall.validateOrder(argOrderValidate);
            // in case if no response from Forter, try to call one more time
            if (forterDecision.result === false && forterDecision.orderValidateAttemptInput == 2) {
                var argOrderValidate = {}
                orderNumber: orderNumber, orderValidateAttemptInput: 2,
                    request: request
            },
            forterCall = require('int_forter_sfra/cartridge/scripts/pipelets/forter/ForterValidate'), forterDecision = forterCall.validateOrder(argOrderValidate);
            error = true;
            serverErrors.push(Resource.msg('error.technical', 'checkout', null));
        }
        if (authResponse.result === true) {
            var argOrderValidate = {
                    orderNumber: orderNumber,
                    orderValidateAttemptInput: 1,
                    request: request
                },
                forterCall = require('int_forter_sfra/cartridge/scripts/pipelets/forter/ForterValidate'),
                forterDecision = forterCall.validateOrder(argOrderValidate);
            // in case if no response from Forter, try to call one more time
            if (forterDecision.result === false && forterDecision.orderValidateAttemptInput == 2) {
                var argOrderValidate = {
                    orderNumber: orderNumber,
                    orderValidateAttemptInput: 2,
                    request: request
                };
                forterCall = require('int_forter_sfra/cartridge/scripts/pipelets/forter/ForterValidate'), forterDecision = forterCall.validateOrder(argOrderValidate);
            }
            if (forterDecision.JsonResponseOutput.processorAction === 'skipCapture' || forterDecision.JsonResponseOutput.processorAction === 'notReviewed') {
                error = false;
            } else if (forterDecision.JsonResponseOutput.processorAction === 'disabled' ||
                forterDecision.JsonResponseOutput.processorAction === 'internalError' || forterDecision.JsonResponseOutput.processorAction === 'capture') {
                var argCCCapture = {
                    Page 3 - 43
                }
            }
            AuthorizeNetResponse: authResponse.AuthorizeNetResponse, orderNumber: orderNumber,
                PaymentInstrument: paymentInstrument
        },
        captureResponse = doCapture(argCCCapture);
        if (captureResponse.result === true) {
            error = false;
        }
        if (captureResponse.result === false) {
            var argVoid = {
                    AuthorizeNetResponse: authResponse.AuthorizeNetResponse,
                    orderNumber: orderNumber,
                    PaymentInstrument: paymentInstrument
                },
                voidResponse = doVoid(argVoid);
            error = true;
            serverErrors.push(
                Resource.msg('error.technical', 'checkout', null));
        }
    } else {
        var argVoid = {
                AuthorizeNetResponse: authResponse.AuthorizeNetResponse,
                orderNumber: orderNumber,
                PaymentInstrument: paymentInstrument
            },
            voidResponse = doVoid(argVoid);
        error = true;
        serverErrors.push(
            Resource.msg('error.technical', 'checkout', null));
    } catch (e) {
        error = true;
        serverErrors.push(
            Resource.msg('error.technical', 'checkout', null)
        );
    }
    return {
        fieldErrors: fieldErrors,
        serverErrors: serverErrors,
        error: error
    };
}

function doAuth(argCCAuth) {
    var authorizenetCCAuthRequest = require('~/cartridge/scripts/pipelets/AuthorizenetCCAuthRequest'),
        authResponse = authorizenetCCAuthRequest.execute(argCCAuth);
    return authResponse;
}

function doCapture(argCCCapture) {
    var authorizenetCCCaptureRequest = require('~/cartridge/scripts/pipelets/AuthorizenetCCCaptureRequest'),
        captureResponse = authorizenetCCCaptureRequest.execute(argCCCapture);
    return captureResponse;
}

function doVoid(argVoid) {
    var authorizenetVoidRequest = require('~/cartridge/scripts/pipelets/AuthorizenetVoidRequest'),
        voidResponse = authorizenetVoidRequest.execute(argVoid);
    return voidResponse;
}

return {
    error: true,
    PlaceOrderError: new Status(Status.ERROR, handlePaymentsResult.forterErrorCode ? handlePaymentsResult.forterErrorCode.code : 'confirm.error.technical')
};