CardPointe
Table of Contents:
CardPointe
Working with Plug-ins
Plastic is a plug-in for FileMaker Pro and FileMaker Server that processes secure payments within FileMaker.
Requirements
- FileMaker 19 or higher
- Windows: 10 or later
- Mac OS: Catalina or later
- Linux: Ubuntu 22 or later
Installation
If you unzip the zip archive containing the plug-in files and open the top-level directory, you will find two subdirectories labeled WIN (for Windows) and MAC (for Macintosh). The WIN directory contains two plug-in files, one with a .fmx extension and another with a .fmx64 extension. The file with the .fmx64 extension is only used for FileMaker Server installations, which are explained below. The MAC directory contains a plug-in file with a .fmplugin extension.
To install the plug-in, copy the plug-in from the WIN or MAC folder to one of the directories listed below. Directory paths are listed relative to the parent directory of the installation home directory of the FileMaker application.
FileMaker Pro
FileMaker Pro <XX>/Extensions
FileMaker Pro <XX> Advanced/Extensions
FileMaker Server Web Publishing Engine (applies to the entire Web Publishing Engine prior to FileMaker Server 12.0.2 and to Instant Web Publishing only for FileMaker Server 12.0.2 and later)
FileMaker Server/Web Publishing/publishing-engine/wpc/Plugins (create the Plugins folder if it does not exist)
FileMaker Server Custom Web Publishing (applies only to FileMaker Server 12.0.2 and later)
FileMaker Server/Web Publishing/publishing-engine/cwpc/Plugins (create the Plugins folder if it does not exist)
For 64-bit versions of Windows, be sure to use the 360Works plug-in with a .fmx64 extension
FileMaker Server Scripting Engine (applies to FileMaker Server scheduled scripts)
FileMaker Server/Database Server/Extensions
Using the plug-in with the FileMaker Server Web Publishing Engine or the FileMaker Server Scripting Engine requires an Enterprise plug-in license.
Uninstalling the plug-in
Uninstall the plug-in by quitting FileMaker Pro or stopping FileMaker Server and removing the plug-in file from the appropriate Extensions or Plugins directory.
Demo mode and registering the plug-in
Plug-ins will run in a fully featured demo mode until they are registered. While running in demo mode, the plug-in will run for 2 hours at a time. In order to get another two hours of demo time, you must restart FileMaker Pro, FileMaker Server's database server module or FileMaker Server's Web Publishing Engine, depending upon where the plug-in is installed.
To register the plug-in in FileMaker Pro, you may either enter the license information in FileMaker plug-in preferences or by calling CCRegister inside a script. You must call CCRegister inside a script in order to register the plug-in for use with FileMaker Server.
Set Variable [ $register; Value: CCRegister ( $licenseKey; $registeredToName) ]
Returns: a 1 on success or a 0 on failure.
Error Handling/Reporting
When something unexpected happens, the plug-in will pop up a dialog showing what the error message is. This makes it easy to see what went wrong. However, in some cases, you (the developer) may prefer to show your own message to the user, or possibly not show a message at all. In that case, you can call CCSetErrorCapture ( true ). This will suppress the displaying of error dialogs.
Whether or not you suppress the error dialogs, a plugin function will return the word ERROR if something goes wrong. It's a good idea to check the result of each plugin function call to determine if an error occurred. If an error occurs, use the CCLastError function to get a detailed message describing the error. For example:
Set Variable [ $result; Value: MyPluginFunction("x" ; "y" ; "z") ]
If [ $result = "ERROR" ]
Show Custom Dialog [ "An error occurred: " & CCLastError ]
End If
If a plug-in is not installed correctly, all plug-in function calls will return "?".
To check if a transaction succeeded
The simplest way to check to see if money has changed hands in a payment processing function call is to check the result of the function itself. This is extremely useful when calling functions such as CCProcessPayment and CCProfileProcessPayment. The result of the transaction will give a transaction ID or the word ERROR. Using the CCLastError like in the example above will give further information about the error, such as if there is no network connectivity, or the card was declined.
Set Variable [ $result; Value: CCProcessPayment(...) ]
If [ $result = "ERROR" ]
# Transaction is unsuccessful. Below is an example of how you might handle the error.
Set Field [ Transaction::Error Message ; CCLastError ]
Else
# Transaction is successful.
Set Field [ Transaction::Transaction ID ; $result ]
End If
More Information
For more information on how to correctly install and work with plug-ins, check out the Plugins 101 documentation.
CardPointe
CardPointe can process a wide variety of transactions, and supports ACH payments and profile-based payments. For detailed examples of each of these transactions, check the demo file included as a download with Plastic. These scripts are ready for insertion into your own solution!
Getting an account
If you do not already have a gateway or merchant account, you can sign up for a CardPointe account at this link.
You'll need an account using the CardPointe gateway, and use your Merchant API Login ID and the Merchant Transaction Key as the first two parameters, as well as your Merchant Id as an additional parameter for every plug-in function call that performs a transaction. The merchant API Login ID is provided in a welcome packet from Fiserv on sign up, and together with the transaction key provides the merchant authentication required for access to the payment gateway.
Set Variable [ $result; Value:
CCProcessPayment (
$merchantAPILoginID;
$merchantTransactionKey;
"$merchantId=" & Settings::yourMerchantID;
...) ]
Getting credentials in the gateway
Step 1: In the CardPointe console, go to Administration, Credentials, Create Credentials
Step 2: Select an account and specify a username then click 'Generate Password'
Setting the Gateway
Before calling any function in Plastic, the first required step is to set the gateway required.
Set Variable [ $gateway; Value: CCSetGateway( "cardpointe"; "cardPresent=true" ) ]
Returns: 1 if a valid gateway is provided, ERROR otherwise.
Emulators And Alternate URLs
If you would like to use Plastic to perform transactions against an alternate URL, call the CCSetGateway function with the additional parameter url, whose value would correspond to the alternate url. A gateway emulator is a common use case for an alternate URL. Gateway emulators fashion an application programming interface that resembles that of a competing gateway to ease the integration process for merchants who switch to their gateway.
Example of communicating with a gateway that provides an Authorize.Net emulator at the URL http://AlternateURLGoesHere.com
Set Variable [ $result; Value: CCSetGateway ("cardpointe" ; "url=http://AlternateURLGoesHere.com/") ]The call to CCSetGateway acts as a flag, so all subsequent transactions will point to the alternate URL until otherwise specified or FileMaker is restarted.
Working With Terminals
Listing Connected Terminals
You will need the terminal ID to process a transaction. That's often included on the Terminal itself, but Plastic also allows you to get a list of active terminals so that you can programmatically manage payment traffic. You only need to provide your API key as the merchantAccount (first) parameter. You can provide an empty string for transactionKey (second) parameter.
For the authKey, this is a separate API key provided by Fiserv.
Set Variable [ $result; Value:
CCListTerminals(
$merchantAPILoginID;
authKey;
$merchantId; ) ]
This method will return a JSON array of objects containing a terminal ID. The shape of the return JSON structure is below.
[{
"id":"c8tqau46lrsdf3d939g"
}]
Using the Terminals
Terminal use is available only with the CCProcessPayment function. When processing a transaction, you are required to provide the additional parameters of methodOfPayment and terminalID. For methodOfPayment you provide "TERMINAL" and for terminalID you'll provide the ID of the terminal you want to send the transaction to.
Set Variable [ $result; Value:
CCProcessPayment(
$merchantAPILoginID;
$merchantTransactionKey;
$chargeAmount;
$cardNumber;
$expDate;
"$merchantId="Settings::yourMerchantID;
"termid=" & Settings::yourTerminalID ) ]
Processing Payments
Basic Credit Card Charge
This simple example will run a single charge and requires you to input a card number and expiration date. To prevent this information from being saved in your database and to simplify PCI compliance, jump to the Payment Profiles section.
Once you properly configure your merchant account, you can quickly and easily process payment transactions.
You must provide the following information for a credit card payment transaction:
- merchant account name
- merchant account key
- dollar amount
- credit card number
- credit card expiration date (Format the expiration date as MMYY or MM/YY or MM/DD/YY)
- merchant ID
The CCProcessPayment function will process a transaction and return a transaction ID. This function returns a transaction ID if the transaction is successful or the word ERROR if the transaction fails. For detailed information about the most recent transaction failure, call the CCLastError function before calling any other transaction-processing function.
In your script, you would then have a second line after setting the gateway.
Set Variable [ $result; Value:
CCProcessPayment(
$merchantAPILoginID;
$merchantTransactionKey;
$chargeAmount;
$cardNumber;
$expDate;
"$merchantId="Settings::yourMerchantID) ]
Returns: a verification code from the payment gateway service if the order is successful, or ERROR if there was a problem
It is important to store the resulting transaction ID because you may need it later to void the transaction, issue a refund or capture a previously authorized transaction.
You may submit optional parameters to most of Plastic's payment-transaction processing functions. These parameters will be submitted to the payment gateway along with the basic transaction information. Although they are not usually required to process an order, these parameters can be useful for tasks such as address verification or linking a transaction to a customer id or an invoice number. To supply additional parameters to a function call, add them to the end of the parameter list after the last required parameter, using a "key=value" syntax.
Set Variable [ $result; Value:
CCProcessPayment(
$merchantAPILoginID;
$merchantTransactionKey;
$chargeAmount;
$cardNumber;
$expDate;
"$merchantId="Settings::yourMerchantID;
"company=" & Payment::company;
"email=" & Payment::email) ]
Optional Parameters
Processing ACH Payments
Plastic now supports payments via direct bank transfers and eChecks, via ACH payments. To take a payment via eCheck, use the CCProcessPaymentACH function after calling the gateway. The exact parameters that are required vary by gateway, but a typical example would look like this:
Set Variable [ $result; Value:
CCProcessPaymentACH (
$merchantAPILoginID;
$merchantTransactionKey;
$dollarAmount;
$accountNumber;
$routingNumber;
bankName;
$accountType;
$accountHolderFirstName;
$accountHolderLastName;
$checkNumber;
"achType=ARC") ]
Check the rest of the CardPointe-specific documentation for the specific parameters required for this gateway.
Returns: a verification code from the payment gateway service if the order is successful, or ERROR if there was a problem.
For ACH payments, you don't necessarily need to pass bankName, accountType, accountHolderFirstName, and accountHolderLastName. If you do not have that information, you can pass in a blank value with "";.
If taking an Account Receivable Transaction (ARC) or Back Office Conversion (BOC) payment, you must also pass in a check number. If not, simply type ""; where that checkNumber field would be.
Optional Parameters
Expand for Optional Parameters
| Parameter | Description |
|---|---|
| currency | ISO currency code for the transaction, for example "USD" |
| name | Account holder's name |
| company | Account holder's company name |
| address | Account holder's billing street address line |
| address2 | Second address line (for example, apartment or suite number) |
| city | Account holder's billing city. |
| region | Account holder's billing state, province, or region. |
| country | Account holder's billing country code (for example, "US"). |
| phone | Account holder's phone number |
| Account holder's email address | |
| postal | Account holder's billing postal or ZIP code. |
| cvv2 | Card verification value (CVV/CVC) printed on the card, used for card-not-present and 3-D Secure transactions. |
| accttype | Account type (for example, card brand like "VISA" or ACH type such as "ESAV" for savings). |
| termid | Terminal Device ID, must be exactly 8 characters long |
| orderid | Merchant’s order or invoice identifier for the transaction. |
| orderdate | For most industries, the delivery date for the order, in the format YYYYMMDD |
| invoiceid | Optional invoice ID |
| batchid | Optional batch identifier associated with the authorization for reporting and settlement. |
| batchsource | Optional source or system identifier for the batch. |
| capture | Flag indicating whether to capture the funds immediately (for example, "y" or "Y") or authorize only. |
| receipt | Flag indicating whether a receipt should be generated for the transaction. "Y" or "json" for yes, "N" for no (default) |
| tokenize | Flag indicating whether to create and return a token for the account (for example, "y" to tokenize). |
| userfields | Custom user-defined fields; either an object or array of name/value pairs for additional metadata. |
| profile | Specify as "Y" to simultaneously create a profile using the account information provided during the transaction |
| ecomind | E-commerce indicator describing how the transaction was initiated (for example, "E" for e-commerce). |
| cof | Stored credential indicator: identifies Cardholder-Initiated ("C") vs Merchant-Initiated ("M") transactions. |
| cofscheduled | Indicates whether the stored-credential transaction is a one-time or scheduled recurring payment ("Y" or "N"). |
| cofpermission | Optional flag indicating whether the account holder gave consent to store and reuse their payment credentials. |
| track | Payment card track data captured using a supported card reader device. Can be unencrypted Track 1 or Track 2 data, or encrypted swipe data (containing Track 1 and/or Track 2) data |
| bin | Specify as "Y" to return BIN lookup fields |
| auoptout | When the profile parameter is enabled, specify "Y" to opt out of signing up the profile for automatic card updates. Defaults to "N" (no) |
| signature | JSON-escaped, Base64-encoded, Gzipped, BMP of signature data (from a signature-capable terminal) |
| taxexempt | Specify as "Y" if the order is tax exempt |
| taxamnt | The tax amount for the order, either in decimal or in currency minor units (i.e. USD Pennies, MXN Centavos) |
| frtamnt | Total freight amount for the order |
| dutyamnt | Total duty amount for the order (non-US orders only) |
| discamnt | Discount amount for the order |
| shiptozip | The customer/recipient's postal code. Must be 5 or 10 digits (including hyphen) if "shiptocountry":"US"; otherwise, any alphanumeric string is accepted |
| shipfromzip | The merchant/sender's postal code. Must be 5 or 10 digits (including hyphen) if "shiptocountry":"US"; otherwise, any alphanumeric string is accepted |
| shiptocountry | The customer/recipient's country code |
| ponumber | A customer purchase order number, also referred to as the "Customer Code," which should be an identifier that the customer can use to identify the order |
| secureflag | 3-D Secure ECI value from the authentication provider, indicating authentication status. |
| securevalue | 3-D Secure CAVV or equivalent authentication value returned by the 3DS provider. |
| securedstid | 3-D Secure transaction identifier (for example, Directory Server Transaction ID). |
| secureexemption | Optional 3-D Secure exemption indicator (for example, low-risk or low-value exemptions in SCA flows). |
| items[...] | An array including one or more items, used to provide line item details for each item |
Authorizing and Capturing Payments
A sale transaction for credit card contains two parts: an authorization which verifies and places a hold for the amount, and a capture, which actually transfers the funds.
To run an authorization, pass in an additional parameter "authMode=AUTH_ONLY".
Set Variable [ $result; Value:
CCProcessPayment(
$merchantAPILoginID;
$merchantTransactionKey;
$chargeAmount;
$cardNumber;
$expDate;
"authMode=AUTH_ONLY") ]
Returns: a verification code from CardPointe if the order is successful, or ERROR if there was a problem
After running an authorization, run the appropriate CCProcessAuthorizedPayment. Pass in the previousTransactionId from the transaction ID you received from the process with authMode.
Set Variable [ $result; Value:
CCProcessAuthorizedPayment(
$merchantAPILoginID;
$merchantTransactionKey;
$previousTransactionId;
$dollarAmount;
"$merchantId=Settings::yourMerchantID") ]
The dollarAmount parameter is not required to process the authorized payment. CCProcessAuthorizedPayment accepts the same optional parameters as CCProcessPayment.
Using Card Readers
Certain types of merchant accounts are set up for reading physical card swipes, instead of taking orders via the web or over the phone. If your account is a card-present account, like a retail store, then you will need to also send the data included on the magnetic stripe of a card.
You should pass in swipe data if you have it, as your transaction may be downgraded to a more expensive rate if you simply type a card number.
First, set the gateway with card-present parameter
To process a card-present transaction, first call CCSetGateway with the parameter cardPresent=true. If CCSetGateway returns a 1, then you can perform a card-present transaction.
Second, determine your Track 1 and 2 formats
To process a payment using card-present accounts, you'll need the information in the magnetic stripe of the credit card. In Plastic, this information may be obtained from a keyboard-emulating card reader, which essentially dumps text into a text field when the card is swiped as if the text had been entered via a keyboard.
While some card readers will contain software that parses that raw data from the magnetic stripe before dumping it to a field, this documentation refers to those keyboard-emulating readers that dump raw data. Raw swipe data contains two delimited pieces of information: Track 1 and Track 2.
Raw data would look something like this:
%B1234123412341234^LAST/FIRSTM^1112101000000000011100111000000?;1234123412341234=11121010000000000111?
Track 1 is delimited by a percent symbol and a question mark, so in the previous example Track 1 would be:
%B1234123412341234^LAST/FIRST/^1112101000000000011100111000000?
Track 2 is delimited by a semicolon and question mark, so in the previous example Track 2 would be:
;1234123412341234=11121010000000000111?
As a convenience, the Plastic function CCTrackData will parse either Track 1 or Track 2 data as a return-separated string containing account code, cardholder name, expiration date (YYMM), and optional discretionary data.
Process the payment with CCProcessPayment
Finally, call CCProcessPayment and pass in raw swipe or track data. When processing a card-present transaction, a gateway will typically require you to pass in either the full raw swipe, Track 1 or Track 2. In most cases, you do not need to pass in card numbers and expiration dates.
Set Variable [ $result; Value:
CCProcessPayment(
$merchantAPILoginID;
$merchantTransactionKey;
$dollarAmount;
"";
"";
"$merchantId="Settings::yourMerchantID;
"track1=%B1234123412341234^LAST/FIRST/^1112101000000000011100111000000?") ]
Voiding Transactions
Set Variable [ $result; Value:
CCVoidPayment (
$merchantAPILoginID;
$merchantTransactionKey;
$previousTransactionID) ]
Voids a previously processed payment. The parameters are similar to the CCProcessPayment function, except dollarAmount is replaced with the addition of the previousTransactionID parameter. The previousTransactionID should be the transactionID of the transaction you wish to void. This value is returned by the CCProcessPayment function. Alternately, you can use the CCLastPaymentTransactionID function to get the transactionID of the last processed payment.
Parameters:
- merchantAPILoginID
- Your payment gateway merchant account name. In the case of CardPointe, this is merchantAPILoginID.
- merchantTransactionKey
- Your merchant account password OR transaction key. In the case of CardPointe, this is merchantTransactionKey.
- previousTransactionID
- The
transactionIdof a previously processed transaction.
- The
Note that CCVoidPayment will only work on orders that have not settled yet, which means that it will generally only work on payments made that same day. To void settled orders, use CCRefund instead.
Returns: the transactionID from the payment gateway service if the order is successful, or ERROR if there was a problem.
See also: CCLastPaymentTransactionID: the transactionID from the payment gateway service if the order is successful, or ERROR if there was a problem (use CCLastError for more detailed information about the nature of the error).
Crediting or Refunding Transactions
To credit a transaction, you need the transaction ID returned by CCProcessPayment. Pass this (along with other payment info) to the CCRefund function. This is similar to the void process, except it accepts a dollar amount and the credit card number (or the last four digits of the credit card number) used to process the original transaction.
Set Variable [ $result; Value:
CCRefund(
$merchantAPILoginID;
$merchantTransactionKey;
$transactionID;
$cardNumber;
$dollarAmount) ]
Returns: the transactionID from CardPointe if the order is successful, or ERROR if there was a problem
Unlinked Credits
You can also use CCRefund to do an unlinked credit, which will run a refund of the amount without requiring a transaction ID. Pass in a blank value ""; for the previous transaction ID and a negative amount for the chargeAmount to perform this type of transaction.
In order to perform these credits using CardPointe, a merchant account must have Force Credit enabled. Merchants should contact their CardPointe customer support representative for more information.
- Card Present Unlinked Refund
-
Set Variable [ $result; Value:
CCRefund(
$merchantAPILoginID;
$merchantTransactionKey;
"";
$cardNumber;
$chargeAmount;
"expirationDate=12/13") ]
-
Payment Profiles
Customer Profiles
Plastic features customer profiles, which allow you to submit customer and payment information to be reused for future transactions. This greatly simplifies PCI compliance, and keeps sensitive information out of your database. To get started, first you'll need to create a customer in the system. This will return an ID that you can then store. After that, attach a payment method to this newly created customer. This will return a payment ID, which together with the customer profile ID, you can run charges against.
To create a customer in the system, set the following:
Set Variable [ $customerID; Value:
CCProfileCreateCustomer (
$merchantAPILoginID;
$merchantTransactionKey;
$customerId) ]
Returns: the customer profile ID used to reference the newly created profile if successful, or ERROR if there was a problem
Note: If you provide an empty string to customerId, the gateway will generate and return one.
After creating a customer, it can also be updated, deleted, or retrieved. Retrieving a customer will return the information the gateway has saved about the customer.
| CCProfileUpdateCustomer | CCProfileDeleteCustomer | CCProfileGetCustomer |
|---|---|---|
| merchantAPILoginID | merchantAPILoginID | merchantAPILoginID |
| merchantTransactionKey | merchantTransactionKey | merchantTransactionKey |
| customerId | customerProfileId | customerProfileId |
| customerProfileId |
Returns: 1 if successful, or ERROR if there was a problem
When retrieving information about a profile with CCProfileGetCustomer, CCProfileGetShipping, or CCProfileGetPayment, the response will return a list of values marked with a dollar sign, like so:
$billingFirstName="First";$billingLastName="Name";$billingCompany="";
To parse out these values, you can use a combination of the Evaluate and Let functions. After seeing a response from CardPointe, note the value you want to parse, such as $billingLastName in the example above. Then you can use the formula:
Evaluate ( "Let( [" & Transaction::Response Message& "] ; $billingLastName)")
This will return the last name of the profile requested.
For CardPointe, leave customerId blank for CCProfileCreateCustomer. CardPointe will generate and return a number UUID for the customer profile id
Creating Payment Profiles
Payment profiles allow you to save payment information straight to the gateway for future use. To create a payment profile, call either CCProfileCreatePayment or CCProfileCreatePaymentACH, depending on whether the payment profile is a credit card or ACH. Credit cards are created with CCProfileCreatePayment and updated with CCProfileUpdatePayment.
| CCProfileCreatePayment | CCProfileUpdatePayment |
|---|---|
| customerProfileId | customerProfileId |
| cardNumber | paymentProfileId |
| expirationDate | cardNumber |
| $merchantId | expirationDate |
| $merchantId |
Returns: CCProfileCreatePayment or CCProfileCreatePaymentACH returns the payment profile ID used to reference the newly created profile if successful, or ERROR if there was a problem.
Returns: CCProfileUpdatePayment returns a 1 on success, or ERROR if there was a problem.
After creation, payments can be retrieved with CCProfileGetPayment. Certain gateways can validate a payment with CCProfileValidatePayment. Payments can be deleted with CCProfileDeletePayment.
| CCProfileGetPayment | CCProfileValidatePayment | CCProfileDeletePayment |
|---|---|---|
| customerProfileId | customerProfileId | customerProfileId |
| paymentProfileId | paymentProfileId | paymentProfileId |
| $merchantId | $merchantId | $merchantId |
Returns: CCProfileValidatePayment and CCProfileDeletePayment return a 1 on success, or ERROR if there was a problem.
For CardPointe, creating and updating payments accept the following:
Optional Parameters
Expand for Optional Parameters
| Parameter | Description |
|---|---|
| cofpermission | Optional flag indicating whether the account holder gave consent to store and reuse their payment credentials. |
| auoptout | Specify "Y" to opt out of signing up the profile for automatic card updates. Defaults to "N" (no) |
| address | Account holder's billing street address line |
| city | Account holder's billing city. |
| region | Account holder's billing state, province, or region. |
| country | Account holder's billing country code (for example, "US"). |
| phone | Account holder's phone number |
| Account holder's email address | |
| postal | Account holder's billing postal or ZIP code. |
| company | Account holder's company name |
ACH payments are added and updated in much the same way as a credit card. Italicized items are optional, and can accept "" if not needed. ACH payments can use the same CCProfileGetPayment, CCProfileValidatePayment, and CCProfileDeletePayment as above.
| CCProfileCreatePaymentACH | CCProfileUpdatePaymentACH |
|---|---|
| merchantAPILoginID | merchantAPILoginID |
| merchantTransactionKey | merchantTransactionKey |
| customerProfileId | customerProfileId |
| accountNumber | paymentProfileId |
| routingNumber | accountNumber |
| bankName | routingNumber |
| accountType | bankName |
| accountHolderFirstName | accountType |
| accountHolderLastName | accountHolderFirstName |
| $merchantId | $merchantId |
Running Charges Against Profiles
You can process a payment, authorize a payment, capture an authorized payment, void, and refund transactions. Please note that for unlinked credits with CCProfileRefund, do not pass in an accountNumber or routingNumber.
If you want to run authorize only transactions, use CCProfileProcessPayment and add "authMode=AUTH_ONLY" to the list of parameters. To then capture that transaction, run CCProfileProcessAuthorizedPayment. Italicized items are optional, and can accept "" if not needed.
| CCProfileProcessPayment | CCProfileProcessAuthorizedPayment | CCProfileRefund | CCProfileVoidPayment |
|---|---|---|---|
| merchantAPILoginID | merchantAPILoginID | merchantAPILoginID | merchantAPILoginID |
| merchantTransactionKey | merchantTransactionKey | merchantTransactionKey | merchantTransactionKey |
| customerProfileId | customerProfileId | customerProfileId | customerProfileId |
| paymentProfileId | paymentProfileId | paymentProfileId | paymentProfileId |
| dollarAmount | previousTransactionId | previousTransactionId | previousTransactionId |
| shippingProfileId | dollarAmount | amountToCredit | |
| authMode | shippingProfileId | accountNumber - you can pass in only the last four digits preceded by XXXX | |
| verificationCode | verificationCode | routingNumber | |
| invoiceNumber | splitTenderId | invoiceNumber | |
| poNumber | poNumber | ||
| chargeDescription | chargeDescription | ||
| isPartialAuthorization | |||
| splitTenderId |
Getting Response Information and Using Helper Functions
Plastic includes a number of helper functions that allow users to retrieve data from the gateway or Plastic.
To execute any of these functions inside a script, use a Set Field or Set Variable script step.
- CCGetCardIssuer
- Format:
CCGetCardIssuer( $cardNumber ) - Description: Returns the card issuer for a given card number, either: VISA, MASTERCARD, AMEX, DINERS, DISCOVER, JCB. Returns an error if the card number is from another issuer.
- Format:
- CCGetLast
- Format:
CCGetLast ( $name ) - Description: Returns a value from the most recent transaction response that corresponds with the name parameter.
- Format:
- CCLastAVS
- Description: Returns the gateway's Address Verification System Response for the last payment which was processed. This response is typically a one letter indicator, meaning the following:
| Code | Description | Network |
|---|---|---|
| A | Street address matches, but 5-digit and 9-digit postal code do not match. | Standard domestic |
| B | Street address matches, but postal code not verified. | Standard international |
| C | Street address and postal code do not match. | Standard international |
| D | Street address and postal code match. Code "M" is equivalent. | Standard international |
| E | AVS data is invalid or AVS is not allowed for this card type. | Standard domestic |
| G | Non-U.S. issuing bank does not support AVS. | Standard international |
| I | Address not verified. | Standard international |
| M | Street address and postal code match. Code "D" is equivalent. | Standard international |
| N | Street address and postal code do not match. | Standard domestic |
| P | Postal code matches, but street address not verified. | Standard international |
| R | System unavailable. | Standard domestic |
| S | Bank does not support AVS. | Standard domestic |
| U | Address information unavailable. Returned if the U.S. bank does not support non-U.S. AVS or if the AVS in a U.S. bank is not functioning properly. | Standard domestic |
| W | Street address does not match, but 9-digit postal code matches. | Standard domestic |
| X | Street address and 9-digit postal code match. | Standard domestic |
| Y | Street address and 5-digit postal code match. | Standard domestic |
| Z | Street address does not match, but 5-digit postal code matches. | Standard domestic |
- CCLastCCV
- Description: Returns the gateway's Card Code Verification Response for the last payment which was processed. This response is typically a one letter indicator, meaning the following:
- M - CVV2/CVC2 Match - Indicates that the card is authentic. Complete the transaction if the authorization request was approved.
- N - CVV2 / CVC2 No Match - May indicate a problem with the card. Contact the cardholder to verify the CVV2 code before completing the transaction, even if the authorization request was approved.
- P - Not Processed - Indicates that the expiration date was not provided with the request, or that the card does not have a valid CVV2 code. If the expiration date was not included with the request, resubmit the request with the expiration date.
- S - Merchant Has Indicated that CVV2 / CVC2 is not present on card - May indicate a problem with the card. Contact the cardholder to verify the CVV2 code before completing the transaction.
- U - Issuer is not certified and/or has not provided visa encryption keys
- Description: Returns the gateway's Card Code Verification Response for the last payment which was processed. This response is typically a one letter indicator, meaning the following:
- CCLastChargeResult
- Description: Returns the gateway's result code for the last operation.
- CCLastPaymentAuthCode
- Description: Returns the gateway's approval code for the last payment which was processed with
CCProcessPayment.
- Description: Returns the gateway's approval code for the last payment which was processed with
- CCLastPaymentTransactionID
- Description: Returns the gateway's transaction ID for the last payment which was processed with
CCProcessPayment.
- Description: Returns the gateway's transaction ID for the last payment which was processed with
- CCLastRawResponse
- Description: Returns the gateway's raw text response for the most recent transaction.
- CCValidateCardNumber
- Format:
CCValidateCardNumber( $cardNumber ) - Description: Determines if a card number is valid. Does not indicate the validity of the card itself, only its number. Returns either a 1 for valid card, or 0 for invalid cards.
- Format:
- CCLastError
- Description: Returns the text of the last error triggered by a plugin function.
- CCLicenseInfo
- Description: Returns information about the license used.
- CCVersion
- Description: Returns the version of the credit card plugin which is installed.
Getting Help
If you still need help, there are several resources available! FMForums hosts a support forum for 360Works products. Please look through the posts and see if your question has been posted before making a new topic.
Support is also available via email at support@360works.com. You can also call us at 770-234-9293. We offer many services in addition to our plug-ins, so let us know if you'd like a little help integrating the plug-in into your solution. If you'd be interested in a customized plug-in or development, please let us know! We have many certified FileMaker developers on staff who can help you with your project.