PayLink Transact SDK Reference

https://github.com/atomicfi/atomic-transact-ios

pod 'AtomicSDK', :git => "https://github.com/atomicfi/atomic-transact-ios.git"

import SwiftUI
import AtomicTransact

struct ContentView: View {
    @State var showingTransact = false
    
    var body: some View {
        Button("Launch Transact") {
            showingTransact = true
        }.atomicTransact(
            isPresented: $showingTransact,
            config: {
              AtomicConfig(
                publicToken: "PUBLIC_TOKEN", 
                scope: .payLink, 
                tasks: [.init(operation: .switch)],
                theme: Theme(
                  brandColor: "#9460FE",
                  dark: false
                ),
                language: "en",
                deeplink: Deeplink(
                  step: "login-company",
                  companyId: "64ecca15ec669e000851d5d2"
                ),
                search: Search(
                  ruleId: "67571ed7b278a518d7d8abdf"
                ),
                metadata: [
                  "version": "1.2.1",
                  "test": "New User Experience", 
                  "testVariant": "B"
                ]
             )},
            onDataRequest: { request in
              // Handle data request for additional information
              print("Data request: \(request.fields)")
            },
            onAuthStatusUpdate: { status in
              print("Auth status: \(status.status)")
            },
            onTaskStatusUpdate: { task in
              print("Task \(task.taskId) status: \(task.status)")
            },
            onError: { error in
              print("Error: \(error)")
            },
            onCompletion: { result in
              switch result {
              case .closed(let response):
                print("Close event: \(response.reason)")
              case .error(let error):
                print("Transact returned with error: \(error)")
              default:
                print("Default case")
              }
            })
        
        .onReceive(Atomic.interactions) { interaction in
            print("Interaction event: \(interaction.name) \(interaction.value)")
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

import AtomicTransact

let config = AtomicConfig(
  publicToken: "PUBLIC_TOKEN", 
  scope: .payLink,
  tasks: [.init(operation: .switch)],
  theme: Theme(
    brandColor: "#9460FE",
    dark: false
  ),
  language: "en",
  deferredPaymentMethodStrategy: .sdk, // optional
  deeplink: Deeplink(
    step: "login-company",
    companyId: "64ecca15ec669e000851d5d2"
  ),
  search: Search(
    ruleId: "67571ed7b278a518d7d8abdf"
  ),
  metadata: [
    "version": "1.2.1",
    "test": "New User Experience",
    "testVariant": "B"
  ]
)

Atomic.presentTransact(
    from: self, 
    config: config,
    onDataRequest: { request in
      // Handle data request for additional information
      print("Data request: \(request.fields)")

      // Example of sending card data
      // Use a Basis Theory sandbox test card when testing Switch in sandbox.
      // Replace this with your actual data collection logic in production.
      let card = TransactDataResponse.CardData(
          number: "5100000000000008",
          expiry: "03/29",
          cvv: "111"
      )

      let identity = TransactDataResponse.Identity(
          firstName: "John ",
          lastName: "Doe",
          postalCode: "12345",
          address: "123 Main St",
          city: "New York",
          state: "NY",
          phone: "5551234567",
          email: "john.doe@example.com"
      )
      let errors = identity.validate()

      if !errors.isEmpty {
          for error in errors {
              print("Validation error: (error)")
          }
      }

      if !identity.isValid() {
          // Handle invalid identity
      }

      return TransactDataResponse(card: card, identity: identity)
    },
    onAuthStatusUpdate: { status in
      print("Auth status: \(status.status)")
    },
    onTaskStatusUpdate: { task in
      print("Task \(task.taskId) status: \(task.status)")
    },
    onError: { error in
      print("Error: \(error)")
    },
    onInteraction: { interaction in
      print("Interaction event: \(interaction.name) \(interaction.value)")
  }, 
  onCompletion: { result in
    switch result {
      case .closed(let response):
        print("Close event: \(response.reason)")
      case .error(let error):
        print("Transact returned with error: \(error)")
  }
})

buildscript {
  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
    mavenCentral() // Include to import Transact Android SDK
  }
  dependencies {
    // ...
  }
}

android {
  defaultConfig {
    minSdkVersion 23 // or greater
  }

  // Enable Java 8 support for Transact to work
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

dependencies {
  // ...
  implementation 'financial.atomic:transact:<insert latest version>'
}

 implementation("financial.atomic:transact:<insert latest version>")
  constraints {
      implementation("androidx.lifecycle:lifecycle-common") {
          version {
              strictly("2.6.1")
          }
      }
      implementation("androidx.lifecycle:lifecycle-process") {
          version {
              strictly("2.6.1")
          }
      }
  }

<activity
  android:name="financial.atomic.transact.activity.TransactActivity"
  android:theme="@style/Theme.You.Want"
  />

<activity
  android:name="financial.atomic.transact.activity.TransactActivity"
  android:theme="@style/Theme.You.Want"
  tools:replace="theme"
  />

import org.json.JSONObject
import financial.atomic.transact.*
import financial.atomic.transact.receiver.TransactBroadcastReceiver

val config = Config(
  publicToken = "PUBLIC_TOKEN",
  scope = Config.Scope.PAY_LINK,
  tasks = listOf(Config.Task(operation = Config.Operation.SWITCH)),
  theme = Config.Theme(
    brandColor = "#9460FE",
    dark = false
  ),
  language = "en",
  deferredPaymentMethodStrategy: .sdk, // optional
  deeplink = Config.Deeplink(
    step = "login-company",
    companyId = "64ecca15ec669e000851d5d2"
  ),
  search = Config.Search(
    ruleId = "67571ed7b278a518d7d8abdf"
  ),
  metadata = mapOf(
    "version" to "1.2.1",
    "test" to "New User Experience",
    "testVariant" to "B"
  )
)

Transact.registerReceiver(context, object: TransactBroadcastReceiver() {
  override fun onDataRequest(data: JSONObject) {
    // Handle data request for additional information
    Log.d("APP", "Data request: ${data.getJSONArray("fields")}")

    // Example of sending card data through the SDK.
    // Use a Basis Theory sandbox test card when testing Switch in sandbox.
    // If you are passing this info through the API, disregard this line.
    val card = Config.TransactDataResponse.CardData("5100000000000008", "03/29", "111")

    val identity =
        Config.TransactDataResponse.Identity(
            "John",
            "Doe",
            "12345",
            "123 Main St",
            "Apt 4B",
            "New York",
            "NY",
            "5551234567",
            "john.doe@example.com",
        )

    val dataResponse = Config.TransactDataResponse(card, identity)

    Transact.sendData(this@MainActivity, dataResponse)
  }
  override fun onAuthStatusUpdate(data: JSONObject) {
    Log.d("APP", "Auth status: ${data.getString("status")}")
  }
  override fun onTaskStatusUpdate(data: JSONObject) {
    Log.d("APP", "Task ${data.getString("taskId")} status: ${data.getString("status")}")
  }
  override fun onError(data: JSONObject) {
    Log.d("APP", "Error: ${data.getString("error")}")
  }
  override fun onInteraction(data: JSONObject) {
    Log.d("APP", "Interaction event: ${data.getString("name")} ${data.getJSONObject("value")}")
  }
  override fun onClose(data: JSONObject) {
    Log.d("APP", "Close event: ${data.getString("reason")}")
  }
})

Transact.present(context, config)

import android.content.Context;
import android.util.Log;
import org.json.JSONObject;
import java.util.Arrays;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import financial.atomic.transact.*;
import financial.atomic.transact.receiver.TransactBroadcastReceiver;

public class TransactJavaImplementation {
   public static void initializeTransact(Context context) {
    Map<String, String> metadata = new HashMap<>();
    metadata.put("version", "1.2.1");
    metadata.put("test", "New User Experience");
    metadata.put("testVariant", "B");

    Config config = new Config(
        "PUBLIC_TOKEN",
        Config.Scope.PAY_LINK,
        Arrays.asList(new Config.Task(Config.Operation.SWITCH)),
        new Config.Theme("#9460FE", false),
        "en",
        new Config.Deeplink("login-company", "64ecca15ec669e000851d5d2"),
        new Config.Search("67571ed7b278a518d7d8abdf"),
        metadata
    );

    Transact.Companion.registerReceiver(context, new TransactBroadcastReceiver() {
        @Override
        public void onDataRequest(JSONObject data) {
            // Handle data request for additional information
            Log.d("APP", "Data request: " + data.optJSONArray("fields"));
        }

        @Override
        public void onAuthStatusUpdate(JSONObject data) {
            Log.d("APP", "Auth status: " + data.optString("status"));
        }

        @Override
        public void onTaskStatusUpdate(JSONObject data) {
            Log.d("APP", "Task " + data.optString("taskId") + " status: " + data.optString("status"));
        }

        @Override
        public void onError(JSONObject data) {
            Log.d("APP", "Error: " + data.optString("error"));
        }

        @Override
        public void onInteraction(JSONObject data) {
            Log.d("APP", "Interaction event: " + data.optString("name") + " " + data.optJSONObject("value"));
        }

        @Override
        public void onClose(JSONObject data) {
            Log.d("APP", "Close event: " + data.optString("reason"));
        }
    });

    Transact.Companion.present(context, config);
  }
}

yarn add @atomicfi/transact-react-native

(cd ios && pod install)

import { Atomic, Operation } from "@atomicfi/transact-react-native"

Atomic.transact({
  config: {
    scope: "pay-link",
    publicToken: "PUBLIC_TOKEN",
    tasks: [{ operation: "switch" }],
    theme: {
      brandColor: "#9460FE",
      dark: false
    },
    language: "en",
    deeplink: {
      step: "login-company",
      companyId: "64ecca15ec669e000851d5d2"
    },
    search: {
      ruleId: "67571ed7b278a518d7d8abdf"
    },
    metadata: {
      version: "1.2.1",
      test: "New User Experience",
      testVariant: "B"
    }
  },
  onDataRequest: request => {
    // Handle data request for additional information
    console.log('Data request:', request.fields)
  },
  onAuthStatusUpdate: status => {
    console.log('Auth status:', status.status)
  },
  onTaskStatusUpdate: task => {
    console.log('Task', task.taskId, 'status:', task.status)
  },
  onError: error => {
    console.log('Error:', error)
  },
  onInteraction: interaction => {
    console.log('Interaction event:', interaction.name, interaction.value)
  },
  onClose: data => {
    console.log('Close event:', data.reason)
  }
})

dependencies:
  ...
  atomic_transact_flutter: <version>

android {
  defaultConfig {
    minSdkVersion 23 // or greater
  }
}

import 'package:atomic_transact_flutter/atomic_transact_flutter.dart';

Atomic.transact(
  config: AtomicConfig(
    publicToken: "PUBLIC_TOKEN",
    scope: "pay-link",
    tasks: [AtomicTask(operation: AtomicOperationType.switchPayment)],
    theme: AtomicTheme(
      brandColor: "#9460FE",
      dark: false,
    ),
    language: "en",
    deeplink: AtomicDeeplink.step(
      DeeplinkStep.loginCompany(companyId: "64ecca15ec669e000851d5d2"),
    ),
    search: AtomicSearch(ruleId: "67571ed7b278a518d7d8abdf"),
    deferredPaymentMethodStrategy: AtomicDeferredPaymentMethodStrategy.sdk, // optional
    metadata: {
      "version": "1.2.1",
      "test": "New User Experience",
      "testVariant": "B",
    },
  ),
  onDataRequest: (request) {
    // Handle data request for additional information
    print("Data request: ${request.fields}");

    // Example of sending card data through the SDK.
    // Use a Basis Theory sandbox test card when testing Switch in sandbox.
    // If you are passing this info through the API, disregard this return.
    return AtomicTransactDataResponse(
      card: AtomicTransactCardData(
        number: "5100000000000008",
        expiry: "03/29",
        cvv: "111",
      ),
      identity: AtomicTransactIdentity(
        firstName: "John",
        lastName: "Doe",
        postalCode: "12345",
        address: "123 Main St",
        address2: "Apt 4B",
        city: "New York",
        state: "NY",
        phone: "5551234567",
        email: "john.doe@example.com",
      ),
    );
  },
  onAuthStatusUpdate: (status) {
    print("Auth status: ${status.status}");
  },
  onTaskStatusUpdate: (task) {
    print("Task ${task.taskId} status: ${task.status}");
  },
  onInteraction: (interaction) {
    print("Interaction event: ${interaction.name} ${interaction.value}");
  },
  onCompletion: (type, response, error) {
    print("Completion event: $type");
  },
);

npm install @atomicfi/transact-capacitor && npx cap sync

import { TransactPlugin } from '@atomicfi/transact-capacitor'

await TransactPlugin.addListener('onInteraction', (event) => {
  console.log('Interaction event:', event.name, event.value)
})
await TransactPlugin.addListener('onAuthStatusUpdate', (event) => {
  console.log('Auth status:', event.status)
})
await TransactPlugin.addListener('onTaskStatusUpdate', (event) => {
  console.log('Task', event.taskId, 'status:', event.status)
})
await TransactPlugin.addListener('onClose', (event) => {
  console.log('Close event:', event.reason)
})
await TransactPlugin.addListener('onDataRequest', async (event) => {
  // Handle data request for additional information
  console.log('Data request:', event.fields)
  await TransactPlugin.resolveDataRequest({ /* provide required data */ })
})

await TransactPlugin.presentTransact({
  config: {
    scope: 'pay-link',
    publicToken: 'PUBLIC_TOKEN',
    tasks: [{ operation: 'switch' }],
    theme: {
      brandColor: '#9460FE',
      dark: false
    },
    language: 'en',
    deeplink: {
      step: 'login-company',
      companyId: '64ecca15ec669e000851d5d2'
    },
    metadata: {
      version: '1.2.1',
      test: 'New User Experience',
      testVariant: 'B'
    }
  },
  environment: { environment: 'production' }
})