Step One - To integrate the iOS mobile SDK via CocoaPods:

Step Two - To add the mobile SDK as a dependency:

The Pod installation complete! message appears in the terminal.

If the Unable to find a specification error message appears, your CocoaPods repository, which stores a reference to all available pods, needs updating. To update your CocoaPods repository run: $ pod repo update

To integrate the iOS Mobile SDK via Carthage:

The iOS Mobile SDK is now ready to use in your iOS project.

To get started:

To initialise a JudoKit session:

To create a JudoKit session:

JudoKit *judo = [[JudoKit alloc] initWithAuthorization:authorization];

Use the JPConfiguration object to set the parameters. The JPConfiguration object is passed as a method parameter and communicates how the payment flow should behave.

1. To configure the JPConfiguration object: 

Add your:

JPAmount *myAmount;
JPReference *myReference;
JPConfiguration *myConfiguration;

    myAmount = [[JPAmount alloc] initWithAmount:@"0.01"
                                   currency:@"GBP"];

    myReference = [[JPReference alloc] initWithConsumerReference:@"my-reference"];

    myConfiguration = [JPConfiguration alloc] initWithJudoID:@"my-judo-id"
                                       amount:myAmount
                                               reference:myReference];

The JPAmount object sets your:

These are used to set your unique consumerReference, to identify your consumer. Now you can use this object to make a transaction.

Prerequisites:

The available transaction types that can be passed as a parameter are:

For more details, see our API Reference documentation.

Once you have completed the prerequisite steps, you are ready to make a transaction.

To make a transaction:

1. Call the method and handling the response from the completion block:

[judo invokeTransactionWithType:TransactionTypePayment
                  configuration:configuration
                     completion:^(JPResponse *response, NSError *error) {

     // Handle response / error

}];

The SDK also offers server-to-server capabilities. This works by sending the payment token back to the merchant the moment the consumer presses the Pay button. This allows the merchant to process and complete the transaction on their side.

Server-to-server capabilities are available for both transactions made through:

To specify a server-to-server transaction:

[self.judoKitSession invokePaymentMethodScreenWithMode:TransactionModeServerToServer
                                         configuration:configuration
                                            completion:^(JPResponse *response, NSError *error) {
    // Handle the payment token returned from the response
}];

[self.judoKitSession invokeApplePayWithMode:TransactionModeServerToServer
                              configuration:configuration
                                 completion:^(JPResponse *response, NSError *error) {
    // Handle the payment token returned from the response
}];

If you are building your own card wallet, and not using a UI you can make a /payments or /preauths transaction using a stored card token.

Steps:

Billing Address | primary account details | CV2 are optional fields.

yourConsumerReference | yourPaymentReference | amount | currency | judo ID are mandatory fields.

To make a token payment or token preauth transaction:

Get the Card Token:

[judo invokeTransactionWithType:JPTransactionTypeSaveCard
                  configuration:configuration
                     completion:^(JPResponse *response, JPError *error) 
        {
           NSString *cardToken = response.cardDetails.cardToken;
            // Save the card token for future use.
                                                             }];

Create an API Service Session:

Complete a Token Transaction Request:

JPTokenRequest *request = [[JPTokenRequest alloc] initWithConfiguration:configuration
andCardToken:@"YOUR_TOKEN"

Complete a Payments Transaction

[apiService invokeTokenPaymentWithRequest:request andCompletion:^(JPResponse *response, JPError *error) {
// Handle response
}];

Complete a Preauths Transaction

[apiService invokePreAuthTokenPaymentWithRequest:request andCompletion:^(JPResponse *response,
// Handle response
}];

You have flexibility on how the payment experience looks to the consumer.

The JPConfiguration object has a uiConfiguration property of type JPUIConfiguration.

This allows you to:

An example of the JPUIConfiguration object:

JPUIConfiguration *uiConfig = [JPUIConfiguration new];
    uiConfig.shouldPaymentMethodsDisplayAmount = NO;
    uiConfig.shouldPaymentButtonDisplayAmount: = NO;
    uiConfig.isAVSEnabled = YES;
    uiConfig.shouldPaymentMethodsVerifySecurityCode = YES;

configuration.uiConfiguration = uiConfig;

The JPUIConfiguration instance is set as part of the JPConfiguration object that is passed to our transactions.

To set the primary account details to be sent with the transaction

1. Set the primaryAccountDetails property of the JPConfiguration object:

JPPrimaryAccountDetails *accountDetails;
accountDetails = [JPPrimaryAccountDetails new];

    accountDetails.name = @"example-name";
    accountDetails.accountNumber = @"example-number";
    accountDetails.dateOfBirth = @"example-date";
    accountDetails.postCode = @"example-post-code";

configuration.primaryAccountDetails = accountDetails;

To select the card networks to support:

1. Set the supportedCardNetworks property of the JPConfiguration object with one or more values from this list:

For the purpose of this exercise, Visa and MasterCard are set as the supported card networks: configuration.supportedCardNetworks = CardNetworkVisa | CardNetworkMasterCard;

To send additional card address details with the transaction:

JPAddress *cardAddress = [[JPCardAddress alloc] initWithLine1:@"address-1"
                                                        line2:@"address-2"
                                                        line3:nil
                                                         town:@"example-town"
                                                  countryCode:@"GB"
                                                     postCode:@"EX4 MPL3"];

By default, all payment methods are displayed in the Payments Widget (as long as the required parameters are set). 

You have the flexibility to include the payment methods you support, with pre-defined initialisers for each payment method.

To set the Payment Methods:

1. Set the paymentMethods property in the JPConfiguration object with your list of payment methods:

configuration.paymentMethods = @[  
    JPPaymentMethod.card,  
    JPPaymentMethod.iDeal
];

For the purpose of this exercise, Card and iDEAL transactions are set as the supported payment methods.

The JPPaymentMethod is an object that is initialized by providing a JPPaymentMethodType value.

PayByBankApp enables consumers to use bank transfers to easily pay for goods and services online.

For more details on using the PayByBankApp as an alternative payment method, see:

iDEAL enables consumers to easily pay online for goods and services in the Netherlands.

For more details using iDEAL as an alternative payment method, see:

To add iDEAL support to your Payments Widget, set:

An example of a valid iDEAL configuration:

configuration.judoId = @"my-judo-id";

Once the currency and judoId are set, iDEAL will be available as a payment method in the Payments Widget.

You can enable some additional information to be sent within a transaction, for example information to help with reconciliation or receipt tracking. Setting up the paymentReference and metaData properties can allow for:

To apply your own custom styles and theme options, override the following payment UI elements:

1. In ViewController delete the line that specifies the targeted environment:

self.judoKitSession.apiSession.sandboxed = YES;

2. Replace your sandbox API Token and Secret for the live API Token and Secret 

Find these in Judopay Portal > Your apps > {app name} > Live Tokens

self.judoKitSession = [[JudoKit alloc] initWithToken:token secret:secret];

Test live payments