Ir para o conteúdo


Foto:

Integração do carrinho em PHP


  • Por favor, faça o login para responder
9 respostas neste tópico

#1 João Batista Neto

João Batista Neto

    Verschränkung

  • Administrators
  • 29 posts

Postado 26 February 2013 - 08:24 PM

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:

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.

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.

produtos: Esse nó representa o carrinho de compras do cliente. Todos os produtos, seus preços e suas respectivas quantidades serão colocados aqui.

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:

Posted Image

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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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
<?php
/**
 * Representação do recebedor na API da Akatus
 * @author       João Batista Neto &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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 &lt;neto.joaobatista@gmail.com.br&gt;
 */
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


#2 WennderT

WennderT

    Newbie

  • Members
  • Pip
  • 1 posts

Postado 14 March 2013 - 07:15 AM

Arruma o link do Github por favor.

#3 AkatusConnect

AkatusConnect

    Akatus Connect

  • Administrators
  • 140 posts

Postado 18 March 2013 - 01:09 PM

Esse é o link.

https://github.com/A.../codesample_api

#4 prmas

prmas

    Newbie

  • Members
  • Pip
  • 8 posts

Postado 28 August 2013 - 04:15 PM

Segui todos os passos.

Quando executo a rotina, minha página fica em branco.

O que pode estar acontecendo?

#5 prmas

prmas

    Newbie

  • Members
  • Pip
  • 8 posts

Postado 28 August 2013 - 04:19 PM

Decobri que quando executa a linha

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

a tela fica em branco!

Como resolver isso?

#6 Diego Souza

Diego Souza

    Advanced Member

  • Members
  • PipPipPip
  • 112 posts

Postado 29 August 2013 - 11:28 AM

Conseguiu resolver prmas? Você provavelmente não importou a classe Buyer corretamente.

#7 eronventer

eronventer

    Newbie

  • Members
  • Pip
  • 9 posts

Postado 19 March 2014 - 01:57 AM

Estou hospedando na UOLHost, até ontem parecia estar tudo funcionando, porém hoje pela manhã ocorreu o erro abaixo:
 

Warning: DOMDocument::loadXML() [domdocument.loadxml]: Opening and ending tag mismatch: hr line 5 and body in Entity, line: 6 in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 87

Warning: DOMDocument::loadXML() [domdocument.loadxml]: Opening and ending tag mismatch: body line 3 and html in Entity, line: 7 in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 87

Warning: DOMDocument::loadXML() [domdocument.loadxml]: Premature end of data in tag html line 1 in Entity, line: 8 in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 87

Fatal error: Wrong parameters for Exception([string $exception [, long $code ]]) in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 112


#8 Diego Souza

Diego Souza

    Advanced Member

  • Members
  • PipPipPip
  • 112 posts

Postado 31 March 2014 - 11:56 AM

 

Estou hospedando na UOLHost, até ontem parecia estar tudo funcionando, porém hoje pela manhã ocorreu o erro abaixo:
 

Warning: DOMDocument::loadXML() [domdocument.loadxml]: Opening and ending tag mismatch: hr line 5 and body in Entity, line: 6 in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 87

Warning: DOMDocument::loadXML() [domdocument.loadxml]: Opening and ending tag mismatch: body line 3 and html in Entity, line: 7 in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 87

Warning: DOMDocument::loadXML() [domdocument.loadxml]: Premature end of data in tag html line 1 in Entity, line: 8 in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 87

Fatal error: Wrong parameters for Exception([string $exception [, long $code ]]) in /var/www/html/pizzadopao.com.br/web/preview/akatus/php/AkatusCartApi.php on line 112

 

Consegue imprimir o response que está sendo passado para o loadXML?

Qual é a versão de PHP que você está rodando?



#9 eronventer

eronventer

    Newbie

  • Members
  • Pip
  • 9 posts

Postado 08 April 2014 - 05:03 PM

Consegue imprimir o response que está sendo passado para o loadXML?

Qual é a versão de PHP que você está rodando?

 

Diego,

 

Desculpe a demora na resposta, mas acredito que tenha sido algumas instabilidade, pois horas depois voltou a funcionar perfeitamente.



#10 Diego Souza

Diego Souza

    Advanced Member

  • Members
  • PipPipPip
  • 112 posts

Postado 09 April 2014 - 10:51 AM

Diego,

 

Desculpe a demora na resposta, mas acredito que tenha sido algumas instabilidade, pois horas depois voltou a funcionar perfeitamente.

 

Ah, então beleza.

O importante é que deixou o feedback aqui p/ o resto do pessoal.

 

Valeu.






0 usuário(s) está(ão) lendo esta discussão

0 membro(s), 0 visitante(s) e 0 membros anônimo(s)