SDK Rush

Nuestro SDK te permite integrarte rapidamente con Culqi

Nuestro SDK oficial Rush, es compatible con la V2.0 del Culqi API, con el cual tendrás la posibilidad de integrarte con el API de tokens, cargos, devoluciones, clientes, tarjetas, planes, suscripciones y órdenes

El SDK te da la posibilidad de capturar el status_code de la solicitud HTTP que se realiza al API de Culqi, así como el response.

Requisitos

  • Nuestro SDK es compatible con Rush 1.6.2+.
  • Debes tener tus llaves de producción o integración.
  • Si aun no te afilias a Culqi, lo puedes hacer desde aquí.
  • Para encriptar el payload debes generar un id y llave RSA ingresando a tu CulqiPanel > Desarrollo > RSA Keys.

Recuerda que para obtener tu llave pública, debes ingresar a la sección “Desarrollo” y luego a “API Keys” en tu CulqiPanel, para generar tu id y llave RSA debes ingresar a “RSA Keys”.

Repositorio

Puedes descargar el código fuente del SDK desde:

Repositorio

Culqi Rush

repositorio

Repositorio de paquetes

Puedes revisar las versiones disponibles desde el repositorio de paquetes de crates.io e instalarlo en tu aplicativo como una dependencia:

Repositorio

Culqi Ruby

repositorio

Instalación

Agregar la siguiente dependencia en tu arhivo Cargo.toml (Ultima version)

[dependencies]
LibCulqi = "1.0.2"

O ejecuta el sisguiente comando:

cargo install LibCulqi

Configuración

1. Configurar llaves

Para empezar a enviar peticiones al API de Culqi debes configurar tu llave pública (pk), llave privada (sk). Para habilitar encriptación de payload debes configurar tu rsa_id y rsa_public_key.

const PUBLIC_KEY : &str = "Ingresa tu llave pública";
const SECRET_KEY : &str = "Ingresa tu llave privada";

Recuerda que las llaves de integración se identifican como “test” y las de producción como “live”.

2. Encriptar payload

Para encriptar el payload necesitas pasar como parámetro el rsaPublicKey y rsaId.

Ejemplo

const RSA_ID : &str = "Ingresa tu rsa_id";
const RSA_KEY : &str = "Ingresa tu rsa_public_key";

Servicios

Crear token

Para no poner en riesgo los datos sensibles de la tarjeta de crédito/débito es recomendable es generar los ‘tokens’ con el Custom Checkout debido a que es muy importante que los datos de la tarjeta sean enviados directamente desde el dispositivo de tus clientes a los servidores de Culqi.

Recuerda que cuando interactúas directamente con el API Token necesitas cumplir la normativa de PCI DSS 3.2. Por ello, te pedimos que llenes el formulario SAQ-D y lo envíes al buzón de riesgos Culqi.

 
let request_create_token = json!({
    "card_number": "4111111111111111",
    "cvv": "123",
    "expiration_month": "09",
    "expiration_year": "2025",
    "email": "brando.carquin@culqi.com",
    "metadata": {
        "comment": "Tarjeta de Prueba",
        "document_number": "12345678",
    },
})
let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Token::create(client, &request_create_token, None).await;

Crear cargo

Crear un cargo significa cobrar una venta a una tarjeta. Para esto previamente deberías generar el token y enviarlo en el parámetro source_id.

Los cargos son creados a través del API de cargo.

let request_create_token = json!({
    "amount": 10000,
    "currency_code": "PEN",
    "email": "brando.carquin@culqi.com",
    "source_id": "tkn_test_0CjjdWhFpEAZlxlz", // Crear Token -> Id
    "capture": true,
    "antifraud_details": {
        "address": "Avenida Lima 1234",
        "address_city": "Lima",
        "country_code": "PE",
        "first_name": "culqi",
        "last_name": "core",
        "phone_number": "999777666"
    },
    "metadata": {
        "documentNumber": "77723083"
    }
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Charge::create(client, &request_create_token, None).await;

Para realizar un cargo recurrente, puedes utilizar el siguiente código:

params = {
  :amount => 1000,
  :capture => false,
  :currency_code => 'PEN',
  :description => 'Venta de prueba',
  :email => 'test'+SecureRandom.uuid+'@culqi.com',
  :installments => 0,
  :metadata => ({
    :test => 'test123'
  }),
  :source_id => token_json['id']
}

custom_headers  = {
  'X-Charge-Channel' => 'recurrent',
}

charge, statusCode = Culqi::Charge.create(params, '', '', custom_headers)

jsonCharge = JSON.parse(charge)

Crear devolución

Solicita la devolución de las compras de tus clientes (parcial o total) a través del API y CulqiPanel.

Las devoluciones son creadas a través del API de devolución.

let request_create_token = json!({
    "amount": 2000,
    "charge_id": "chr_test_3xWxRF1Zswgp6C7N", // Crear Cargo -> Id
    "reason": "fraudulento"
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Refund::create(client, &request_create_token, None).await;

Crear Cliente

El cliente es un servicio que te permite guardar la información de tus clientes. Es un paso necesario para generar una tarjeta.

Los clientes son creados a través del API de cliente.

let request_create_token = json!({
    "first_name": "Richard",
    "last_name": "Hendricks",
    "email": "richard@piedpiper.com",
    "address": "San Francisco Bay Area",
    "address_city": "Palo Alto",
    "country_code": "US",
    "phone_number": "6505434800"
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Customer::create(client, &request_create_token, None).await;

Crear Card

La tarjeta es un servicio que te permite guardar la información de las tarjetas de crédito o débito de tus clientes para luego realizarles cargos one click o recurrentes (cargos posteriores sin que tus clientes vuelvan a ingresar los datos de su tarjeta).

Las tarjetas son creadas a través del API de tarjeta.

let request_create_token = json!({
    "customer_id": "cus_test_Lz6Yfsm7QqCPIECW", // Crear Customer -> Id
    "token_id": "tkn_test_vEcZSCOVz5PGDPdQ", // Crear Token -> Id
    "validate": true,
    "metadata": {
        "marca_tarjeta": "VISA"
    }
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Card::create(client, &request_create_token, None).await;

Crear Plan

El plan es un servicio que te permite definir con qué frecuencia deseas realizar cobros a tus clientes.

Un plan define el comportamiento de las suscripciones. Los planes son creados a través del API de Plan o desde el CulqiPanel.

let request_create_token = json!({
    "name": "Plan de Prueba.",
    "short_name": "plan-de-prueba-001",
    "description": "Descripción Plan de Prueba",
    "amount": 5,
    "currency": "PEN",
    "interval_unit_time": 1,
    "interval_count": 1,
    "initial_cycles": {
        "count": 0,
        "has_initial_charge": false,
        "amount": 0,
        "interval_unit_time": 1
    },
    "metadata": {
        "DNI": 123456782
    }
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Plan::create(client, &request_create_token, None).await;

Crear Suscripción a un plan

La suscripción es un servicio que asocia la tarjeta de un cliente con un plan establecido por el comercio.

Las suscripciones son creadas a través del API de suscripción.

let request_create_token = json!({
    "card_id": "crd_test_RzjTyGUwZioJLpZt", // Crear Card -> Id
    "plan_id": "pln_test_XXXXXXXXXXXXXXXX", // Crear Plan -> Id
    "tyc": true,
    "metadata": {
        "DNI": 123456782
    }
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Subscription::create(client, &request_create_token, None).await;

Crear Orden

Es un servicio que te permite generar una orden de pago para una compra potencial. La orden contiene la información necesaria para la venta y es usado por el sistema de PagoEfectivo para realizar los pagos diferidos.

Las órdenes son creadas a través del API de orden.

let request_create_token = json!({
    "amount": 60000,
    "currency_code": "PEN",
    "description": " Venta de polo",
    "order_number": "#id-9999",
    "expiration_date": "1476132639",
    "client_details": {
        "first_name": "Richard",
        "last_name": "Hendricks",
        "email": "richard@piedpiper.com",
        "phone_number": "999999987"
    },
    "confirm": true,
    "metadata": {
        "dni": "71702999"
    }
})

let client = Client::config(&SECRET_KEY, &PUBLIC_KEY, None,);

return Order::create(client, &request_create_token, None).await;

Pruebas

Antes de activar tu tienda en producción, te recomendamos realizar pruebas de integración. Así garantizarás un correcto despliegue.

Si vas a empezar a vender desde tu tienda virtual, deberás seleccionar el ambiente de producción e ingresar tus llaves.

Recuerda que si quieres probar tu integración, puedes utilizar nuestras tarjetas de prueba.

En la carpeta /tests encontraras ejemplos para crear un token, charge, plan, órdenes, card, suscripciones, etc.

Puedes ejecutar todos los test con el siguiente comando

cargo test

Si queremos ejecutar un especifico método de un test

cargo test tests::test_plan_update
Anterior SDK Ruby
Siguiente Demos