[Resolvido] Como integrar o carrinho de compras ao sistema Akatus

[RSS iMasters 5]

Olá pessoal,

 

Como vimos na documentação da API, precisamos enviar um XML com a seguinte estrutura:

<?xml version="1.0" encoding="UTF-8"?>

 

<carrinho>

 

<recebedor>

<api_key>API_KEY_GERADO</api_key>

<email>EMAIL_DA_CONTA_AKATUS</email>

</recebedor>

 

<pagador>

<nome>Jose Antonio</nome>

<email>ze@antonio.com.br</email>

<enderecos>

<endereco>

<tipo>entrega</tipo>

<logradouro>Rua Labib Marrar</logradouro>

<numero>129</numero>

<bairro>Jardim Santa Cruz</bairro>

<cidade>São Paulo</cidade>

<estado>SP</estado>

<pais>BRA</pais>

<cep>04182-040</cep>

</endereco>

</enderecos>

 

<telefones>

<telefone>

<tipo>residencial</tipo>

<numero>1433019799</numero>

</telefone>

</telefones>

</pagador>

 

<produtos>

<produto>

<codigo>UFC1403</codigo>

<descricao>Luva de box com ferradura dentro</descricao>

<quantidade>1</quantidade>

<preco>148.99</preco>

<peso>8.5</peso>

<frete>16.45</frete>

<desconto>10.00</desconto>

 

</produto>

 

<produto>

<codigo>UFC1403</codigo>

<descricao>Luva de box com ferradura dentro</descricao>

<quantidade>1</quantidade>

<preco>148.99</preco>

<peso>8.5</peso>

<frete>16.45</frete>

<desconto>10.00</desconto>

</produto>

</produtos>

 

<transacao>

<desconto_total>20.00</desconto_total>

<peso_total>17.0</peso_total>

<frete_total>32.90</frete_total>

<moeda>BRL</moeda>

<referencia>abc1234</referencia>

<meio_de_pagamento>boleto</meio_de_pagamento>

</transacao>

 

</carrinho>

Como podemos ver nesse XML, temos um nó principal chamado carrinho, e alguns nós filhos:

1. recebedor: Esse nó conterá os dados da entidade (pessoa física ou jurídica) que receberá o pagamento. Ele será preenchido com o email da conta Akatus e a chave da API.
2. pagador: Esse nó conterá os dados do cliente que está fazendo o pagamento, seja via cartão de crédito, ou via boleto bancário. Ele será preenchido com o nome, email, lista de endereços e lista de telefones do cliente.
3. produtos: Esse nó representa o carrinho de compras do cliente. Todos os produtos, seus preços e suas respectivas quantidades serão colocados aqui.
4. transacao: Esse nó é o fechamento do carrinho. Ele será preenchido com o total da transação, desconto, frete e o meio de pagamento que será utilizado.

Estruturalmente, o carrinho se parecerá com o seguinte:

Então:

Pagador, Telefone e Endereço:

Address.php

<?php

/**

* Representação do endereço do comprador na API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Address {

/**

* @var string

*/

private $city;

 

/**

* @var string

*/

private $country;

 

/**

* @var string

*/

private $neighborhood;

 

/**

* @var integer

*/

private $number;

 

/**

* @var string

*/

private $state;

 

/**

* @var string

*/

private $street;

 

/**

* @var string

*/

private $type;

 

/**

* @var string

*/

private $zip;

 

/**

* @return string

*/

public function getCity() {

return $this->city;

}

 

/**

* @return string

*/

public function getCountry() {

return $this->country;

}

 

/**

* @return string

*/

public function getNeighborhood() {

return $this->neighborhood;

}

 

/**

* @return integer

*/

public function getNumber() {

return $this->number;

}

 

/**

* @return string

*/

public function getState() {

return $this->state;

}

 

/**

* @return string

*/

public function getStreet() {

return $this->street;

}

 

/**

* @return string

*/

public function getType() {

 

return $this->type;

}

 

/**

* @return string

*/

public function getZip() {

return $this->zip;

}

 

/**

* @param string $city

*/

public function setCity($city) {

$this->city = $city;

}

 

/**

* @param string $country

*/

public function setCountry($country) {

$this->country = $country;

}

 

/**

* @param string $neighborhood

*/

public function setNeighborhood($neighborhood) {

$this->neighborhood = $neighborhood;

}

 

/**

* @param integer $number

*/

public function setNumber($number) {

$this->number = $number;

}

 

/**

* @param string $state

*/

public function setState($state) {

$this->state = $state;

}

 

/**

* @param string $street

*/

public function setStreet($street) {

$this->street = $street;

}

 

/**

* @param string $type

*/

public function setType($type) {

$this->type = $type;

}

 

/**

* @param string $zip

*/

public function setZip($zip) {

$this->zip = $zip;

}

}

Phone.php

<?php

/**

* Representação de um telefone na API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Phone {

/**

* @var string

*/

private $number;

 

/**

* @var string

*/

private $type;

 

/**

* @param string $type

* @param string $number

*/

public function __construct($type, $number) {

$this->setType($type);

$this->setNumber($number);

}

 

/**

* @return string

*/

public function getNumber() {

return $this->number;

}

 

/**

* @return string

*/

public function getType() {

return $this->type;

}

 

/**

* @param string $number

*/

public function setNumber($number) {

$this->number = $number;

}

 

/**

* @param string $type

*/

public function setType($type) {

$this->type = $type;

}

}

Buyer.php

<?php

require_once 'Address.php';

require_once 'Phone.php';

 

/**

* Representação do comprador na API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Buyer {

/**

* @var array[Address]

*/

private $addresses = array();

 

/**

* @var string

*/

private $email;

 

/**

* @var string

*/

private $name;

 

/**

* @var array[Phone]

*/

private $phones = array();

 

/**

* @param string $name

*/

public function __construct( $name, $email ) {

$this->setName( $name );

$this->setEmail( $email );

}

 

/**

* @param Address $address

*/

public function addAddress( Address $address ) {

$this->addresses[] = $address;

}

 

/**

* Cria uma instância de Phone e já adiciona na lista de telefones do

* comprador.

* @param string $type

* @param string $number

*/

public function addNewPhone($type, $number) {

$this->addPhone( new Phone($type, $number));

}

 

/**

* @param Phone $phone

 

*/

public function addPhone( Phone $phone ) {

$this->phones[] = $phone;

}

 

/**

* Cria uma instância de Address e já adiciona na lista de endereços do

* comprador.

* @param string $type

* @return Address

*/

public function createAddress( $type ) {

$address = new Address();

$address->setType($type);

 

$this->addAddress($address);

 

return $address;

}

 

/**

* @return Iterator

*/

public function getAddressIterator() {

return new ArrayIterator( $this->addresses );

}

 

/**

* @return string

*/

public function getEmail() {

return $this->email;

}

 

/**

* @return string

*/

public function getName() {

return $this->name;

}

 

/**

* @return Iterator

*/

public function getPhoneIterator() {

return new ArrayIterator( $this->phones );

}

 

/**

* @param string $email

*/

public function setEmail( $email ) {

$this->email = $email;

}

 

/**

* @param string $name

*/

public function setName( $name ) {

$this->name = $name;

}

}

Agora, a classe que representa o recebedor:

 

Recebedor

<?php

/**

* Representação do recebedor na API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Receiver {

/**

* @var string

*/

private $apiKey;

 

/**

* @var string

*/

private $email;

 

/**

* @param string $apiKey

* @param string $email

*/

public function __construct( $apiKey, $email ) {

$this->setApiKey($apiKey);

$this->setEmail($email);

}

 

/**

* @return string

*/

public function getApiKey() {

return $this->apiKey;

}

 

/**

* @return string

*/

public function getEmail() {

return $this->email;

}

 

/**

* @param string $apiKey

*/

public function setApiKey($apiKey) {

$this->apiKey = $apiKey;

}

 

/**

* @param string $email

*/

public function setEmail($email) {

$this->email = $email;

}

}

Com o pagador e recebedor, vamos ver o produto:

 

Product.php

<?php

/**

* Representação de um produto na API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Product {

/**

* @var string

*/

private $description;

 

/**

* @var float

*/

private $discount = 0;

 

/**

* @var string

*/

private $id;

 

/**

* @var float

*/

private $price;

 

/**

* @var integer

*/

private $quantity;

 

/**

* @var float

*/

private $shipping = 0;

 

/**

* @var float

*/

private $weight;

 

/**

* @param string $description

* @param float $price

* @param float $weight

* @param integer $quantity

*/

public function __construct( $description, $price, $weight, $quantity = 1 ) {

$this->setDescription($description);

$this->setPrice($price);

$this->setQuantity($quantity);

$this->setWeight($weight);

}

 

/**

* @return string

*/

public function getDescription() {

return $this->description;

}

 

/**

* @return float

*/

public function getDiscount() {

return $this->discount;

}

 

/**

* @return string

*/

public function getId() {

return $this->id;

}

 

/**

* @return float

*/

public function getPrice() {

return $this->price;

}

 

/**

* @return integer

*/

public function getQuantity() {

return $this->quantity;

}

 

/**

* @return float

*/

public function getShipping() {

return $this->shipping;

}

 

/**

* @return float

*/

public function getWeight() {

return $this->weight;

}

 

/**

* @param string $description

*/

public function setDescription($description) {

$this->description = $description;

}

 

/**

* @param float $discount

*/

public function setDiscount($discount) {

$this->discount = (float) $discount;

}

 

/**

* @param string $id

*/

public function setId($id) {

$this->id = $id;

}

 

/**

* @param float $price

*/

public function setPrice($price) {

$this->price = (float) $price;

}

 

/**

* @param integer $quantity

*/

public function setQuantity($quantity) {

$this->quantity = (int) $quantity;

}

 

/**

* @param float $shipping

*/

public function setShipping($shipping) {

$this->shipping = (float) $shipping;

}

 

/**

* @param float $weight

*/

public function setWeight($weight) {

$this->weight = (float) $weight;

}

}

E agora o carrinho:

Cart.php

<?php

require_once 'Transaction.php';

require_once 'Product.php';

 

/**

* Representação do carrinho na integração com a API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Cart implements Countable, IteratorAggregate {

/**

* @var Buyer

*/

private $buyer;

 

/**

* @var array[Product]

*/

private $products;

 

/**

* @var Receiver

*/

private $receiver;

 

/**

* @var Transaction

*/

private $transaction;

 

/**

* @param Buyer $buyer

* @param Receiver $receiver

*/

public function __construct( Buyer $buyer, Receiver $receiver ) {

$this->buyer = $buyer;

$this->products = array();

$this->receiver = $receiver;

$this->transaction = new Transaction();

}

 

/**

* Adiciona um novo produto ao carrinho.

* @param string $description

* @param float $price

* @param float $weight

* @param integer $quantity

* @param float $shipping

* @param float $discount

* @return Product

*/

public function addNewProduct($description,

$price,

$weight,

$quantity = 1,

$shipping = 0,

$discount = 0) {

 

$product = new Product($description, $price, $weight,$quantity);

$product->setDiscount((float) $discount);

$product->setShipping((float) $shipping);

 

$this->addProduct($product);

 

return $product;

}

 

/**

* @param Product $product

*/

public function addProduct( Product $product ) {

$this->products[] = $product;

$this->transaction->setDiscount(

$this->transaction->getDiscount() + $product->getDiscount()

);

 

$this->transaction->setShipping(

$this->transaction->getShipping() + $product->getShipping()

);

 

$this->transaction->setWeight(

$this->transaction->getWeight() +

($product->getWeight() * $product->getQuantity())

);

}

 

/* (non-PHPdoc)

* @see Countable::count()

*/

public function count() {

return count( $this->products );

 

}

 

/**

* @return Buyer

*/

public function getBuyer() {

return $this->buyer;

}

 

/* (non-PHPdoc)

* @see IteratorAggregate::getIterator()

*/

public function getIterator() {

return new ArrayIterator( $this->products );

}

 

/**

* @return Receiver

*/

public function getReceiver() {

return $this->receiver;

}

 

/**

* @return Transaction

*/

public function getTransaction() {

return $this->transaction;

}

}

Como podemos ver, o carrinho já cria a instância de Transaction. Ela também ajusta alguns valores dessa instância, conforme produtos vão sendo adicionados ao carrinho.

Transaction.php

<?php

/**

* Representação de uma transação na API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class Transaction {

/**

* Método de pagamento padrão

* @var string

*/

const DEFAULT_PAYMENT_METHOD = 'boleto';

 

/**

* Moeda padrão.

* @var string

*/

const DEFAULT_CURRENCY = 'BRL';

 

/**

* @var string

*/

private $currency = Transaction::DEFAULT_CURRENCY;

 

/**

* @var float

*/

private $discount = 0;

 

/**

* @var string

*/

private $paymentMethod = Transaction::DEFAULT_PAYMENT_METHOD;

 

/**

* @var string

*/

private $reference;

 

/**

* @var float

*/

private $shipping = 0;

 

/**

* @var float

*/

private $weight = 0;

 

/**

* @return string

*/

public function getCurrency() {

return $this->currency;

}

 

/**

* @return float

*/

public function getDiscount() {

return $this->discount;

}

 

/**

* @return string

*/

public function getPaymentMethod() {

return $this->paymentMethod;

}

 

/**

* @return string

*/

public function getReference() {

return $this->reference;

}

 

/**

* @return float

*/

public function getShipping() {

return $this->shipping;

}

 

/**

* @return float

*/

public function getWeight() {

return $this->weight;

}

 

/**

* @param string $currency

*/

public function setCurrency($currency) {

$this->currency = $currency;

}

 

/**

* @param float $discount

*/

public function setDiscount($discount) {

$this->discount = $discount;

 

}

 

/**

* @param string $paymentMethod

*/

public function setPaymentMethod($paymentMethod) {

$this->paymentMethod = $paymentMethod;

}

 

/**

* @param string $reference

*/

public function setReference($reference) {

$this->reference = $reference;

}

 

/**

* @param float $shipping

*/

public function setShipping($shipping) {

$this->shipping = $shipping;

}

 

/**

* @param float $weight

*/

public function setWeight($weight) {

$this->weight = $weight;

}

}

Nesse instante temos algumas classes que representam a estrutura hierárquica do XML que devemos enviar para a Akatus. Precisamos agora de um participante responsável por receber essa estrutura e escrever o XML:

AkatusCartMarshaller.php

<?php

/**

* Serialização do carrinho para XML para integração com a API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class AkatusCartMarshaller {

/**

* @return string

*/

public function marshall( Cart $cart ) {

$dom = new DOMDocument('1.0','UTF-8');

$carrinho = $dom->createElement('carrinho');

$carrinho->appendChild($this->createReceiverElement($dom, $cart));

$carrinho->appendChild($this->createBuyerElement($dom, $cart));

$carrinho->appendChild($this->createProductsElement($dom, $cart));

$carrinho->appendChild($this->createTransactionElement($dom, $cart));

 

$dom->appendChild($carrinho);

 

return $dom->saveXML();

}

 

private function createReceiverElement(DOMDocument $dom, Cart $cart) {

$receiver = $cart->getReceiver();

 

$receiverElement = $dom->createElement('recebedor');

$receiverElement->appendChild(

$dom->createElement('api_key', $receiver->getApiKey())

);

$receiverElement->appendChild(

$dom->createElement('email', $receiver->getEmail())

);

 

return $receiverElement;

}

 

private function createBuyerElement(DOMDocument $dom, Cart $cart) {

$buyer = $cart->getBuyer();

 

$buyerElement = $dom->createElement('pagador');

$buyerElement->appendChild(

$dom->createElement('nome', $buyer->getName())

);

$buyerElement->appendChild(

$dom->createElement('email', $buyer->getEmail())

);

$addressesElement = $dom->createElement('enderecos');

$buyerElement->appendChild($addressesElement);

 

foreach ( $buyer->getAddressIterator() as $address ) {

$addressesElement->appendChild(

$this->createAddressElement($dom, $address)

);

}

 

$phonesElement = $dom->createElement('telefones');

$buyerElement->appendChild($phonesElement);

 

foreach ($buyer->getPhoneIterator() as $phone ) {

$phonesElement->appendChild(

$this->createPhoneElement($dom, $phone)

);

}

 

return $buyerElement;

}

 

private function createAddressElement(DOMDocument $dom, Address $address) {

$addressElement = $dom->createElement('endereco');

$addressElement->appendChild(

$dom->createElement('tipo', $address->getType())

);

$addressElement->appendChild(

$dom->createElement('logradouro', $address->getStreet())

);

$addressElement->appendChild(

$dom->createElement('numero', $address->getNumber())

);

$addressElement->appendChild(

$dom->createElement('bairro', $address->getNeighborhood())

);

$addressElement->appendChild(

$dom->createElement('cidade', $address->getCity())

);

$addressElement->appendChild(

$dom->createElement('estado', $address->getState())

);

$addressElement->appendChild(

$dom->createElement('pais', $address->getCountry())

);

$addressElement->appendChild(

$dom->createElement('cep', $address->getZip())

);

 

return $addressElement;

}

 

private function createPhoneElement(DOMDocument $dom, Phone $phone) {

$phoneElement = $dom->createElement('phone');

$phoneElement->appendChild(

$dom->createElement('tipo', $phone->getType())

);

$phoneElement->appendChild(

$dom->createElement('numero', $phone->getNumber())

);

 

return $phoneElement;

}

 

private function createProductsElement(DOMDocument $dom, Cart $cart) {

$productsElement = $dom->createElement('produtos');

 

foreach ($cart->getIterator() as $product) {

$productsElement->appendChild(

$this->createProductElement($dom, $product)

);

}

 

return $productsElement;

}

 

private function createProductElement(DOMDocument $dom, Product $product) {

$productElement = $dom->createElement('produto');

$productElement->appendChild(

$dom->createElement('codigo', $product->getId())

);

$productElement->appendChild(

$dom->createElement('descricao', $product->getDescription())

);

$productElement->appendChild(

$dom->createElement('quantidade', $product->getQuantity())

);

$productElement->appendChild(

$dom->createElement('preco', $product->getPrice())

);

$productElement->appendChild(

$dom->createElement('peso', $product->getWeight())

);

$productElement->appendChild(

$dom->createElement('frete', $product->getShipping())

);

$productElement->appendChild(

$dom->createElement('desconto', $product->getDiscount())

);

 

return $productElement;

}

 

private function createTransactionElement(DOMDocument $dom, Cart $cart) {

$transaction = $cart->getTransaction();

$transactionElement = $dom->createElement('transacao');

$transactionElement->appendChild(

$dom->createElement('desconto_total', $transaction->getDiscount())

);

$transactionElement->appendChild(

$dom->createElement('peso_total', $transaction->getWeight())

);

$transactionElement->appendChild(

$dom->createElement('frete_total', $transaction->getShipping())

);

$transactionElement->appendChild(

$dom->createElement('moeda', $transaction->getCurrency())

);

$transactionElement->appendChild(

$dom->createElement('referencia', $transaction->getReference())

);

$transactionElement->appendChild(

$dom->createElement('meio_de_pagamento', $transaction->getPaymentMethod())

);

 

return $transactionElement;

}

}

O método marshall() vai receber o carrinho e retornar um XML. Com esse XML faremos o POST para a Akatus:

AkatusCartApi.php

<?php

require_once 'AkatusCartMarshaller.php';

require_once 'AkatusCartResponseUnMarshaller.php';

 

/**

* Integração com a API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class AkatusCartApi {

/**

* Endpoint de produção

* @var string

*/

const ENDPOINT = 'https://www.akatus.com/api/v1/carrinho.xml';

 

/**

* Endpoint de testes

* @var string

*/

const TEST_ENDPOINT = 'https://dev.akatus.com/api/v1/carrinho.xml';

 

/**

* @var AkatusCartMarshaller

*/

private $marshaller;

 

/**

* @var AkatusCartResponseUnMarshaller

*/

private $unmarshaller;

 

/**

* @var boolean

*/

private $test = false;

 

/**

* @param AkatusCartMarshaller $marshaller

*/

public function __construct(AkatusCartMarshaller $marshaller = null,

AkatusCartResponseUnMarshaller $unmarshaller = null ) {

 

if ( $marshaller == null ) {

$marshaller = new AkatusCartMarshaller();

}

 

if ( $unmarshaller == null ) {

$unmarshaller = new AkatusCartResponseUnMarshaller();

}

 

$this->marshaller = $marshaller;

$this->unmarshaller = $unmarshaller;

}

 

/**

* Executa a operação.

* @param Cart $cart O carrinho que será enviado.

* @return AkatusCartResponse A resposta do serviço.

* @throws RuntimeException

*/

public function execute( Cart $cart ) {

$endpoint = $this->test ? self::TEST_ENDPOINT: self::ENDPOINT;

$curl = curl_init();

 

curl_setopt($curl, CURLOPT_URL, $endpoint );

curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false );

curl_setopt($curl, CURLOPT_RETURNTRANSFER, true );

curl_setopt($curl, CURLOPT_POST, true );

curl_setopt($curl, CURLOPT_POSTFIELDS, $this->marshaller->marshall($cart));

 

$response = curl_exec( $curl );

$errno = curl_errno($curl);

$error = curl_error($curl);

 

curl_close($curl);

 

if ($errno != 0) {

throw new RuntimeException($error, $errno);

}

 

libxml_use_internal_errors(false);

 

$dom = new DOMDocument();

$dom->preserveWhiteSpace = false;

$dom->loadXML($response);

 

$libxmlErrors = libxml_get_errors();

 

if (count($libxmlErrors) != 0) {

$e = null;

 

foreach ( $libxmlErrors as $libxmlError ) {

$e = new UnexpectedValueException($libxmlError->message,

$libxmlError->code, $e);

}

 

libxml_clear_errors();

 

throw new RuntimeException( 'XML error', null, $e );

} else {

try {

$response = $this->unmarshaller->unmarshall($dom);

 

if ($response->getStatus()=='erro') {

throw new RuntimeException($response->getDescription());

}

 

return $response;

} catch (UnexpectedValueException $e) {

throw new RuntimeException('Unmarshall problem', null, $e);

}

}

}

 

/**

* Define a execução da operação no ambiente de testes.

* @return AkatusCartApi

*/

public function test() {

$this->test = true;

return $this;

}

}

O método execute fará todo o trabalho, receberá a instância de Cart, usará nosso serializador para criar o XML, enviará o POST para a Akatus e usará o deserializador para criar uma instância de AkatusCartResponse, que conterá a representação do seguinte XML:

XML em caso de sucesso

<?xml version="1.0" encoding="UTF-8"?>

<resposta>

<carrinho>37b4529f-6982-4c77-ba7d-f925113f55e2</carrinho>

<status>Aguardando Pagamento</status>

<transacao>1f5cbb15-9695-4947-9154-19d6b08cf816</transacao>

<url_retorno>http://www.akatus.com/boleto/MWY1Y2JiMTUtOTY5NS00OTQ3LTkxNTQtMTlkNmIwOGNmODE2.html</url_retorno>

</resposta>

XML em caso de falha

<?xml version="1.0" encoding="UTF-8"?>

<resposta>

<status>erro</status>

<descricao>descrição do erro</descricao>

</resposta>

Para poder criar a instância de AkatusCartResponse, precisamos do serializador, que segue abaixo:

AkatusCartResponseUnMarshaller.php

<?php

require_once 'AkatusCartResponse.php';

 

**

* Deserialização da resposta XML da integração com a API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class AkatusCartResponseUnMarshaller {

/**

* @param DOMDocument $dom

* @return AkatusCartResponse

* @throws UnexpectedValueException

*/

public function unMarshall(DOMDocument $dom) {

$akatusCartResponse = new AkatusCartResponse();

$akatusCartResponse->setStatus($this->getStatus($dom));

$akatusCartResponse->setDescription($this->getDescription($dom));

$akatusCartResponse->setCart($this->getCart($dom));

$akatusCartResponse->setTransaction($this->getTransaction($dom));

$akatusCartResponse->setReturnUrl($this->getReturnUrl($dom));

 

return $akatusCartResponse;

}

 

private function getNodeValue(DOMDocument $dom, $tagName) {

$element = $dom->getElementsByTagName($tagName)->item(0);

 

return $element == null ? null : $element->nodeValue;

}

 

private function getStatus(DOMDocument $dom) {

$status = $this->getNodeValue($dom, 'status');

 

if ( $status == null ) {

throw new UnexpectedValueException('Invalid XML');

}

 

return $status;

}

 

private function getCart(DOMDocument $dom) {

return $this->getNodeValue($dom, 'carrinho');

}

 

private function getDescription(DOMDocument $dom) {

return $this->getNodeValue($dom,'descricao');

}

 

private function getTransaction(DOMDocument $dom) {

return $this->getNodeValue($dom,'transacao');

}

 

private function getReturnUrl(DOMDocument $dom) {

return $this->getNodeValue($dom,'url_retorno');

}

}

O método unMarshall receberá uma instância de DOMDocument, que contém os nós do XML de resposta, ela retornará a instância de AkatusCartResponse, cuja classe segue abaixo:

AkatusCartResponse.php

<?php

/**

* Resposta da API da Akatus

* @author João Batista Neto <neto.joaobatista@gmail.com.br>

*/

class AkatusCartResponse {

/**

* @var string

*/

private $cart;

 

/**

* @var string

*/

private $description;

 

/**

* @var string

*/

private $returnUrl;

 

/**

* @var string

*/

private $status;

 

/**

* @var string

*/

private $transaction;

 

/**

* @return string

*/

public function getCart() {

return $this->cart;

}

 

/**

* @return string

*/

public function getDescription() {

return $this->description;

}

 

/**

* @return string

*/

public function getReturnUrl() {

return $this->returnUrl;

}

 

/**

* @return string

*/

public function getStatus() {

return $this->status;

}

 

/**

* @return string

*/

public function getTransaction() {

return $this->transaction;

}

 

/**

* @param string $cart

*/

public function setCart($cart) {

$this->cart = $cart;

}

 

/**

* @param string $description

*/

public function setDescription($description) {

$this->description = $description;

}

 

/**

* @param string $returnUrl

*/

public function setReturnUrl($returnUrl) {

$this->returnUrl = $returnUrl;

}

 

/**

* @param string $status

*/

public function setStatus($status) {

$this->status = $status;

}

 

/**

* @param string $transaction

*/

public function setTransaction($transaction) {

$this->transaction = $transaction;

}

}

Nesse instante, temos todos os participantes para fazer a integração, para usar tudo isso basta fazer o seguinte:

 

<?php

require 'AkatusCartApi.php';

require 'Receiver.php';

require 'Buyer.php';

require 'Cart.php';

 

receiver = new Receiver('XXX', 'user@domain.com');

 

//dados do comprador

$buyer = new Buyer('Jose Antonio', 'ze@antonio.com.br');

 

//telefone do comprador

$buyer->addNewPhone('residencial','1699999999');

 

//endereço do comprador

$address = $buyer->createAddress('entrega');

$address->setCity('Cidade');

$address->setCountry('Brasil');

$address->setNeighborhood('Bairro');

$address->setNumber(0);

$address->setState('estado');

$address->setStreet('Rua dos bobos');

$address->setZip('00000000');

 

//carrinho e os produtos comprados

$cart = new Cart($buyer, $receiver);

$cart->addNewProduct('Produto 1', 148.99, 8.5, 1, 16.45, 10)->setId('UFC1403');

$cart->addNewProduct('Produto 3', 148.99, 8.5, 1, 16.45, 10)->setId('UFC1403');

 

cart->getTransaction()->setReference('abc1234');

 

try {

$akatusCartApi = new AkatusCartApi();

 

//o método test() indica que estamos usando o ambiente de testes,

//para usar o ambiente de produção, basta não suar o método test.

var_dump( $akatusCartApi->test()->execute($cart) );

} catch (RuntimeException $e) {

//opz, alguma coisa saiu errada.

//log...

 

echo $e->getMessage();

}

E pronto, o método execute() retornará a instância de AkatusCartResponse que, se tudo estiver okay, podemos usar o método getReturnUrl() para redirecionar o cliente.

O código foi colocado no github: https://github.com/A.../codesample_api

Para clonar:

git clone git://github.com/Akatus/codesample_api.git

 

 

 

http://imasters.com.br/artigo/24690/akatus/como-integrar-o-carrinho-de-compras-ao-sistema-akatus-usando-php