@spec authorize(Gringotts.Money.t(), Gringotts.CreditCard.t(), keyword()) ::
  {:ok | :error, Gringotts.Response.t()}

Performs a (pre) Authorize operation.

The authorization validates the card details with the banking network, places a hold on the transaction amount in the customer’s issuing bank and also triggers risk management. Funds are not transferred.

When followed up with a capture/3 transaction, funds will be transferred to the merchant's account upon settlement.

CAMS returns a Transaction ID (available in the Response.authorization field) which can be used later to:

• capture/3 an amount.
• void/2 an authorized transaction.

optional-fields

Optional Fields

options[
  order_id: String,
  description: String
]

examples

Examples

The following example shows how one would (pre) authorize a payment of $20 on a sample card.

iex> card = %CreditCard{first_name: "Harry",
                        last_name: "Potter",
                        number: "4111111111111111",
                        year: 2099,
                        month: 12,
                        verification_code: "999",
                        brand: "VISA"}
iex> money = Money.new(20, :USD)
iex> {:ok, auth_result} = Gringotts.authorize(Gringotts.Gateways.Cams, money, card)

@spec capture(Gringotts.Money.t(), String.t(), keyword()) ::
  {:ok | :error, Gringotts.Response.t()}

Captures a pre-authorized amount.

Captures can be submitted for an amount equal to or less than the originally authorized amount in an authorize/3ation referenced by transaction_id.

Partial captures are allowed, and the remaining amount is released back to the payment source (video).

Multiple, partial captures on the same authorization token are not supported.

CAMS returns a Transaction ID (available in the Response.authorization field) which can be used later to:

• refund/3
• void/2 (only before settlements!)

examples

Examples

The following example shows how one would (partially) capture a previously authorized a payment worth $10 by referencing the obtained authorization id.

iex> card = %CreditCard{first_name: "Harry",
                        last_name: "Potter",
                        number: "4111111111111111",
                        year: 2099,
                        month: 12,
                        verification_code: "999",
                        brand: "VISA"}
iex> money = Money.new(10, :USD)
iex> authorization = auth_result.authorization
# authorization = "some_authorization_transaction_id"
iex> {:ok, capture_result} = Gringotts.capture(Gringotts.Gateways.Cams, money, authorization)

@spec purchase(Gringotts.Money.t(), Gringotts.CreditCard.t(), keyword()) ::
  {:ok | :error, Gringotts.Response.t()}

Transfers amount from the customer to the merchant.

CAMS attempts to process a purchase on behalf of the customer, by debiting amount from the customer's account by charging the customer's card.

Returns a Transaction ID (available in the Response.authorization field) which can be used later to:

• refund/3
• void/2 (only before settlements!)

examples

Examples

The following example shows how one would process a payment worth $20 in one-shot, without (pre) authorization.

iex> card = %CreditCard{first_name: "Harry",
                        last_name: "Potter",
                        number: "4111111111111111",
                        year: 2099,
                        month: 12,
                        verification_code: "999",
                        brand: "VISA"}
iex> money = Money.new(20, :USD)
iex> Gringotts.purchase(Gringotts.Gateways.Cams, money, card)

@spec refund(Gringotts.Money.t(), String.t(), keyword()) ::
  {:ok | :error, Gringotts.Response.t()}

Refunds the amount to the customer's account with reference to a prior transfer.

It's better to void/2 a transaction if it has not been settled yet! Refunds lead to to two entries on the customer's bank statement, one for the original purchase/3 or capture/3 and another for the refund/3.

Multiple, partial refunds on the same Transaction ID are allowed till all the captured amount is refunded.

examples

Examples

The following example shows how one would completely refund a previous capture (and similarily for purchases).

iex> capture_id = capture_result.authorization
# capture_id = "some_capture_transaction_id"
iex> money = Money.new(20, :USD)
iex> Gringotts.refund(Gringotts.Gateways.Cams, money, capture_id)

@spec validate(
  Gringotts.CreditCard.t(),
  keyword()
) :: {:ok | :error, Gringotts.Response.t()}

Validates the card

Verifies the credit card without authorizing any amount.

examples

Examples

iex> card = %CreditCard{first_name: "Harry",
                        last_name: "Potter",
                        number: "4111111111111111",
                        year: 2099,
                        month: 12,
                        verification_code: "999",
                        brand: "VISA"}
iex> Gringotts.validate(Gringotts.Gateways.Cams, card)

Catches gateway configuration errors.

Raises a run-time ArgumentError if any of the required_config values is not available or missing from the Application config.

@spec void(
  String.t(),
  keyword()
) :: {:ok | :error, Gringotts.Response.t()}

Voids the referenced payment.

Cancel a transaction referenced by transaction_id that is not settled yet. This will erase any entries from the customer's bank statement.

authorize/3 can be void/2ed to prevent captures.

examples

Examples

The following example shows how one would void a previous (pre) authorization.

iex> auth_id = auth_result.id
# auth_id = "aome_authorisation_transaction_id"
iex> Gringotts.void(Gringotts.Gateways.Cams, auth_id)