API Referencia
undefined

Transacción Completa

Una Transacción Completa permite al comercio presentar al tarjetahabiente un formulario propio para almacenar los datos de la tarjeta, fecha de vencimiento y cvv (no necesario para comercios con la opción sin cvv habilitada).

Transacción Completa

Crear una transacción

Esta operación te permite iniciar o crear una transacción, Transbank procesa el requerimiento y entrega como resultado de la operación el token de la transacción.

import cl.transbank.transaccioncompleta.FullTransaction;

String buyOrder = "Orden de compra de la transaccion";
String sessionId = "Identificador del servicio unico de transacción";
double amount = 10000; // mongo en pesos
String cardNumber= "Numero de Tarjeta";
String cardExpirationDate= "Fecha de expiracion en formato AA/MM";
short cvv = 123; // CVV de la tarjeta.

FullTransactionCreateResponse response = FullTransaction.Transaction.create(buyOrder, sessionId, amount, cardNumber, cardExpirationDate, cvv);
use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$response = $transaction->create(
  $buy_order,                       // ordenCompra12345678
  $session_id,                      // sesion1234564
  $amount,                          // 10000
  $cvv,                             // 123
  $card_number,                     // 4239000000000000
  $card_expiration_date             // AA/MM - 22/10
);
using Transbank.Webpay.TransaccionCompleta;

var buy_order = "Orden de compra de la transaccion";
var session_id = "Identificador del servicio unico de transacción";
var amount = 10000; // monto en pesos
var card_number = "Numero de Tarjeta";
var card_expiration_date = "Fecha de expiracion en formato AA/MM";
var cvv = 123; // CVV de la tarjeta.

var response = FullTransaction.Create(
                buyOrder: buy_order,
                sessionId: session_id,
                amount: amount,
                cvv: cvv,
                cardNumber: card_number,
                cardExpirationDate: card_expiration_date);
buy_order = "Orden de compra de la transaccion"
session_id = "Identificador del servicio unico de transacción"
amount = 1000 /* monto en pesos */
card_number = "Numero de Tarjeta"
card_expiration_date = "Fecha de expiracion en formato AA/MM"
cvv = 123 /* CVV de la tarjeta. */

response = Transbank::TransaccionCompleta::Transaction::create(
                                                            buy_order: buy_order,
                                                            session_id: session_id,
                                                            amount: amount,
                                                            card_number: card_number,
                                                            cvv: cvv,
                                                            card_expiration_date: card_expiration_date
                                                            )
from transbank.transaccion_completa.transaction import Transaction

# leyendo variables desde un formulario
buy_order = 'Orden de compra de la transaccion '
session_id = 'Identificador del servicio unico de transacción'
amount = 10000; #monto en pesos
card_number = 'Numero de Tarjeta'
cvv = 123 #CVV de la tarjeta.
card_expiration_date = 'Fecha de expiracion en formato AA/MM'

resp = Transaction.create(
    buy_order=buy_order, session_id=session_id, amount=amount,
    card_number=card_number, cvv=cvv, card_expiration_date=card_expiration_date
)
const TransaccionCompleta = require('transbank-sdk').TransaccionCompleta; // CommonJS
import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules

const buyOrder = 'Orden de compra de la transaccion';
const sessionId = 'Identificador del servicio unico de transacción';
const amount = 10000; // Monto en CLP
const cardNumber = 'Numero de Tarjeta';
const cvv = 123; // CVV de la tarjeta, parametro opcional si tu código de comercio es sin CVV, en cuyo caso debes enviar null o undefined
const cardExpirationDate = '21/12'; // Fecha de expiración en formato AA/MM

const response = await TransaccionCompleta.Transaction.create(
  buyOrder, sessionId, amount, cvv, cardNumber, cardExpirationDate
);

Respuesta Transaction.create

response.getToken();
$response->getToken();
response.Token;
response.token
response.token
response.token

Consulta de cuotas

Antes de confirmar una transaccion es necesario confirmar la cantidad de cuotas y entregar el valor de estas.

import cl.transbank.transaccioncompleta.FullTransaction;

String token = "token obtenido como respuesta de la creacion de transaccion";
int installmentsNumber = 10; // numero de cuotas;

FullTransactionInstallmentResponse response = FullTransaction.Transaction.installment(
  token,
  installmentsNumber
);
use Transbank\TransaccionCompleta\Transaction;

$token = "token obtenido como respuesta de la creacion de transaccion";
$installmentsNumber = 10; // numero de cuotas;

$transaction = new Transaction();
$response = $transaction->installments(
    $token,
    $installmentsNumber
);
using Transbank.Webpay.TransaccionCompleta;

var token = "token obtenido como respuesta de la creacion de transaccion";
var installments_number = 10; // numero de cuotas;

var response = FullTransaction.Installments(
  token: token,
  installmentsNumber: installments_number
  );
token = "token obtenido como respuesta de la creacion de transaccion"
installments_number = 10 /* numero de cuotas */

response = Transbank::TransaccionCompleta::Transaction::installments( token: token,
                                                                      installments_number: installments_number )
from transbank.transaccion_completa.transaction import Transaction

#obtener form desde el request
    req = request.form
    token = request.form.get('token') #token obtenido al iniciar la transaccion
    installments_number = 10 #numero de cuotas
    resp = Transaction.installments(token=token, installments_number=installments_number)
const TransaccionCompleta = require('transbank-sdk').TransaccionCompleta; // CommonJS
import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules

const installmentsNumber = 10; // Número de Cuotas
const response = await TransaccionCompleta.Transaction.installments(token, installmentsNumber);

Respuesta consulta de cuotas

response.getInstallmentsAmount();
response.getIdQueryInstallments();
DeferredPeriod deferredPeriod = response.getDeferredPeriods()[0];
deferredPeriod.getAmount();
deferredPeriod.getPeriod();
$response->getInstallmentsAmount();
$response->getIdQueryInstallments();
$response->getDeferredPeriods();
response.InstallmentsAmount;
respone.IdQueryInstallments;
response.DeferredPeriods;
response.installments_amount
response.id_query_installments
response.deferred_periods
response.installments_amount
response.id_query_installments
response.deferred_periods
response.installments_amount
response.id_query_installments
response.deferred_periods

Si el comercio no tiene configurado periodos diferidos, la respuesta de deferred_periods será []:

Confirmar una transacción

Una vez obtenido la respuesta de la consulta de cuotas, con los datos de esta se puede realizar la confirmación de la transaccion utilizando el metodo commit

import cl.transbank.transaccioncompleta.FullTransaction;


String token = "token obtenido como respuesta de la creacion de transaccion";
int idQueryInstallments = 12345679; // numero identificador de las cuotas.
byte deferredPeriodIndex= 1;
Boolean gracePeriod = false;

FullTransactionCommitResponse response = FullTransaction.Transaction.commit(
  token,
  idQueryInstallments,
  deferredPeriodIndex,
  gracePeriod
);
use Transbank\TransaccionCompleta\Transaction;

$token = "token obtenido como respuesta de la creacion de transaccion";
$idQueryInstallments = 12345679; // numero identificador de las cuotas.
$deferredPeriodIndex= 1;
$gracePeriod = false;

$transaction = new Transaction();
$response = $transaction->commit(
    $token,
    $idQueryInstallments,
    $deferredPeriodIndex,
    $gracePeriod
);
using Transbank.Webpay.TransaccionCompleta;

var token = "token obtenido como respuesta de la creacion de transaccion";
var idQueryInstallments = 12345679; // numero identificador de las cuotas.
var deferredPeriodsIndex = 1;
var gracePeriods = false;

var result = FullTransaction.Commit(
  token:token,
  idQueryInstallments: idQueryInstallments,
  deferredPeriodsIndex: deferredPeriodsIndex,
  gracePeriods: gracePeriods
);
token = "token obtenido como respuesta de la creacion de transaccion"
id_query_installments = 12345679 # numero identificador de las cuotas.
deferred_period_index = 1
grace_period = false

response = Transbank::TransaccionCompleta::Transaction::commit(
  token: token,
  id_query_installments: id_query_installments,
  deferred_period_index:deferred_period_index,
  grace_period: grace_period
)
from transbank.transaccion_completa.transaction import Transaction

#token obtenido como respuesta de la creacion de transaccion
token = "token obtenido como respuesta de la creacion de transaccion"
id_query_installments = 12345679 # numero identificador de las cuotas.
deferred_period_index = 1
grace_period = 'false'

response = Transaction.commit(token=token,
                          id_query_installments=id_query_installments,
                          deferred_period_index=deferred_period_index,
                          grace_period=grace_period)
const TransaccionCompleta = require('transbank-sdk').TransaccionCompleta; // CommonJS
import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules

const token = "token obtenido como respuesta de la creacion de transaccion";
const idQueryInstallments = 123456789 // Número identificador de las cuotas
const deferredPeriodIndex = 1;
const gracePeriod = false;

const response = await TransaccionCompleta.Transaction.commit(
  token, idQueryInstallments, deferredPeriodIndex, gracePeriod
);

Respuesta confirmación

response.getAccountingDate();
response.getAmount();
response.getAuthorizationCode();
response.getBuyOrder();
CardDetail cardDetail = response.getCardDetail();
cardDetail.getCardNumber();
response.getInstallmentsAmount();
response.getInstallmentsNumber();
response.getPaymentCodeType();
response.getResponseCode();
response.getSessionId();
response.getTransactionDate();
$response->getAccountingDate();
$response->getAmount();
$response->getAuthorizationCode();
$response->getBuyOrder();
$cardDetail = $response->getCardDetail();
$cardDetail->getCardNumber();
$response->getInstallmentsAmount();
$response->getInstallmentsNumber();
$response->getPaymentCodeType();
$response->getResponseCode();
$response->getSessionId();
$response->getTransactionDate();
response.AccountingDate;
response.Amount;
response.AuthorizationCoda;
response.BuyOrder;
var cardDetail = response.CardDetail;
cardDetail.CardNumber;
response.InstallmentsAmount;
response.InstallmentsNumber;
response.PaymentTypeCode;
response.ResponseCode;
response.SessionId;
response.Status;
response.TransactionDate;
response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance
response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance
response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance

Obtener estado de una transacción

Esta operación permite obtener el estado de la transacción en cualquier momento. En condiciones normales es probable que no se requiera ejecutar, pero en caso de ocurrir un error inesperado permite conocer el estado y tomar las acciones que correspondan.

Este método puede ser invocado los 7 días siguientes luego de realizada la transacción. Después de esto no será posible.

import cl.transbank.transaccioncompleta.FullTransaction;

final FullTransactionStatusResponse response = FullTransaction.Transaction.status(token);
use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$transaction->status($token_ws);
using Transbank.Webpay.TransaccionCompleta;

FullTransaction.Status(token);
Transbank::TransaccionCompleta::Transaction::status(token: token)
from transbank.transaccion_completa.transaction import Transaction

Transaction.status(token=token)
const TransaccionCompleta = require('transbank-sdk').TransaccionCompleta; // CommonJS
import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules

const response = await TransaccionCompleta.Transaction.status(token);

Respuesta estado

response.getAccountingDate();
response.getAmount();
response.getAuthorizationCode();
response.getBuyOrder();
CardDetail cardDetail = response.getCardDetail();
cardDetail.getCardNumber();
response.getInstallmentsAmount();
response.getInstallmentsNumber();
response.getPaymentCodeType();
response.getResponseCode();
response.getSessionId();
response.getTransactionDate();
$response->getAccountingDate();
$response->getAmount();
$response->getAuthorizationCode();
$response->getBuyOrder();
$cardDetail = $response->getCardDetail();
$cardDetail->getCardNumber();
$response->getInstallmentsAmount();
$response->getInstallmentsNumber();
$response->getPaymentCodeType();
$response->getResponseCode();
$response->getSessionId();
$response->getTransactionDate();
response.AccountingDate;
response.Amount;
response.AuthorizationCoda;
response.BuyOrder;
var cardDetail = response.CardDetail;
cardDetail.CardNumber;
response.InstallmentsAmount;
response.InstallmentsNumber;
response.PaymentTypeCode;
response.ResponseCode;
response.SessionId;
response.Status;
response.TransactionDate;
response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance
response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance
response.amount
response.status
response.buy_order
response.session_id
response.card_number
response.accounting_date
response.transaction_date
response.authorization_code
response.payment_type_code
response.response_code
response.installments_number
response.installments_amount
response.balance

Reversar o anular una transacción

Este método permite a todo comercio habilitado reversar o anular una transacción completa. El método permite generar el reembolso del total o parte del monto de una transacción dependiendo de la siguiente lógica de negocio la invocación a esta operación generará una reversa o una anulación:

  • Si el monto enviado es menor al monto total entonces se ejecutará una anulación parcial.
  • Si el monto enviado es igual al total, entonces se evaluará una anulación o reversa. Será reversa si el tiempo para ejecutarla no ha terminado, de lo contrario se ejecutará una anulación.

La anulación puede realizarse máximo 90 días después de la fecha de la transacción original.

Para anular una transacción se debe invocar al método Transaction.refund().

Permite generar el reembolso del total o parte del monto de una transacción completa. Dependiendo de la siguiente lógica de negocio la invocación a esta operación generará una reversa o una anulación:

  • Si se especifica un valor en el campo “amount” se ejecutará siempre una anulación.
  • Si se supera el tiempo máximo para ejecutar una reversa se ejecutará una anulación.
  • Si no se ha dado ninguno de los casos anteriores se ejecutará una reversa.
import cl.transbank.transaccioncompleta.FullTransaction;

final FullTransactionRefundResponse response = FullTransaction.Transaction.refund(token,amount);
use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$transaction->refund($token, $amount);
using Transbank.Webpay.TransaccionCompleta;

FullTransaction.Refund(token, amount);
Transbank::TransaccionCompleta::Transaction::refund(token: token, amount: amount)
from transbank.transaccion_completa.transaction import Transaction

Transaction.refund(token=token, amount=amount)
const TransaccionCompleta = require('transbank-sdk').TransaccionCompleta; // CommonJS
import { TransaccionCompleta } from 'transbank-sdk'; // ES6 Modules

const response = await TransaccionCompleta.Transaction.refund(token, amount);

Respuesta reembolso

response.getType();
response.getAuthorizationCode();
response.getAuthorizationDate();
response.getNullifiedAmount();
response.getBalance();
response.getResponse();
$response->getType();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getNullifiedAmount();
$response->getBalance();
$response->getResponse();
response.AuthorizationCode;
response.AuthorizationDate;
response.Balance;
response.NullifiedAmount;
response.ResponseCode;
response.Type;
response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code
response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code
response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code

Captura diferida Transacción completa

Este método permite a todo comercio habilitado realizar capturas de una transacción autorizada sin captura generada en Transacción Completa. El método contempla una única captura por cada autorización. Para ello se deberá indicar los datos asociados a la transacción de venta con autorización sin captura y el monto requerido para capturar el cual debe ser menor o igual al monto originalmente autorizado.

Para capturar una transacción, ésta debe haber sido creada por un código de comercio configurado para captura diferida. De esa forma la transacción estará autorizada pero requerirá una captura explícita posterior para confirmar la transacción.

Puedes leer más sobre la captura en la información del producto Webpay para conocer más detalles y restricciones.

// Aun no está disponible en este SDK
// Aun no está disponible en este SDK
// Aun no está disponible en este SDK
Transbank::TransaccionCompleta::Transaction.capture(
  token: token,
  buy_order: buy_order,
  authorization_code: authorization_code,
  capture_amount: capture_amount
)
# Aun no está disponible en este SDK
const response = TransaccionCompleta.DeferredTransaction.capture(
  token, buyOrder, authorizationCode, amount
);

Respuesta captura

// Aun no está disponible en este SDK
// Aun no está disponible en este SDK
// Aun no está disponible en este SDK
# Aun no está disponible en este SDK
# Aun no está disponible en este SDK
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

Transaccción Completa Mall

Una transacción Mall corresponde a una solicitud de autorización financiera de un conjunto de pagos con tarjetas de crédito, en donde quién realiza el pago ingresa al sitio del comercio, selecciona productos o servicios, y el ingreso asociado a los datos de la tarjeta de crédito lo realiza una única vez para el conjunto de pagos. Cada pago tendrá su propio resultado, autorizado o rechazado.

Desagregación de un pago Mall

Es la tienda Mall la que agrupa múltiples tiendas, son estas últimas las que pueden generar transacciones. Tanto el mall como las tiendas asociadas son identificadas a través de un número denominado código de comercio.

Flujo

El flujo de Transaccion Completa Mall es en general el mismo que el de Transaccion Completa tanto de cara al tarjeta habiente como de cara al integrador.

Las diferencias son:

  • Se debe usar un código de comercio configurado para modalidad Mall en Transbank, el cual debe ser indicado al iniciar la transacción.
  • Se pueden indicar múltiples transacciones, cada una asociada a un código de comercio de tienda (que debe estar configurada en Transbank como perteneciente al mall).
  • Se debe verificar por separado el resultado de cada una de esas transacciones individualmente, pues es posible que el emisor de la tarjeta autorice algunas y otras no.

Crear una transacción mall

Esta operación te permite iniciar o crear varias transacciones de una sola vez, Transbank procesa el requerimiento y entrega como resultado de la operación el token de la transacción.

MallTransactionCreateDetails transactionDetails = MallTransactionCreateDetails.build()
  .add(amountMallOne, commerceCodeMallOne, buyOrderMallOne, installmentsNumberMallOne)
  .add(amountMallTwo, commerceCodeMallTwo, buyOrderMallTwo, installmentsNumberMallTwo);

final MallFullTransactionCreateResponse response = MallFullTransaction.Transaction.create(
  buyOrder,                           // ordenCompra12345678
  sessionId,                          // sesion1234564
  cardNumber,                         // 4239000000000000
  cardExpirationDate,                 // 22/10
  transactionDetails
);
use Transbank\TransaccionCompleta\MallTransaction;
use Transbank\TransaccionCompleta\TransaccionCompleta;

$transaction_details = [
    [
        'amount' => 10000,
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_1,
        'buy_order' => '123456789'
    ],
    [
        'amount' => 12000,
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_2,
        'buy_order' => '123456790'
    ],
];
$cardNumber = '4051885600446623';
$cardExpirationDate = '22/12';
$cvv = '123';

$transaction = new MallTransaction();
$response = $transaction->create(
    'buyOrder1',                         // ordenCompra12345678
    'sessionId' ,                        // sesion1234564
    $cardNumber,                       // 4239000000000000
    $cardExpirationDate,              // 22/10
    $transaction_details,
    $cvv);

print_r($response);
using Transbank.Webpay.TransaccionCompletaMall;

var transactionDetails = new List<CreateDetails>();
transactionDetails.Add(new CreateDetails(
    amountMallOne,
    commerceCodeMallOne,
    buyOrderMallOne
));
transactionDetails.Add(new CreateDetails(
    amountMallTwo,
    comerceCodeMallTwo,
    buyOrderMallTwo
));

var response = MallFullTransaction.Create(
  buyOrder,
  sessionId,
  cardNumber,
  cardExpirationDate,
  transactionDetails
);
details = [
  {
    amount: 10000,
    commerce_code: 597055555552,
    buy_order: '123456789'
  },
  {
    amount: 12000,
    commerce_code: 597055555553,
    buy_order: '123456790'
  }
]
response = Transbank::TransaccionCompleta::MallTransaction::create(
  buy_order: 'ordenCompra12345678',
  session_id: 'sesion1234564',
  card_number: 4239000000000000,
  card_expiration_date: '22/10',
  details: details
)
details = [
  {
      'commerce_code': 597055555552,
      'buy_order': '123456789',
      'amount': 10000
  },
  {
      'commerce_code': 597055555553,
      'buy_order': '123456790',
      'amount': 12000
  }
]

response = Transaction.create(
  buy_order=buy_order,
  session_id=session_id,
  card_number=card_number, card_expiration_date=card_expiration_date, details=details
)
const details = [
  new TransactionDetail(amount, commerceCode, childBuyOrder),
  new TransactionDetail(amount2, commerceCode2, childBuyOrder2)
];

const response = await TransaccionCompleta.MallTransaction.create(        
  parentBuyOrder,        
  sessionId,        
  cvv,        
  cardNumber,        
  cardExpirationDate,        
  details
);

Respuesta creación

response.getToken();
$response->getToken();
response.Token;
response.token
response.token
response.token

Consulta de cuotas mall

Para consultar el valor de las cuotas que pagará el tarjeta habiente en cada transacción dentro transacción completa mall, es necesario llamar al método Transaction.installments()

Operación que permite obtener el monto de la cuota a partir del número de cuotas. El id de la consulta que selecciona el tarjetahabiente debe ser informado en la invocación de la confirmación.

MallFullTransactionInstallmentsDetails installmentsDetails = 
  MallFullTransactionInstallmentsDetails.build().add(commerceCode, buyOrder, installmentsNumber);
final MallFullTransactionInstallmentsResponse response = 
  MallFullTransaction.Transaction.installment(token, installmentsDetails);
use Transbank\TransaccionCompleta

use Transbank\TransaccionCompleta\MallTransaction;

$transaction = new MallTransaction();

$installments_details = [
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_1,
        'buy_order' => '123456789',
        'installments_number' => 2
    ],
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_2,
        'buy_order' => '123456790',
        'installments_number' => 2
    ],
];

$response = $transaction->installments($token, $installments_details);
print_r($response);
using Transbank.Webpay.TransaccionCompletaMall;

var installmentsDetails = new List<MallInstallmentsDetails>();
installmentsDetails.Add(new CreateDetails(
    commerceCodeMallOne,
    buyOrderMallOne,
    installmentsNumberMallOne
));
installmentsDetails.Add(new CreateDetails(
    comerceCodeMallTwo,
    buyOrderMallTwo,
    installmentsNumberMallTwo
));

var response = MallFullTransaction.Installments(
  token, installmentDetails
);
installment_details = [
  {
    commerce_code: 597055555552,
    buy_order: '123456789',
    installments_number: 2
  },
  {
    commerce_code: 597055555553,
    buy_order: '123456790',
    installments_number: 2
  },
]

response = Transbank::TransaccionCompleta::MallTransaction::installments(token, installment_details)
from transbank.transaccion_completa_mall.transaction import Transaction

details = [
  {
    'commerce_code': 597055555552,
    'buy_order': '123456789',
    'installments_number': 2
  },
  {
    'commerce_code': 597055555553,
    'buy_order': '123456790',
    'installments_number': 2
  }
]

response = Transaction.installments(token=token, details=details)
// Installments Number == Número de cuotas
const details = [
  new InstallmentDetail(childCommerceCode, childBuyOrder, installmentsNumber),
  new InstallmentDetail(childCommerceCode2, childBuyOrder2, installmentsNumber2)
  ];        

const installmentsResponse = await TransaccionCompleta.MallTransaction.installments(        
  token,        
  details
);

Confirmar una transacción mall

Una vez iniciada la transacción y consultado el monto de las cuotas por cada subtransacción, puedes confirmar y obtener el resultado de una transacción completa usando el metodo Transaction.commit().

Es una operación que permite confirmar una transacción. Retorna el estado de la transacción.

MallTransactionCommitDetails details = MallTransactionCommitDetails.build().add(
  commerceCode,buyOrder,idQueryInstallments,deferredPeriodIndex,gracePeriod
);

final MallFullTransactionCommitResponse response = MallFullTransaction.Transaction.commit(token, details);
use Transbank\TransaccionCompleta;
use Transbank\TransaccionCompleta\MallTransaction;

$details = [
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_1,
        'buy_order' => '123456789',
        'id_query_installments' => $firstInstallmentResponse->getIdQueryInstallments(),
        'deferred_period_index' => null,
        'grace_period' => false
    ],
    [
        'commerce_code' => TransaccionCompleta::DEFAULT_MALL_CHILD_COMMERCE_CODE_2,
        'buy_order' => '123456790',
        'id_query_installments' => $secondInstallmentResponse->getIdQueryInstallments(),
        'deferred_period_index' => null,
        'grace_period' => false
    ]
];

$transaction = new MallTransaction();
$response = $transaction->commit($token, $details);
print_r($response);
using Transbank.Webpay.TransaccionCompletaMall;

var transactionDetails = new List<MallCommitDetails>();
transactionDetails.Add(new MallCommitDetails(
    commerceCodeMallOne,
    buyOrderMallOne,
    idQueryInstallmentsOne,
    deferredPeriodIndexOne,
    gracePeriodOne
));
transactionDetails.Add(new MallCommitDetails(
    commerceCodeMallTwo,
    buyOrderMallTwo,
    idQueryInstallmentsTwo,
    deferredPeriodIndexTwo,
    gracePeriodTwo
));

var response = MallFullTransaction.Commit(
  token, transactionDetails
);
details = [
  {
    commerce_code: '597055555552',
    buy_order: 'ordenCompra1234',
    id_query_installments: 12,
    deferred_period_index: 1,
    grace_period: false
  },
  {
    commerce_code: '597055555553',
    buy_order: 'ordenCompra12345',
    id_query_installments: 12,
    deferred_period_index: 1,
    grace_period: false
  }
]

response = Transbank::TransaccionCompleta::MallTransaction::commit(
  token: token, details: details
)
details = [
  {
    "commerce_code": '597055555552',
    "buy_order": 'ordenCompra1234',
    "id_query_installments": 12,
    "deferred_period_index": 1,
    "grace_period": false
  },
  {
    "commerce_code": '597055555553',
    "buy_order": 'ordenCompra12345',
    "id_query_installments": 12,
    "deferred_period_index": 1,
    "grace_period": false
  }
]

response = Transaction.commit(
  token=token, details=details
)
let commitDetails = [
  new CommitDetail(commerceCode, childBuyOrder),
  new CommitDetail(commerceCode2, childBuyOrder2)
];        
const response = await TransaccionCompleta.MallTransaction.commit(        
  token,        
  commitDetails
);

Respuesta confirmación mall

response.getBuyOrder();
response.getCardNumber();
response.getAccountingDate();
response.getTransactionDate();
Detail detail = response.getDetails()[0];
detail.getAuthorizationCode();
detail.getPaymentCodeType();
detail.getResponseCode();
detail.getInstallmentsAmount();
detail.getInstallmentsNumber();
detail.getAmount();
detail.getCommerceCode();
detail.getBuyOrder();
detail.getStatus();
detail.getBalance();
$response->getBuyOrder();
$response->getCardNumber();
$response->getAccountingDate();
$response->getTransactionDate();
$detail = $response->getDetails()[0];
$detail->getAuthorizationCode();
$detail->getPaymentTypeCode();
$detail->getResponseCode();
$detail->getInstallmentsAmount();
$detail->getInstallmentsNumber();
$detail->getAmount();
$detail->getCommerceCode();
$detail->getBuyOrder();
$detail->getStatus();
response.BuyOrder;
response.CardNumber;
response.AccountingDate;
response.TransactionDate;
detail = response.Details[0];
detail.AuthorizationCode;
detail.PaymentCodeType;
detail.ResponseCode;
detail.InstallmentsAmount;
detail.InstallmentsNumber;
detail.Amount;
detail.CommerceCode;
detail.BuyOrder;
detail.Status;
detail.Balance;
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

Obtener estado de una transacción mall

Esta operación permite obtener el estado de la transacción Completa Mall en cualquier momento. En condiciones normales es probable que no se requiera ejecutar, pero en caso de ocurrir un error inesperado permite conocer el estado y tomar las acciones que correspondan.

Obtiene resultado de transacción a partir de un token.

MallFullTransaction.Transaction.status(token)
use Transbank\TransaccionCompleta\MallTransaction;

$response = (new MallTransaction)->status(token);
using Transbank.Webpay.TransaccionCompletaMall;

var response = MallFullTransaction.Status(token);
response = Transbank::TransaccionCompleta::MallTransaction::status(token)
response = Transaction.status(token)
const response = await TransaccionCompleta.Transaction.status(token);

Respuesta consulta de estado

response.getBuyOrder();
response.getCardNumber();
response.getAccountingDate();
response.getTransactionDate();
Detail detail = response.getDetails()[0];
detail.getAuthorizationCode();
detail.getPaymentCodeType();
detail.getResponseCode();
detail.getInstallmentsAmount();
detail.getInstallmentsNumber();
detail.getAmount();
detail.getCommerceCode();
detail.getBuyOrder();
detail.getStatus();
detail.getBalance();
$response->getBuyOrder();
$response->getCardNumber();
$response->getAccountingDate();
$response->getTransactionDate();
$detail = $response->getDetails()[0];
$detail->getAuthorizationCode();
$detail->getPaymentTypeCode();
$detail->getResponseCode();
$detail->getInstallmentsAmount();
$detail->getInstallmentsNumber();
$detail->getAmount();
$detail->getCommerceCode();
$detail->getBuyOrder();
$detail->getStatus();
response.BuyOrder;
response.CardNumber;
response.AccountingDate;
response.TransactionDate;
detail = response.Details[0];
detail.AuthorizationCode;
detail.PaymentCodeType;
detail.ResponseCode;
detail.InstallmentsAmount;
detail.InstallmentsNumber;
detail.Amount;
detail.CommerceCode;
detail.BuyOrder;
detail.Status;
detail.Balance;
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance
response.buy_order
response.card_number
response.accounting_date
response.transaction_date
detail = response.details[0]
detail.authorization_code
detail.payment_code_type
detail.response_code
detail.installments_amount
detail.installments_number
detail.amount
detail.commerce_code
detail.buy_order
detail.status
detail.balance

Reversar o anular una transacción mall

Permite generar el reembolso del total o parte del monto de una transacción completa. Dependiendo de la siguiente lógica de negocio la invocación a esta operación generará una reversa o una anulación:

  • Si se especifica un valor en el campo “amount” se ejecutará siempre una anulación.
  • Si se supera el tiempo máximo para ejecutar una reversa se ejecutará una anulación.
  • Si no se ha dado ninguno de los casos anteriores se ejecutará una reversa.

Permite solicitar a Webpay la anulación de una transacción realizada previamente y que se encuentre vigente.

final MallFullTransactionRefundResponse response = MallFullTransaction.Transaction.refund(
  token, amount, commerceCode, buyOrder
);
use Transbank\TransaccionCompleta\MallTransaction;

(new MallTransaction)->refund(
  $token,
  $childBuyOrder,
  $childCommerceCode,
  $amount
);
using Transbank.Webpay.TransaccionCompletaMall;

MallRefundRequest(
  token,
  childBuyOrder,
  childCommerceCode,
  amount
);
Transbank::TransaccionCompleta::MallTransaction::refund(
  token: token,
  child_buy_order: child_buy_order,
  child_commerce_code: child_commerce_code,
  amount: amount
)
from transbank.transaccion_completa_mall.transaction import Transaction

Transaction.refund(
  token=token, amount=amount, child_commerce_code=child_commerce_code, child_buy_order=child_buy_order
)
const refundResponse = await TransaccionCompleta.MallTransaction.refund(        
  token,    
  buyOrder,        
  commerceCode,
  amount        
);

Respuesta reembolso mall

response.getType();
response.getAuthorizationCode();
response.getAuthorizationDate();
response.getNullifiedAmount();
response.getBalance();
response.getResponseCode();
$response->getType();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getNullifiedAmount();
$response->getBalance();
$response->getResponseCode();
response.Type;
response.AuthorizationCode;
response.AuthorizationDate;
response.NullifiedAmount;
response.Balance;
response.ResponseCode;
response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code
response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code
response.type
response.authorization_code
response.authorization_date
response.nullified_amount
response.balance
response.response_code

Captura diferida de una transacción mall

Este método permite a todo comercio habilitado realizar capturas de una transacción autorizada sin captura generada en Transacción Completa. El método contempla una única captura por cada autorización. Para ello se deberá indicar los datos asociados a la transacción de venta con autorización sin captura y el monto requerido para capturar el cual debe ser menor o igual al monto originalmente autorizado.

Para capturar una transacción, ésta debe haber sido creada por un código de comercio configurado para captura diferida. De esa forma la transacción estará autorizada pero requerirá una captura explícita posterior para confirmar la transacción.

Puedes leer más sobre la captura en la información del producto Webpay para conocer más detalles y restricciones.

// Aun no está disponible en este SDK
use Transbank\TransaccionCompleta\Transaction;

$transaction = new Transaction();
$transaction->capture($token, $buyOrder, $authorizationCode, $captureAmount);


// 
use Transbank\TransaccionCompleta\MallTransaction;

$transaction = new MallTransaction();
$transaction->capture($token, $commerceCode, $buyOrder, $authorizationCode, $captureAmount);
// Aun no está disponible en este SDK
Transbank::TransaccionCompleta::MallTransaction.capture(
  token: token,
  commerce_code: commerce_code,
  buy_order: buy_order,
  authorization_code: authorization_code,
  capture_amount: capture_amount
)
# Aun no está disponible en este SDK
const response = TransaccionCompleta.MallDeferredTransaction.capture(
  token, commerceCode, buyOrder, authorizationCode, amount
);

// Aun no está disponible en este SDK
$response->getToken();
$response->getAuthorizationCode();
$response->getAuthorizationDate();
$response->getCapturedAmount();
$response->getResponseCode();
// Aun no está disponible en este SDK
# Aun no está disponible en este SDK
# Aun no está disponible en este SDK
response.authorization_code
response.authorization_date
response.captured_amount
response.response_code

Credenciales y Ambientes

Ambiente de integración

Puede encontrar más información al respecto en este link

Configuración SDK

Los SDK vienen preconfigurados para operar directamente en el ambiente de integración. Si necesitas operar con otra modalidad, debes configurar explícitamente el código de comercio que usarás. No es necesario definir el Api Key ya que en este ambiente, todos los productos usan la misma y ya viene preconfigurada.

Puede encontrar más información al respecto en este link

Puesta en Producción

Puede encontrar más información al respecto en este link

Ejemplos de integración

Ponemos a tu disposición una serie de repositorios en nuestro Github para ayudarte a entender la integración de mejor forma. Puedes encontrar una lista de proyectos de ejemplo acá.