Maintaining a public-key based integration

const handler = Plaid.create({
  clientName: 'Plaid Quickstart',
  env: 'sandbox',
  key: 'PUBLIC_KEY',
  product: ['transactions'],
  onSuccess: (public_token, metadata) => {},
  onLoad: () => {},
  onExit: (err, metadata) => {},
  onEvent: (eventName, metadata) => {},
  countryCodes: ['US'],
  webhook: 'https://requestb.in',
  linkCustomizationName: '',
  language: 'en',
  oauthNonce: null,
  oauthRedirectUri: null,
  oauthStateId: null,
  token: null,
  paymentToken: null,
});

const handler = Plaid.create({
  ...,
  onSuccess: (public_token, metadata) => {
    fetch('//yourserver.com/exchange_public_token', {
      method: 'POST',
      body: {
        public_token: public_token,
        accounts: metadata.accounts,
        institution: metadata.institution,
        link_session_id: metadata.link_session_id,
      },
    });
  }
});

{
  institution: {
    name: 'Wells Fargo',
    institution_id: 'ins_4'
  },
  accounts: [
    {
      id: 'ygPnJweommTWNr9doD6ZfGR6GGVQy7fyREmWy',
      name: 'Plaid Checking',
      mask: '0000',
      type: 'depository',
      subtype: 'checking',
      verification_status: ''
    },
    {
      id: '9ebEyJAl33FRrZNLBG8ECxD9xxpwWnuRNZ1V4',
      name: 'Plaid Saving',
      mask: '1111',
      type: 'depository',
      subtype: 'savings'
    }
    ...
  ],
  link_session_id: '79e772be-547d-4c9c-8b76-4ac4ed4c441a'
}

const handler = Plaid.create({
  ...,
  onExit: (error, metadata) => {
    // Save data from the onExit handler
    supportHandler.report({
      error: error,
      institution: metadata.institution,
      link_session_id: metadata.link_session_id,
      plaid_request_id: metadata.request_id,
      status: metadata.status,
    });
  },
});

{
  error_type: 'ITEM_ERROR',
  error_code: 'INVALID_CREDENTIALS',
  error_message: 'the credentials were not correct',
  display_message: 'The credentials were not correct.',
}

{
  institution: {
    name: 'Wells Fargo',
    institution_id: 'ins_4'
  },
  status: 'requires_credentials',
  link_session_id: '36e201e0-2280-46f0-a6ee-6d417b450438',
  request_id: '8C7jNbDScC24THu'
}

const handler = Plaid.create({
  ...,
  onEvent: (eventName, metadata) => {
    // send event and metadata to self-hosted analytics
    analytics.send(eventName, metadata);
  },
});

{
  error_type: 'ITEM_ERROR',
  error_code: 'INVALID_CREDENTIALS',
  error_message: 'the credentials were not correct',
  exit_status: null,
  institution_id: 'ins_4',
  institution_name: 'Wells Fargo',
  institution_search_query: 'wellsf',
  mfa_type: null,
  view_name: 'ERROR'
  request_id: 'm8MDnv9okwxFNBV',
  link_session_id: '30571e9b-d6c6-42ee-a7cf-c34768a8f62d',
  timestamp: '2017-09-14T14:42:19.350Z',
}

const handler = Plaid.create({ ... });
// Graceful exit - Link may display a confirmation screen
// depending on how far the user is in the flow
handler.exit();

const handler = Plaid.create({ ... });
// Force exit - Link exits immediately
handler.exit({ force: true });

let linkConfiguration = PLKConfiguration(
  env: .sandbox,
  key: "<YOUR_PLAID_PUBLIC_KEY>",
  product: [.auth]
)
linkConfiguration.clientName = "My application";
linkConfiguration.language = "en";
linkConfiguration.countryCodes = ["US", "CA", "GB"];
linkConfiguration.webhook = "https://webhook.com";
linkConfiguration.linkCustomizationName = "default";
linkConfiguration.oauthRedirectUri = "<YOUR_OAUTH_REDIRECT_URI>"
linkConfiguration.oauthNonce = UUID().uuidString
let linkViewController = PLKPlaidLinkViewController(
  configuration: linkConfiguration,
  delegate: self
)
present(linkViewController, animated: true)

func linkViewController(
  _ linkViewController: PLKPlaidLinkViewController,
  didSucceedWithPublicToken publicToken: String,
  metadata: [String : Any]?
) {
  dismiss(animated: true) {
  // Exchange publicToken with an accessToken on your server
    NSLog("Successfully linked account!\npublicToken: (publicToken)\nmetadata: (metadata ?? [:])")
  }
}

{
  kPLKMetadataInstitutionKey: @{
    kPLKMetadataInstitutionNameKey: 'Wells Fargo',
    kPLKMetadataInstitutionIdKey: 'ins_4'
  },
  kPLKMetadataAccountsKey: [
    @{
      kPLKMetadataIdKey: 'ygPnJweommTWNr9doD6ZfGR6GGVQy7fyREmWy',
      kPLKMetadataNameKey: 'Plaid Checking',
      kPLKMetadataMaskKey: '0000',
      kPLKMetadataTypeKey: 'depository',
      kPLKMetadataSubtypeKey: 'checking',
      kPLKMetadataAccountVerificationStatusKey: ''
    },
    @{
      kPLKMetadataIdKey: '9ebEyJAl33FRrZNLBG8ECxD9xxpwWnuRNZ1V4',
      kPLKMetadataNameKey: 'Plaid Saving',
      kPLKMetadataMaskKey: '1111',
      kPLKMetadataTypeKey: 'depository',
      kPLKMetadataSubtypeKey: 'savings'
    }
    ...
  ],
  kPLKMetadataLinkSessionIdKey: '79e772be-547d-4c9c-8b76-4ac4ed4c441a'
}

func linkViewController(
    _ linkViewController: PLKPlaidLinkViewController,
  didExitWithError error: Error?,
                metadata: [String : Any]?
) {
  dismiss(animated: true) {
    if let error = error {
      NSLog("Failed to link account due to: (error.localizedDescription)\n metadata: (metadata ?? [:])")
      self.handleError(error, metadata: metadata)
    }
    else {
      NSLog("Plaid link exited with metadata: (metadata ?? [:])")
      self.handleExitWithMetadata(metadata)
    }
  }
}

{
  kPLKErrorTypeKey: 'ITEM_ERROR',
  kPLKErrorCodeKey: 'INVALID_CREDENTIALS',
  kPLKErrorMessageKey: 'the credentials were not correct',
  kPLKDisplayMessageKey: 'The credentials were not correct.',
}

{
   kPLKMetadataInstitutionKey: @{
    kPLKMetadataInstitutionNameKey: 'Wells Fargo',
    kPLKMetadataInstitutionIdKey: 'ins_4'
  },
  kPLKMetadataLinkSessionIdKey: '36e201e0-2280-46f0-a6ee-6d417b450438',
  kPLKMetadataRequestIdKey: '8C7jNbDScC24THu'
}

func linkViewController(
  _ linkViewController: PLKPlaidLinkViewController,
  didHandleEvent event: String,
  metadata: [String : Any]?
) {
  NSLog("Link event: (event)\nmetadata: (metadata ?? [:])")
}

{
  kPLKMetadataErrorTypeKey: 'ITEM_ERROR',
  kPLKMetadataErrorCodeKey: 'INVALID_CREDENTIALS',
  kPLKMetadataErrorMessageKey: 'the credentials were not correct',
  kPLKMetadataExitStatusKey: '',
  kPLKMetadataInstitutionIdKey: 'ins_4',
  kPLKMetadataInstitutionNameKey: 'Wells Fargo',
  kPLKMetadataInstitutionSearchQueryKey: 'wellsf',
  kPLKMetadataLinkSessionIdKey: '30571e9b-d6c6-42ee-a7cf-c34768a8f62d',
  kPLKMetadataMFATypeKey: '',
  kPLKMetadataRequestIdKey: 'm8MDnv9okwxFNBV',
  kPLKMetadataTimestampKey: '2017-09-14T14:42:19.350Z',
  kPLKMetadataViewNameKey: 'ERROR'
}

import android.content.Intent
import com.plaid.link.Plaid
import com.plaid.linkbase.models.LinkConfiguration
import com.plaid.linkbase.models.PlaidEnvironment
import com.plaid.linkbase.models.PlaidProduct
import com.plaid.link.configuration.LinkLogLevel
class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Open Link – this will usually be in a click listener
    this@MainActivity.openPlaidLink(
      linkConfiguration = linkConfiguration {
        environment = PlaidEnvironment.SANDBOX
        products = listOf(PlaidProduct.TRANSACTIONS)
        clientName = "My Application name"
        language = Locale.ENGLISH.language
        countryCodes = listOf(Locale.US.country)
        webhook = "https://requestb.in"
        linkCustomizationName = "default"
        publicToken = null
        paymentToken = null
      }
    )
  }
}

class MainActivity : AppCompatActivity() {
  private val resultHandler = PlaidLinkResultHandler(
    // ...
    onSuccess = { it: LinkConnection ->
      // Send public_token to your server, exchange for access_token
      val publicToken = it.publicToken
      val metadata = it.linkConnectionMetadata
      val accountId = metadata.accounts.first().accountId
      val accountName = metadata.accounts.first().accountName
      val accountNumber = metadata.accounts.first().accountNumber
      val accountType = metadata.accounts.first().accountType
      val accountSubType = metadata.accounts.first().accountSubType
      val institutionId = metadata.institutionId
      val institutionName = metadata.institutionName
    }
  )
}