This course is still being released! Check back later for more chapters.

Get Notified About this Course!

We will send you messages regarding this course only
and nothing else, we promise.
You can unsubscribe anytime by emailing us at:
privacy@symfonycasts.com
> Symfony 7 > Procesador de Pagos con Lemon Squeezy
Login to bookmark this video
Buy Access to Course
05.

Datos dinámicos

|

Share this awesome video!

|

Keep on Learning!

Start your All-Access Pass

With a Subscription, click any sentence in the script to jump to that part of the video!

Login Subscribe

¡Muy bien! ¡Hemos hecho nuestra primera petición a la API! Esto genera una URL de pago única para nuestro cliente y abre la página de pago de LemonSqueezy para que pueda comprar el producto. Pero cuando configuramos esto, codificamos muchas cosas. ¡Es hora de hacerlo dinámico!

Utilizar datos dinámicos en el objeto de pago

Empecemos con el ID de la tienda. Es único para nuestros entornos de prueba y real, así que tiene sentido establecerlo como una variable de entorno. Abre el archivo.env y, debajo de LEMON_SQUEEZY_API_KEY, escribeLEMON_SQUEEZY_STORE_ID= y establece ese valor como el ID de la tienda. Puedes encontrarlo en OrderController.php.

35 lines | .env
// ... lines 1 - 17
LEMON_SQUEEZY_STORE_ID=132127
// ... lines 19 - 35

Ahora, en config/services.yaml, debajo de parameters, añade uno nuevo -env(LEMON_SQUEEZY_STORE_ID) - y establécelo como%env(LEMON_SQUEEZY_STORE_ID)%’. De vuelta en nuestro controlador, sustituye el valor ID por $this->getParameter('env(LEMON_SQUEEZY_STORE_ID)').

26 lines | config/services.yaml
// ... lines 1 - 5
parameters:
env(LEMON_SQUEEZY_STORE_ID): '%env(LEMON_SQUEEZY_STORE_ID)%'
// ... lines 8 - 26

Almacenar ID de variantes en la base de datos

Para el ID de variante, vamos a crear un nuevo campo en la entidad Product. En tu terminal, ejecuta:

bin/console make:entity

Actualiza la entidad Product, y llama al nuevo campo lsVariantId. Será un string, con una longitud de campo por defecto, y hagámoslo "anulable". PulsaEnter para terminar y luego dirígete a src/Entity/Product.php para ver nuestros cambios. Si nos desplazamos hacia abajo... ¡ah, ahí está! Probablemente también deberíamos hacer estounique. ¡Tiene buena pinta! Aquí abajo, podemos ver que también ha creado un getter y un setter. ¡Qué práctico!

112 lines | src/Entity/Product.php
// ... lines 1 - 9
class Product
{
// ... lines 12 - 31
#[ORM\Column(length: 255, unique: true, nullable: true)]
private ?string $lsVariantId = null;
// ... lines 34 - 99
public function getLsVariantId(): ?string
{
return $this->lsVariantId;
}
public function setLsVariantId(?string $lsVariantId): static
{
$this->lsVariantId = $lsVariantId;
return $this;
}
}

Ahora, de vuelta en nuestro terminal, crea una migración con:

bin/console make:migration

¡Vamos a comprobarlo! En migrations/... aquí abajo... parece que se ha añadido una nueva columna. ¡Qué bien! Aquí arriba, podemos añadir una descripción:

Añadir una columna para almacenar el ID de variante LS en Producto.

De vuelta a nuestro terminal, ejecuta la migración con:

bin/console doctrine:migrations:migrate

Ahora, en src/DataFixtures/AppFixtures.php, establece nuestro nuevo campo en el ID de variante del panel de control de LemonSqueezy. Puedes encontrarlo haciendo clic en "Tienda", "Productos", los tres puntos al final de nuestro producto aquí, y seleccionando "Copiar ID de variante". Pégalo y... ¡tachán! ¡El primero está hecho! Pero, ¿qué clase de puesto de limonada de diseño seríamos si sólo tuviéramos un tipo de limonada para elegir? ¡Añadamos más en función de nuestros accesorios!

Copia esta descripción y, de nuevo en nuestro panel de control, crea un nuevo producto. A éste lo llamaremos "Limonada electrónica de sandía" y pégalo. Establece el precio en "1,99 $", añade una imagen y "Publica el producto". Copia el ID de variante de nuestro nuevo producto y añádelo a nuestro producto en AppFixtures.php. ¡Estupendo! Hagamos lo mismo con los cuatro productos siguientes.

66 lines | src/DataFixtures/AppFixtures.php
// ... lines 1 - 9
class AppFixtures extends Fixture
{
public function load(ObjectManager $manager): void
{
// ... lines 14 - 19
ProductFactory::new()->create([
// ... lines 21 - 24
'lsVariantId' => '737914',
]);
ProductFactory::new()->create([
// ... lines 28 - 31
'lsVariantId' => '737915',
]);
// ... lines 34 - 63
}
}

¡Listo! Ahora vamos a recargar los accesorios con:

bin/console doctrine:fixtures:load

De vuelta en el controlador, dentro de createLsCheckoutUrl(), recupera los productos del carrito de la compra con $products = $cart->getProducts(). Y estableceremos$variantId en $products[0]->getLsVariantId() por ahora. Por último, debajo de$response, establece el ID de la variante en una variable $variantId.

103 lines | src/Controller/OrderController.php
// ... lines 1 - 13
class OrderController extends AbstractController
{
// ... lines 16 - 66
private function createLsCheckoutUrl(HttpClientInterface $lsClient, ShoppingCart $cart): string
{
// ... lines 69 - 72
$products = $cart->getProducts();
$variantId = $products[0]->getLsVariantId();
// ... line 75
$response = $lsClient->request(Request::METHOD_POST, 'checkouts', [
'json' => [
'data' => [
// ... line 79
'relationships' => [
// ... lines 81 - 86
'variant' => [
'data' => [
// ... line 89
'id' => $variantId,
],
],
],
],
],
]);
// ... lines 97 - 100
}
}

Establecer la cantidad correcta

Bien, ¡intentemos pasar por caja! Vuelve a la página de inicio y elige esta vez un nuevo producto. Establece la cantidad en "2", añádelo al carrito y haz clic en el botón de pago. ¡Qué bien! Estamos en la página de pago, y éste es el producto correcto pero... no la cantidad correcta.

Para solucionarlo, de vuelta en nuestro código, debajo de type, añade attributes...checkout_data... variant_quantities... otra matriz vacía, y dentro de ella, escribe variant_id => $variantId y quantity => $quantity. Encima, debajo de variantId, añade $quantity = $cart->getProductQuantity() con$products[0] como argumento. Si vamos a la página del carrito y volvemos a pulsar el botón "pagar"... ¡sí! ¡Tenemos el producto correcto y la cantidad correcta!

114 lines | src/Controller/OrderController.php
// ... lines 1 - 74
$quantity = $cart->getProductQuantity($products[0]);
// ... line 76
$response = $lsClient->request(Request::METHOD_POST, 'checkouts', [
'json' => [
'data' => [
// ... line 80
'attributes' => [
'checkout_data' => [
'variant_quantities' => [
[
'variant_id' => $variantId,
'quantity' => $quantity,
],
],
],
],
// ... lines 91 - 104
],
],
]);
// ... lines 108 - 111
}
// ... lines 113 - 114

Rellenar previamente los datos del usuario

Si me desplazo hacia arriba... hm... ¿de dónde viene este correo electrónico? Soy un propietario autenticado de una tienda LemonSqueezy, así que esto está pre-rellenado para mí. Pero, ¿y si intento pagar como cliente en modo incógnito? Abriré una nueva pestaña en modo incógnito, iniciaré sesión de nuevo con lemon@example.com / lemonpass como contraseña. Ahora elijo un producto, la cantidad, lo añado al carrito, hago clic en "pasar por caja", y... ¡ajá! ¡Los datos del usuario están vacíos! El usuario puede rellenarlos él mismo, así que no es un gran problema, pero apuesto a que podemos ahorrarle algo de tiempo y rellenarlos previamente desde nuestra aplicación, puesto que ya compartió su nombre y correo electrónico cuando se registró. Hagámoslo

En OrderController::checkout(), añade un nuevo argumento -#[CurrentUser] ?User $user - y más abajo, pasa $user acreateLsCheckoutUrl(). Aquí abajo, en ese método, añade un tercer argumento:?User $user.

117 lines | src/Controller/OrderController.php
// ... lines 1 - 12
use Symfony\Component\Security\Http\Attribute\CurrentUser;
// ... lines 14 - 15
class OrderController extends AbstractController
{
// ... lines 18 - 57
#[Route('/checkout', name: 'app_order_checkout')]
public function checkout(
// ... lines 60 - 62
#[CurrentUser] ?User $user,
): Response {
$lsCheckoutUrl = $this->createLsCheckoutUrl($lsClient, $cart, $user);
// ... lines 66 - 67
}
// ... line 69
private function createLsCheckoutUrl(HttpClientInterface $lsClient, ShoppingCart $cart, ?User $user): string
{
// ... lines 72 - 114
}
}

Debajo de $quantity, añade $attributes = y ajústalo a la matriz de atributos de las opciones de petición. Podemos copiar y pegar esto para hacerlo más fácil.

119 lines | src/Controller/OrderController.php
// ... lines 1 - 69
private function createLsCheckoutUrl(HttpClientInterface $lsClient, ShoppingCart $cart, ?User $user): string
{
// ... lines 72 - 79
$attributes = [
// ... lines 81 - 88
];
// ... line 90
$response = $lsClient->request(Request::METHOD_POST, 'checkouts', [
'json' => [
'data' => [
'type' => 'checkouts',
'attributes' => $attributes,
// ... lines 96 - 109
],
],
]);
// ... lines 113 - 116
}
// ... lines 118 - 119

Lo pondremos en $attributes, y aquí arriba, añade if ($user). Dentro, escribe$attributes['checkout_data']['email'] = $user->getEmail(). Y debajo,$attributes['checkout_data']['name'] = $user->getFirstName().

123 lines | src/Controller/OrderController.php
// ... lines 1 - 69
private function createLsCheckoutUrl(HttpClientInterface $lsClient, ShoppingCart $cart, ?User $user): string
{
// ... lines 72 - 89
if ($user) {
$attributes['checkout_data']['email'] = $user->getEmail();
$attributes['checkout_data']['name'] = $user->getFirstName();
}
// ... lines 94 - 120
}
// ... lines 122 - 123

¡Perfecto! Probemos de nuevo a pagar en modo incógnito. Vuelve a la página de inicio, haz clic en el carrito donde ya tenemos dos artículos esperando, haz clic en el botón de pago y... ¡los datos del usuario ya están rellenados! ¡Fantástico!

Hasta ahora, sólo hemos probado a comprar un sabor de limonada cada vez. Intentemos comprar más de un tipo a continuación.