Controllers

Controllers Post-Auth Integration

Overview

The ForterValidate controller is implemented with your payment gateway. In the sample implementations, you can see the mapping for CyberSource and Authorize.net.

You will need to customize the logic to fit your specific payment processor and gateway.

Controllers Code

Below is code from the Authorize.net controller which is triggered as part of the generic Site Genesis authorization flow. You will need to map the authorization response within your payment gateway's controller to the ForterOrder.ds which can be found via the path:

Cartridges>int_forter>cartridge>scripts>lib>forter>dto>ForterOrder.ds

Note that the below code references the Authorize.net controller within the Site Genesis authorization flow and additional customizations should be made to your gateway controller based on the data you receive from your payment gateway (i.e. CyberSource, Adyen, Braintree, PaymentTech etc.)

Sample Controllers Code (Authorize.net)

function Authorize(args) {
    if (empty(session.forms.billing.paymentMethods.selectedPaymentMethodID.value)) {
        return {error: true};
    }

    var orderNo           = args.OrderNo,
        paymentInstrument = args.PaymentInstrument,
        paymentProcessor  = PaymentMgr.getPaymentMethod(paymentInstrument.getPaymentMethod()).getPaymentProcessor();

    Transaction.wrap(function () {
        paymentInstrument.paymentTransaction.transactionID    = orderNo;
        paymentInstrument.paymentTransaction.paymentProcessor = paymentProcessor;
    });

    var argCCAuth = {
            Order             : args.Order,
            PaymentInstrument : paymentInstrument
        },
        authResponse = doAuth(argCCAuth);

    if (authResponse.result == false) {
                var argOrderValidate = {
                Order: args.Order,
                orderValidateAttemptInput: 1
            },
            forterController = require('int_forter/cartridge/controllers/ForterValidate'),
            forterDecision   = forterController.ValidateOrder(argOrderValidate);
        // in case if no response from Forter, try to call one more time
        if (forterDecision.result === false && forterDecision.orderValidateAttemptInput == 2) {
     	var argOrderValidate = {
                    Order: args.Order,
                    orderValidateAttemptInput: 2
                },
                forterController = require('int_forter/cartridge/controllers/ForterValidate'),
                forterDecision   = forterController.ValidateOrder(argOrderValidate);
        }

        if (!empty(forterDecision.PlaceOrderError)) {
            return {error : true, forterErrorCode : forterDecision.PlaceOrderError};
        } else {
            return {error : true};
        }
        return {error: true};
    }

    if (authResponse.result == true) {
        var argOrderValidate = {
                Order: args.Order,
                orderValidateAttemptInput: 1
            },
            forterController = require('int_forter/cartridge/controllers/ForterValidate'),
            forterDecision   = forterController.ValidateOrder(argOrderValidate);
        // in case if no response from Forter, try to call one more time
        if (forterDecision.result === false && forterDecision.orderValidateAttemptInput == 2) {
        	var argOrderValidate = {
                    Order: args.Order,
                    orderValidateAttemptInput: 2
                },
                forterController = require('int_forter/cartridge/controllers/ForterValidate'),
                forterDecision   = forterController.ValidateOrder(argOrderValidate);
        }
        
        if (forterDecision.JsonResponseOutput.processorAction === 'skipCapture' || forterDecision.JsonResponseOutput.processorAction === 'notReviewed') {
            return {authorized: true};
        } else if (forterDecision.JsonResponseOutput.processorAction === 'disabled' || forterDecision.JsonResponseOutput.processorAction === 'internalError' || forterDecision.JsonResponseOutput.processorAction === 'capture') {
            var argCCCapture = {
                    AuthorizeNetResponse : authResponse.AuthorizeNetResponse,
                    Order                : args.Order,
                    PaymentInstrument    : paymentInstrument
                },
                captureResponse = doCapture(argCCCapture);

            if (captureResponse.result == true) {
                return {authorized: true};
            }

            if (captureResponse.result == false) {
                var argVoid = {
                        AuthorizeNetResponse : authResponse.AuthorizeNetResponse,
                        Order                : args.Order,
                        PaymentInstrument    : paymentInstrument
                    },
                    voidResponse = doVoid(argVoid);

                if (!empty(forterDecision.PlaceOrderError)) {
                    return {error : true, forterErrorCode : forterDecision.PlaceOrderError};
                } else {
                    return {error : true};
                }
            }
        } else {
            var argVoid      = {
                    AuthorizeNetResponse : authResponse.AuthorizeNetResponse,
                    Order                : args.Order,
                    PaymentInstrument    : paymentInstrument
                },
                voidResponse = doVoid(argVoid);

            if (!empty(forterDecision.PlaceOrderError)) {
                return {error : true, forterErrorCode : forterDecision.PlaceOrderError};
            } else {
                return {error : true};
            }
        }
    }
}

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;
}

//this is within the ForterOrder.ds file

Response Not stored on Payment Instrument

If your implementation does NOT store the response on the payment instrument, you can pass the response object from your payment processor to the validateOrder() function by using the ForterValidate.js controller.

The path to the ForterValidate.js controller is: Cartridges > int_forter > cartridge > controllers > ForterValidate.js

When the ForterValidate.js controller is used as an input, it is sent as a parameter to the ForterOrder.ds file to generate the request object.