Aquí estoy de nuevo compartiendo otro CODE-KATA, ahora para hacer una tarea muy interesante conectando dos sistemas informáticos. Es decir, tenemos un Magento 1 en algún lugar, y vamos a permitir conectarnos desde otra plataforma en PHP para la creación de pedidos de forma remota.
Lo primero que necesitamos tener es la información del pedido por completo. Necesitamos saber los datos del cliente, direcciones de envío y facturación, en este caso el correo electrónico del cliente registrado en Magento, y de los productos necesitamos el SKU y la cantidad que queremos pedir.
Dando acceso a un usuario de la API Soap
Primero que todo le damos acceso al usuario de la API Soap creándolo y poniéndole un rol. Para esto vamos a estas dos secciones y lo configuramos:
Magento > Sistema > Servicios web > SOAP/XML-RPC - Roles Magento > Sistema > Servicios web > SOAP/XML-RPC - Users
Primero vamos a los roles y le damos permiso a lo que necesita para hacer pedidos. Luego al crear el usuario le tenemos que poner un nombre de usuario y la API key. Esto son el nombre de usuario y la contraseña que vamos a usar después en el script de PHP de creación de pedidos.
Conectando a la API Soap de Magento
Ahora vamos con el código fuente. Primero que todo tenemos que crear la conexión con el Magento:
$user = 'nombreDeUsuario';
$password = 'contraseñaLaAPIKey';
$endpoint = 'https://www.tusitiodepruebas.com/api/v2_soap/?wsdl';
// Create Soap client.
$ret = 'Connecting.. ';
try {
$proxy = new \SoapClient($endpoint);
$ret .= 'ok!'.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR connecting: '.$e->getMessage().PHP_EOL;
}
Hasta aquí, si todo ha ido bien, veremos por pantalla si lo ejecutamos desde línea de comandos lo siguiente: Connecting.. ok!
Login con el usuario de la API
Ahora vamos a hacer login con el usuario:
// Do login.
try {
$sessionId = $proxy->login($user, $password);
$ret .= 'Logged in, session ID: '.$sessionId.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR login! '.$e->getMessage().PHP_EOL;
}
Buscando el cliente en Magento
La siguiente tarea es encontrar el cliente que luego vamos a asignar al carrito de la compra y al pedido. También se podría hacer como usuario no logueado, pero vamos a hacer así:
// load the customer list and select the first customer from the list.
$complexFilter = array(
'complex_filter' => array(
array(
'key' => 'email',
'value' => array('key' => 'in', 'value' => 'email@delusuario.com'),
),
),
);
try {
$customerList = $proxy->customerCustomerList($sessionId, $complexFilter);
$ret .= 'Searching client by email..'.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR searching customer: '.$e->getMessage().PHP_EOL;
}
if($customerList){
$customer = (array) $customerList[0];
$customer['mode'] = 'customer';
} else {
throw new \Exception("ERROR searching customer, not found!", 1);
}
Creando el carrito de la compra
En Magento 1 no se puede crear directamente el pedido. Hay que crear un carrito de la compra con el cliente, poner los datos de facturación, de envío, poner los productos con sus cantidades, y entonces podremos convertir este carrito de la compra en un pedido.
Esto es necesario porque Magento controla si hay unidades disponibles de los productos. Entonces, si no hay suficientes unidades en stock no te dejará hacer el carrito, ni después el pedido. Así que para crear el carrito asociado a la sesión de usuario de antes:
// Create shopping cart.
try {
$cartId = $proxy->shoppingCartCreate($sessionId, $customer['store_id']);
$ret .= 'Created cart, ID: '.$cartId.' ..in store ID: '.$customer['store_id'].PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR creating cart:'.$e->getMessage().PHP_EOL;
}
Lo siguiente será asignar el cliente que hemos encontrado en Magento:
// Set customer of cart.
try {
$resultCustomerSet = $proxy->shoppingCartCustomerSet($sessionId, $cartId, $customer);
$ret .= 'Customer set, result: '.$resultCustomerSet.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR setting customer:'.$e->getMessage().PHP_EOL;
}
Añadimos los productos al carrito
Lo siguiente es llenar el carrito de la compra. Aquí simplemente ponemos las unidades y SKUs de los productos. Todo lo demás (precio, impuestos, etc..) se calculará en función a los datos que haya en Magento.
$products = [];
$products[] = [
'sku' => 'SKU1',
'qty' => '2',
];
try {
$resultProductAdd = $proxy->shoppingCartProductAdd($sessionId, $cartId, $products);
$ret .= 'Product add, result: '.$resultProductAdd.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR adding products:'.$e->getMessage().PHP_EOL;
}
Poniendo los datos de facturación y de envío
Sí que hay datos que poner en un carro de la compra ¿verdad? Sí, tiene su historia, por eso que construir un buen carro de la compra en una página web tiene su historia. Entonces, continuamos poniendo estos datos de facturación y de envío para este pedido:
// add customer address
$address = array(
array(
'mode' => 'shipping',
'firstname' => 'Nombre 1',
'lastname' => 'Apellido 1',
'street' => 'Calle de pruebas',
'city' => 'Ciudad de pruebas',
'region' => 'Región',
'telephone' => '123123123',
'postcode' => '12123',
'country_id' => 'ES',
'is_default_shipping' => 0,
'is_default_billing' => 0,
),
array(
'mode' => 'billing',
'mode' => 'shipping',
'firstname' => 'Nombre 2',
'lastname' => 'Apellido 2',
'street' => 'Calle de pruebas 2',
'city' => 'Ciudad de pruebas 2',
'region' => 'Región',
'telephone' => '123123123',
'postcode' => '12123',
'country_id' => 'ES',
'is_default_shipping' => 0,
'is_default_billing' => 0,
),
);
try {
$resultCustomerAddresses = $proxy->shoppingCartCustomerAddresses($sessionId, $cartId, $address);
$ret .= 'Customer addresses setted, result: '.$resultCustomerAddresses.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR setting addresses:'.$e->getMessage().PHP_EOL;
}
Ponemos el método de envío y de pago
Esto es sencillo:
// Add shipping method.
try {
$resultShippingMethod = $proxy->shoppingCartShippingMethod($sessionId, $cartId, 'freeshipping_freeshipping');
$ret .= 'Shopping method setted, result: '.$resultShippingMethod.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR setting shipping method:'.$e->getMessage().PHP_EOL;
}
Y ahora el método de pago, que para simplificar ponemos la transferencia bancaria:
// Add payment method.
$paymentMethod = array(
'method' => 'banktransfer',
);
try {
$resultPaymentMethod = $proxy->shoppingCartPaymentMethod($sessionId, $cartId, $paymentMethod);
$ret .= 'Payment method setted, result: '.$resultPaymentMethod.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR setting payment method: '.$e->getMessage().PHP_EOL;
}
Terminando, finalmente creamos el pedido
Ahora sí, a partir de todo lo anterior, imaginamos el carrito de la compra de un eCommerce normal y corriente. Ya tenemos todos los datos y estamos en el checkout. Sólo le queda decirle a Magento que coga este carrito y lo convierta en pedido, que se hace así:
// Place the order.
try {
$orderId = $proxy->shoppingCartOrder($sessionId, $cartId);
$ret .= 'Order saved in Magento: '.$orderId.PHP_EOL;
} catch (Exception $e) {
$ret .= 'ERROR placing the order in Magento:'.$e->getMessage().PHP_EOL;
}
return $ret;
Esto es todo, no hace falta más para crear un pedido de forma remota en Magento. Recapitulando, necesitamos un usuario y contraseña con el que llenamos el carrito de la compra, para luego convertir este carrito en un pedido.
¡Un saludo!
