init commit

api/app/Utils/Sms/autoload.php

@@ -0,0 +1,12 @@
+<?php
+
+ require(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'util' . DIRECTORY_SEPARATOR . 'ApiClassLoader.php');
+
+ $packages = array(
+     dirname(__FILE__) . DIRECTORY_SEPARATOR .'util', 
+     dirname(__FILE__) . DIRECTORY_SEPARATOR .'rest-client', 
+     dirname(__FILE__) . DIRECTORY_SEPARATOR .'model'
+  );
+ 
+ ApiClassLoader::register($packages);
+

api/app/Utils/Sms/model/JsonConverter.php

@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * Classe responsável por fazer as conversões para o formato json utilizados no webservice.
+ */
+class JsonConverter {
+    
+    /**
+     * Retorna a representação json de um envio simples.
+     * @param Sms $sms mensagem a ser enviada
+     * @param int $aggregateId id do agrupador
+     * @return string|null string no formato json
+     */
+    public static function smsToJson($sms, $aggregateId=null){  
+        $baseJson=self::getJsonBase($sms, $aggregateId);
+        $json = '{"sendSmsRequest":'.$baseJson.'}';
+        return $json;
+    }
+        
+    /**
+     * Retorna a representação json de um envio múltiplo.
+     * @param array $smsList lista de mensagens SMS a serem enviadas.
+     * @param int $aggregateId id do agrupador
+     * @return string|null
+     */
+    public static function smsListToJson($smsList, $aggregateId=null){       
+        if(is_array($smsList)){
+            $json = '{"sendSmsMultiRequest":{';            
+            if($aggregateId!=null){
+                $json .= '"aggregateId":'.$aggregateId.',';
+            }
+            $json .= '"sendSmsRequestList":[';
+            foreach($smsList as $sms){               
+                $json .= self::getJsonBase($sms).',';                
+            }      
+            $json = rtrim($json, ',');
+            $json .= ']}}';
+            return $json;            
+        }
+        return null;
+        
+    }
+    
+    /**
+     * 
+     * @param Sms $sms
+     * @param int $aggregateId
+     * @return string
+     */
+    private static function getJsonBase($sms, $aggregateId=null){
+        $obj = new stdClass();       
+        if($sms->getId()!=null){
+            $obj->id=$sms->getId(); 
+        } 
+        if($sms->getMsg()!=null){
+            $obj->msg=$sms->getMsg();
+        }
+        if($sms->getTo()!=null){
+            $obj->to=$sms->getTo();
+        }
+        if($sms->getCallbackOption()!=null){
+            $obj->callbackOption=$sms->getCallbackOption();
+        }
+        if($sms->getSchedule()!=null){
+            $obj->schedule=$sms->getSchedule();
+        }
+        if($sms->getFrom()!=null){
+            $obj->from=$sms->getFrom();
+        }
+        if($sms->getExpiryDate()!=null){
+            $obj->expiryDate=$sms->getExpiryDate();
+        }
+        if($sms->getTimeToLive()!=null){
+            $obj->timetoLive=$sms->getTimeToLive();
+        }    
+        if($aggregateId!=null){
+            $obj->aggregateId=$aggregateId;
+        }
+        
+        return json_encode($obj);
+        
+    }
+    
+}

api/app/Utils/Sms/model/Sms.php

@@ -0,0 +1,155 @@
+<?php
+
+/**
+ * Representa uma mensagem SMS.
+ */
+class Sms {
+    
+    /**     
+     * @var string Id da mensagem. Este atributo é opcional 
+     */
+    private $id=null;
+    /**     
+     * @var string Celular de destino. Este atributo é obrigatório 
+     */
+    private $to=null;
+    /**     
+     * @var string Mensagem a ser enviada. Este atributo é obrigatório 
+     */
+    private $msg=null;   
+    /**     
+     * @var string Remetente da mensagem. Este atributo é obrigatório para alguns tipos de conta 
+     */
+    private $from=null;
+    /**     
+     * @var string Tipo do callback da mensagem, pode ser NONE(não será retornado nenhum callback de status para a mensagem)
+     * FINAL(serão retornados apenas os callbacks de status final para a mensagem) e 
+     * ALL(todos os callbacks de status serão retornados para a mensagem). 
+     */
+    private $callbackOption=self::CALLBACK_NONE;    
+    /**     
+     * @var string Data do agendamento da mensagem no formato descrito na ISO 8601(yyyy-MM-dd'T'HH:mm:ss).
+     * Este atributo é opcional e caso não seja informado serão usados a data e a hora do momento do envio.
+     */    
+    private $schedule=null;      
+    private $timeToLive=null;
+    private $expiryDate=null;
+    
+    const CALLBACK_NONE="NONE";
+    const CALLBACK_FINAL="FINAL";
+    const CALLBACK_ALL="ALL";
+    
+    /**     
+     * Método de acesso ao id da mensagem.
+     * @return string Id da mesangem.
+     */
+    public function getId() {
+        return $this->id;
+    }
+
+    /**     
+     * Método modificador de acesso do id da mensagem.
+     * @param string $id Id da mensagem. 
+     */
+    public function setId($id) {
+        $this->id = $id;
+    }
+    
+    /**     
+     * Método de acesso ao remetente da mensagem.
+     * @return string Remetente da mensagem.
+     */
+    public function getFrom() {
+        return $this->from;
+    }
+
+    /**
+     * Método modificador de acesso do remetente da mensagem.
+     * @param string $from Remetente da mensagem.
+     */
+    public function setFrom($from) {
+        $this->from = $from;
+    }
+    
+    /**     
+     * Método de acesso ao celular de destino da mensagem.
+     * @return string Destino da mensagem
+     */
+    public function getTo() {
+        return $this->to;
+    }
+
+    /**     
+     * Método modificador de acesso do celular de destino da mensagem.
+     * @param string $to Destino da mensagem
+     */
+    public function setTo($to) {
+        $this->to = $to;
+    }
+    
+    /**     
+     * Método de acesso ao conteúdo da mensagem.
+     * @return string Conteúdo da mensagem.
+     */
+    public function getMsg() {
+        return $this->msg;
+    }
+
+    /**     
+     * Método modificador de acesso do conteúdo da mensagem.
+     * @param string $msg Conteúdo da mensagem.
+     */
+    public function setMsg($msg) {
+        $this->msg = $msg;
+    }
+    
+    /**   
+     * Método de acesso para a data de agendamento da mensagem.  
+     * @return string Data de agendamento da mensagem no formato ISO 8601(yyyy-MM-dd'T'HH:mm:ss)
+     */
+    public function getSchedule() {
+        return $this->schedule;
+    }
+
+    /**     
+     * @param string $schedule método modificador de acesso para a data de agendamento da mensagem.
+     * O formato informado deverá ser o mesmo descrito na ISO 8601(yyyy-MM-dd'T'HH:mm:ss)
+     */
+    public function setSchedule($schedule) {
+        $this->schedule = $schedule;
+    }
+    
+    /**     
+     * Método de acesso para o tipo de callback da mensagem.
+     * @return string Tipo do callback da mensagem. 
+     */
+    public function getCallbackOption() {
+        return $this->callbackOption;
+    }
+
+    /**     
+     * Método modificador de acesso do tipo de callback da mensagem. 
+     * @param string $callbackOption Tipo de do callback da mensagem. 
+     * Poderá ser NONE, FINAL, ou ALL. 
+     */
+    public function setCallbackOption($callbackOption) {
+        $this->callbackOption = $callbackOption;
+    }  
+    
+    public function getTimeToLive() {
+        return $this->timeToLive;
+    }
+
+    public function setTimeToLive($timeToLive) {
+        $this->timeToLive = $timeToLive;
+    }
+    
+    public function getExpiryDate() {
+        return $this->expiryDate;
+    }
+
+    public function setExpiryDate($expiryDate) {
+        $this->expiryDate = $expiryDate;
+    }
+    
+}

api/app/Utils/Sms/model/SmsFacade.php

@@ -0,0 +1,237 @@
+<?php
+/** 
+ * Classe que serve como fachada para acesso ao webservice de envio e consulta de mensagens.   
+ */
+class SmsFacade {
+    
+   
+    /**     
+     * @var RestClient 
+     */    
+    private $client;
+    /**     
+     * @var string 
+     */
+    private $accountAlias;
+    /**     
+     * @var string 
+     */
+    private $accountPassword;
+    /**
+     *
+     * @var string  
+     */
+    private $webServiceUrl;
+   
+    const DEFAULT_WEBSERVICE_URL="https://api-rest.zenvia360.com.br";
+    
+   
+    
+    /**     
+     * @param string $accountAlias Alias da conta que será utilizada para autenticação no webservice.
+     * @param string $accountPassword Senha da conta que será utilizada para autenticação no webservice.
+     * @param string $webServiceUrl URL do webservice. Caso seja nulo será o usado o valor de @see SmsFacade::DEFAULT_WEBSERVICE_URL 
+     */
+    public function __construct($accountAlias, $accountPassword, $webServiceUrl=null) {
+        $this->accountAlias = $accountAlias;                
+        $this->accountPassword = $accountPassword;                
+        if($webServiceUrl==null){            
+            $this->webServiceUrl=self::DEFAULT_WEBSERVICE_URL;
+        }
+        else{
+            $this->webServiceUrl=$webServiceUrl;
+        }
+        $this->client=new RestClient();
+        
+    }
+    
+    /**
+     * Faz um envio de mensagem simples.
+     * @param Sms $sms O SMS que deverá ser enviado. Este parâmetro é obrigatório
+     * @param int $aggregateId O id do agrupador que deverá ser relacionado ao envio. 
+     * Este parâmetro será obrigatório apenas se a conta possuir a configuração de agrupador habilitada.
+     * @return SmsResponse Resposta com o status e o detalhe da mensagem enviada
+     * @throws RuntimeException
+     */    
+    public function send($sms, $aggregateId=null){
+        $headers = $this->getBaseHeaders();    
+        $json = JsonConverter::smsToJson($sms, $aggregateId);                
+        $client = $this->client;
+        $url=$this->webServiceUrl."/services/send-sms";
+        $response = $client->post($url, $json, $headers);    
+        $this->checkResponse($response);
+        $obj = json_decode($response->getBody());
+        $sendSmsResponse=$obj->sendSmsResponse;    
+        $smsResponse = new SmsResponse($sendSmsResponse->statusCode,  $sendSmsResponse->statusDescription,  $sendSmsResponse->detailCode,  $sendSmsResponse->detailDescription);
+        return $smsResponse;
+    }
+    
+    /**
+     * Faz um envio de mensagem múltiplo.
+     * @param array $smsList Array contendo uma lista de SMS para serem enviados.Este parâmetro é obrigatório
+     * @param int $aggregateId O id do agrupador que deverá ser relacionado ao envio. 
+     * Este parâmetro será obrigatório apenas se a conta possuir a configuração de agrupador habilitada.
+     * @return array Lista de objetos do tipo SmsResponse.
+     * @throws RuntimeException
+     */
+    public function sendMultiple($smsList, $aggregateId=null){
+        $headers = $this->getBaseHeaders();    
+        $json = JsonConverter::smsListToJson($smsList, $aggregateId);       
+        $client = $this->client;
+        $url=$this->webServiceUrl."/services/send-sms-multiple";
+        $response = $client->post($url, $json, $headers);
+        $this->checkResponse($response);
+        $obj = json_decode($response->getBody());
+        $responses = array();                
+        if(is_object($obj)){
+            foreach($obj->sendSmsMultiResponse->sendSmsResponseList as $sendSmsResponse){
+                $smsResponse = new SmsResponse($sendSmsResponse->statusCode,  $sendSmsResponse->statusDescription,  $sendSmsResponse->detailCode,  $sendSmsResponse->detailDescription);
+                array_push($responses, $smsResponse);
+            }
+        }
+        return $responses;
+    }
+    
+    /**
+     * Faz o cancelamento de uma mensagem.
+     * @param string $id Id da mensagem que deverá ser cancelada. Este parâmetro é obrigatório.
+     * @return SmsResponse Resposta com o status e o detalhe da operação de cancelamento.
+     * @throws RuntimeException
+     */    
+    public function cancel($id){
+        $headers = $this->getBaseHeaders();           
+        $client = $this->client;
+        $url=$this->webServiceUrl."/services/cancel-sms/".$id;        
+        $response = $client->post($url, null, $headers);    
+        $this->checkResponse($response);
+        $obj = json_decode($response->getBody()); 
+        $cancelSmsResp=$obj->cancelSmsResp;            
+        $smsResponse = new SmsResponse($cancelSmsResp->statusCode,  $cancelSmsResp->statusDescription,  $cancelSmsResp->detailCode,  $cancelSmsResp->detailDescription);
+        return $smsResponse;
+    }
+    
+    /**
+     * Faz a consulta do status atual de uma mensagem enviada. 
+     * @param string $id Id da mensagem a ser consultada. Este parâmetro é obrigatório.     
+     * @return SmsStatusResponse Resposta com o status e o detalhe da mensagem a ser consultada.
+     * @throws RuntimeException 
+     */    
+    public function getStatus($id){
+        $headers = $this->getBaseHeaders();                                    
+        $headers['Content-Type']=null;        
+        $client = $this->client;
+        $url=$this->webServiceUrl."/services/get-sms-status/".$id;
+        $response = $client->get($url, $headers);   
+        $this->checkResponse($response);
+        $obj = json_decode($response->getBody());        
+        $statusSms=$obj->getSmsStatusResp;           
+        $statusResponse = new SmsStatusResponse();
+        $statusResponse->setStatusCode($statusSms->statusCode);
+        $statusResponse->setStatusDescription($statusSms->statusDescription);
+        $statusResponse->setDetailCode($statusSms->detailCode);
+        $statusResponse->setDetailDescription($statusSms->detailDescription);
+        $statusResponse->setId($statusSms->id);
+        $statusResponse->setReceived($statusSms->received);
+        $statusResponse->setShortCode($statusSms->shortcode);
+        $statusResponse->setMobileOperatorName($statusSms->mobileOperatorName);        
+        return $statusResponse;
+    }
+    
+    /**
+     * Faz a listagem de mensagens recebidas que ainda não foram consultadas.
+     * Os SMS recebidos retornados por esta consulta só poderão ser consultados apenas uma única vez  
+     * de forma que se um SMS é retornado nesta consulta o mesmo não será listado novamente em uma consulta posterior.
+     * Caso seja necessário consultar as mesmas mensagens recebidas múltiplas vezes, deverá ser usado o método @see SmsFacade::searchMessagesReceived
+     * @return SmsReceivedResponse Resposta com as mensagens recebidas.
+     * @throws RuntimeException 
+     */
+    public function listMessagesReceived(){
+        $headers = $this->getBaseHeaders();           
+        $client = $this->client;
+        $url=$this->webServiceUrl."/services/received/list";
+        $response = $client->post($url, null, $headers);      
+        $this->checkResponse($response);
+        $smsResponse = $this->parseMoList($response->getBody());     
+        return $smsResponse;
+    }
+    
+   /**
+    * Faz a consulta de todas as mensagens recebidas no período informado. Este método deverá 
+    * retornar todas as mensagens recebidas que coincidirem com o filtro passado 
+    * independentemente se as mesmas já terem sido consultadas anteriormente.  
+    * @param string $startPeriod Data inicial no formato descrito na ISO 8601(yyyy-MM-dd'T'HH:mm:ss). Este parâmetro é obrigatório.
+    * @param string $endPeriod Data final no formato descrito na ISO 8601(yyyy-MM-dd'T'HH:mm:ss). Este parâmetro é obrigatório. 
+    * @param string $mobile Celular a ser utilizado na pesquisa de mensagens recebidas.
+    * @param $smsId $smsId Id da mensagem de origem a ser utilizado na pesquisa de mensagens recebidas.
+    * @return SmsReceivedResponse Resposta com as mensagens recebidas.
+    * @throws RuntimeException 
+    */
+    public function searchMessagesReceived($startPeriod, $endPeriod, $mobile=null, $smsId=null ){
+        $headers = $this->getBaseHeaders();
+        $headers['Content-Type']=null;
+         $client = $this->client;
+        $url=$this->webServiceUrl."/services/received/search/".rawurlencode($startPeriod).'/'.rawurlencode($endPeriod).'?';              
+        if($mobile!=null){
+            $url .='mobile='.rawurlencode($mobile).'&';                    
+        }
+        if($smsId!=null){
+            $url .='mtId='.rawurlencode($smsId);                    
+        } 
+        $url = rtrim($url, '&');
+        $response = $client->get($url, $headers);  
+        $this->checkResponse($response);
+        $smsResponse = $this->parseMoList($response->getBody());
+        return $smsResponse;
+    }
+    
+    /**
+     * Faz o parse do json de resposta com a representação da lista de mensagens recebidas do webservice para um objeto @see SmsReceivedResponse. 
+     * @param string $jsonResponse Json retornado pelo webservice.
+     * @return SmsReceivedResponse Resposta com as mensagens recebidas.
+     */
+    private function parseMoList($jsonResponse){
+        $obj = json_decode($jsonResponse);          
+        $smsResponse = new SmsReceivedResponse($obj->receivedResponse->statusCode, $obj->receivedResponse->statusDescription, $obj->receivedResponse->detailCode, $obj->receivedResponse->detailDescription);
+        if( is_array($obj->receivedResponse->receivedMessages) && count($obj->receivedResponse->receivedMessages) > 0  ){
+            foreach($obj->receivedResponse->receivedMessages as $message){
+                $receivedMessage = new SmsReceived();
+                $receivedMessage->setBody($message->body);
+                $receivedMessage->setDateReceived($message->dateReceived);
+                $receivedMessage->setId($message->id);
+                $receivedMessage->setMobile($message->mobile);
+                $receivedMessage->setMobileOperatorName($message->mobileOperatorName);
+                $receivedMessage->setShortCode($message->shortcode);
+                $receivedMessage->setSmsOriginId($message->mtId);
+                $smsResponse->addReceivedMessage($receivedMessage);
+            }
+        }  
+        return $smsResponse;        
+    }    
+    
+    /**
+     * Verifica se o serviço retornou uma resposta válida.
+     * @param HttpResponse $response
+     * @throws RuntimeException Se o servidor restornou uma resposta inválida.
+     */
+    private function checkResponse($response){
+        if($response->getHttpCode()>= 400){
+            $exceptionMessage=$response->getHttpCode().' - '.$response->getHttpDescription()." \nServer Response\n".$response->getBody()."."."\nApi Request\n[".$response->getRequestOrigin();            
+            throw new RuntimeException($exceptionMessage);   
+        }
+    }
+      
+    /**
+     * Headers base para as requisições.
+     * @return array Array associativo com os headers comuns das requisições.
+     */
+    private function getBaseHeaders(){
+        $accountAlias=$this->accountAlias;
+        $accountPassword=$this->accountPassword;        
+        $headers = array(
+                        'Accept'=>'application/json',
+                        'Content-Type'=>'application/json; charset=UTF-8',
+                        'Authorization'=> 'Basic '.  base64_encode($accountAlias.':'.$accountPassword)
+                    );
+        return $headers;
+    }
+}

api/app/Utils/Sms/model/SmsReceived.php

@@ -0,0 +1,124 @@
+<?php
+
+/**
+ * Classe que representa uma mensagem recebida.
+ */
+class SmsReceived {
+    
+   /**    
+    * @var long Id da mensagem recebida.
+    */
+    private $id;
+    /**
+     * @var string Data de recebimento da mensagem.
+     */
+    private $dateReceived;
+    /**     
+     * @var string Celular da mensagem recebida.
+     */
+    private $mobile;
+    /**
+     * @var string Conteúdo da mensagem recebida.
+     */
+    private $body;
+    /**
+     * @var string Shortcode da mensagem recebida.
+     */
+    private $shortCode;
+    /**
+     * @var string Nome da operadora do celular da mensagem recebida.
+     */
+    private $mobileOperatorName;
+    /**
+     * @var string Id da mensagem que originou a mensagem recebida.
+     */
+    private $smsOriginId;
+    
+    /**
+     * Método acessor ao id da mensagem.
+     * @return long Id da mensagem recebida
+     */
+    public function getId() {
+        return $this->id;
+    }
+
+    /**
+     * Método acessor para a data de recebimento da mensagem.
+     * @return string Data de recebimento da mensagem no formato ISO 8601(yyyy-MM-dd'T'HH:mm:ss).  
+     */
+    public function getDateReceived() {
+        return $this->dateReceived;
+    }
+
+    /**
+     * Método acessor ao celular da mensagem recebida.
+     * @return string Celular da mensagem recebida
+     */
+    public function getMobile() {
+        return $this->mobile;
+    }
+
+    /**
+     * Método acessor ao conteúdo da mensagem recebida.
+     * @return string Conteúdo da mensagem recebida
+     */
+    public function getBody() {
+        return $this->body;
+    }
+
+    /**
+     * Método acessor ao Shortcode da mensagem recebida.
+     * @return string Shortcode da mensagem recebida
+     */
+    public function getShortCode() {
+        return $this->shortCode;
+    }
+
+    /**
+     * Método acessor para a operadora do celular da mensagem recebida.
+     * @return string Operadora celular da mensagem recebida
+     */
+    public function getMobileOperatorName() {
+        return $this->mobileOperatorName;
+    }
+
+    /**
+     * Método acessor ao id do SMS de origem da mensagem recebida.
+     * @return string Id do SMS de origem da mensagem recebida.
+     */
+    public function getSmsOriginId() {
+        return $this->smsOriginId;
+    }
+
+    public function setId($id) {
+        $this->id = $id;
+    }
+
+    public function setDateReceived($dateReceived) {
+        $this->dateReceived = $dateReceived;
+    }
+
+    public function setMobile($mobile) {
+        $this->mobile = $mobile;
+    }
+
+    public function setBody($body) {
+        $this->body = $body;
+    }
+
+    public function setShortCode($shortCode) {
+        $this->shortCode = $shortCode;
+    }
+
+    public function setMobileOperatorName($mobileOperatorName) {
+        $this->mobileOperatorName = $mobileOperatorName;
+    }
+
+    public function setSmsOriginId($smsOriginId) {
+        $this->smsOriginId = $smsOriginId;
+    }
+
+
+            
+    
+}

api/app/Utils/Sms/model/SmsReceivedResponse.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * Classe que representa uma resposta contendo um conjunto de mensagens recebidas.
+ */
+class SmsReceivedResponse extends SmsResponse{
+    
+    /**     
+     * @var array Lista com as mensagens recebidas na resposta.
+     */
+    private $receivedMessages=array();
+    
+    /**     
+     * Verifica se há mensagens recebidas na resposta.
+     * @return bool 
+     */
+    public function hasMessages(){
+        return count($this->receivedMessages);
+    }
+    
+    /**
+     * Adiciona uma mensagem recebida à lista de mensagens recebidas.
+     * @param SmsReceived $receivedMessage
+     */
+    public function addReceivedMessage($receivedMessage){
+        array_push($this->receivedMessages, $receivedMessage);
+    }
+    
+    /**
+     * Retorna a lista de mensagens recebidas da resposta.
+     * @return array Lista com as mensagens recebidas.
+     */
+    public function getReceivedMessages(){
+        return $this->receivedMessages;
+    }
+    
+    
+}

api/app/Utils/Sms/model/SmsResponse.php

@@ -0,0 +1,86 @@
+<?php
+/**
+ * Classe que representa uma resposta contendo o status de uma mensagem.
+ */
+class SmsResponse {
+   
+    /**     
+     * @var string Código do status da resposta
+     */
+    private $statusCode;
+    /**     
+     * @var string Descrição do status da resposta
+     */
+    private $statusDescription;
+    /**     
+     * @var string Código do detalhe do status da resposta
+     */
+    private $detailCode;
+    /**     
+     * @var string Descrição do detalhe do status da resposta
+     */
+    private $detailDescription;
+    
+    /**     
+     * @param string $statusCode
+     * @param string $statusDescription
+     * @param string $detailCode
+     * @param string $detailDescription
+     */
+    public function __construct($statusCode, $statusDescription, $detailCode, $detailDescription) {
+        $this->statusCode=$statusCode;
+        $this->statusDescription=$statusDescription;
+        $this->detailCode=$detailCode;
+        $this->detailDescription=$detailDescription;
+    }
+    
+    /**
+     * Método acessor ao código do status retornado na resposta.
+     * @return string Código do status
+     */
+    public function getStatusCode() {
+        return $this->statusCode;
+    }
+
+    /**
+     * Método acessor para a descrição do status retornado na resposta.
+     * @return string Descrição do status
+     */
+    public function getStatusDescription() {
+        return $this->statusDescription;
+    }
+
+    /**
+     * Método acessor ao código do detalhe do status retornado na resposta.
+     * @return string Código do detalhe do status
+     */
+    public function getDetailCode() {
+        return $this->detailCode;
+    }
+
+    /**
+     * Método acessor para a descrição do do detalhe do status retornado na resposta.
+     * @return string Descrição do detalhe do status
+     */
+    public function getDetailDescription() {
+        return $this->detailDescription;
+    }
+
+    public function setStatusCode($statusCode) {
+        $this->statusCode = $statusCode;
+    }
+
+    public function setStatusDescription($statusDescription) {
+        $this->statusDescription = $statusDescription;
+    }
+
+    public function setDetailCode($detailCode) {
+        $this->detailCode = $detailCode;
+    }
+
+    public function setDetailDescription($detailDescription) {
+        $this->detailDescription = $detailDescription;
+    }
+    
+    
+}

api/app/Utils/Sms/model/SmsStatusResponse.php

@@ -0,0 +1,78 @@
+<?php
+/**
+ * Classe que representa uma resposta a uma consulta de status de uma mensagem.  
+ */
+class SmsStatusResponse extends SmsResponse{
+    /**     
+     * @var string Id da mensagem enviada. 
+     */
+    private $id;
+    /**     
+     * @var string data de recebimento da mensagem no formato ISO 8601(yyyy-MM-dd'T'HH:mm:ss) 
+     */
+    private $received;
+    /**     
+     * @var string Shortcode da mensagem consultada 
+     */
+    private $shortCode;
+    /**     
+     * @var string Operadora da mensagem consultada.  
+     */    
+    private $mobileOperatorName;
+    
+    public function __construct($statusCode="", $statusDescription="", $detailCode="", $detailDescription="") {
+        parent::__construct($statusCode, $statusDescription, $detailCode, $detailDescription);
+    }
+    
+     /**
+     * Método acessor ao id da mensagem consultada.
+     * @return string Id da mensagem consultada.
+     */
+    public function getId() {
+        return $this->id;
+    }
+
+    /**
+     * Método acessor para a data de recebimento da mensagem consultada.
+     * @return string Data de recebimento da mensagem consultada.
+     */
+    public function getReceived() {
+        return $this->received;
+    }
+
+    /**
+     * Método acessor ao shortcode da mensagem consultada.
+     * @return string Shortcode da mensagem consultada.
+     */
+    public function getShortCode() {
+        return $this->shortCode;
+    }
+
+    /**
+     * Método acessor para a operadora da mensagem consultada.
+     * @return string Operadora da mensagem consultada.
+     */
+    public function getMobileOperatorName() {
+        return $this->mobileOperatorName;
+    }
+
+    public function setId($id) {
+        $this->id = $id;
+    }
+
+    public function setReceived($received) {
+        $this->received = $received;
+    }
+
+    public function setShortCode($shortCode) {
+        $this->shortCode = $shortCode;
+    }
+
+    public function setMobileOperatorName($mobileOperatorName) {
+        $this->mobileOperatorName = $mobileOperatorName;
+    }
+
+
+    
+   
+}

api/app/Utils/Sms/rest-client/DefaultHttpClient.php

@@ -0,0 +1,122 @@
+<?php
+
+
+class DefaultHttpClient implements HttpClient{
+    
+    /** 
+     * @param HttpRequest $request
+     * @param int $timeout
+     * @return HttpResponse 
+     * @throws RuntimeException
+     */
+    public function makeRequest($request, $timeout=null){                
+        $response = null;
+		$httpSocket=null;
+        try{
+            $httpString = $this->parseRequest($request);               
+            $httpSocket = $this->createSocket($request->getURL(), $timeout);
+            $this->makeHttpRequest($httpSocket, $httpString);   			
+            $responseString = $this->retrieveHttpResponse($httpSocket);
+            $response = $this->parseResponse($responseString, $request);
+			$this->closeSocket($httpSocket);
+        }catch(Exception $ex){ 
+			$this->closeSocket($httpSocket);
+            $exceptionMessage='Http Request Failed. Request['.$request.'], Response['.$response.'].';            
+            throw new Exception($exceptionMessage, null, $ex);   
+        }
+        return $response;
+    }
+    
+    
+    /**
+     * 
+     * @param URL $url
+     * @param int $timeout
+     * @return resource
+     * @throws RuntimeException
+     */
+    private function createSocket($url, $timeout=null){        
+		$host=$url->getHost();
+		$port = $url->getPort() == null ? 80 :  $url->getPort();
+		if($url->getScheme() == 'https'){	
+			$host='ssl://'.$url->getHost();
+			$port = $url->getPort() == null ? 443 :  $url->getPort();
+		}		
+        $errorCode = null;
+        $errorDescription = null;
+		$socket = null;		
+		if (is_null($timeout)){
+			$socket = fsockopen($host, $port, $errorCode, $errorDescription);
+		}
+		else{
+			$socket = fsockopen($host, $port, $errorCode, $errorDescription, $timeout);
+		}	
+        if (!is_resource($socket)) {
+            throw new RuntimeException($errorCode . " (" . $errorDescription . ")");
+        }        
+        return $socket;
+    }
+	
+	private function closeSocket($socket){
+		if(is_resource($socket)){
+			fclose($socket);
+		}
+	}
+    
+    private function makeHttpRequest($socket, $httpString){
+        $this->checkSocket($socket);
+        fwrite($socket, $httpString);
+    }
+    
+    private function checkSocket($socket){
+         if(!is_resource($socket)){
+            throw new RuntimeException("Invalid socket resource.");
+        }        
+    }
+    
+    /**
+     * 
+     * @param string $responseString
+     * @param HttpRequest $request
+     * @return HttpResponse
+     */
+    private function parseResponse($responseString, $request){
+        $responseParser = new HttpResponseParser();
+        $response = $responseParser->parse($responseString);    
+        $response->setRequestOrigin($request);
+        return $response;
+    }
+    
+    /**     
+     * @param HttpRequest $request
+     * @return string  
+     */
+    private function parseRequest($request){
+        $requestParser = new HttpRequestParser();
+        $httpString = $requestParser->parse($request);  
+        return $httpString;
+    }
+    
+    /**
+     * 
+     * @param resource $socket
+     * @return string
+     * @throws RuntimeException Caso não seja possível ler o recurso do caminho de origem
+     */
+    private function retrieveHttpResponse($socket){
+        $this->checkSocket($socket);
+        $responseContent = "";   
+		$line="";
+        while (!feof($socket)) {   			
+			$line=fgets($socket, 128);
+            $responseContent .= $line;
+        }		
+        if($responseContent==null || trim($responseContent) == "" ){
+            throw new RuntimeException("Resource requested not found. Try change the request path.");
+        }
+        return $responseContent;
+    }    
+    
+    
+        
+}

api/app/Utils/Sms/rest-client/HttpClient.php

@@ -0,0 +1,11 @@
+<?php
+
+interface HttpClient {
+    /**
+     * 
+     * @param HttpRequest $request
+     * @param int $timeout
+     * @return HttpResponse 
+     */
+    public function makeRequest($request, $timeout=null);
+}

api/app/Utils/Sms/rest-client/HttpHeader.php

@@ -0,0 +1,34 @@
+<?php
+
+
+class HttpHeader {
+    
+    /**     
+     * @var string 
+     */
+    private $name;
+    /**     
+     * @var mixed 
+     */
+    private $value;
+    
+    public function __construct($name, $value) {
+        $this->name = $name;
+        $this->value = $value;
+    }
+    
+    public function getName() {
+        return $this->name;
+    }
+
+    public function getValue() {
+        return $this->value;
+    }    
+    
+    public function __toString() {
+        return "[name=".$this->name.', value='.$this->value.']';
+    }
+   
+
+
+}

api/app/Utils/Sms/rest-client/HttpRequest.php

@@ -0,0 +1,90 @@
+<?php
+
+
+class HttpRequest {
+   
+    const HTTP_GET="GET";
+    const HTTP_POST="POST";
+    const HTTP_PUT="PUT";
+    const HTTP_DELETE="DELETE";    
+    
+    /**
+     *
+     * @var URL 
+     */
+    private $url;    
+    
+    /**     
+     * @var array 
+     */
+    private $headers=array();
+    /**     
+     * @var string 
+     */
+    private $method;
+    /**
+     * @var string 
+     */
+    private $body;
+  
+    public function getMethod() {
+        return $this->method;
+    }
+    
+    public function setMethod($method) {
+        $this->method = $method;
+    }
+    
+    public function getHeaders(){
+        return $this->headers;
+    }
+
+    /**     
+     * @param HttpHeader $header
+     */
+    public function addHeader($header){
+        array_push($this->headers, $header);
+    }
+    
+    public function hasHeader($name){
+        $hasHeader = false;
+        foreach($this->headers as $header){
+            if($header->getName() == $name){
+                $hasHeader=true;
+            }
+        }
+        return $hasHeader;
+        
+    }
+    
+    /**     
+     * @return URL
+     */
+    public function getUrl() {
+        return $this->url;
+    }
+
+    public function setUrl($url) {
+        $this->url = $url;
+    }
+
+
+    public function getBody() {
+        return $this->body;
+    }
+
+    public function setBody($body) {
+        $this->body = $body;
+    }
+
+    
+    public function __toString() {                
+        $requestString = get_class($this).'[url='.$this->url.', method='.$this->method.', body='.$this->body;
+        return $requestString;
+    }
+
+        
+    
+    
+    
+}

api/app/Utils/Sms/rest-client/HttpRequestParser.php

@@ -0,0 +1,39 @@
+<?php
+
+class HttpRequestParser {
+  
+
+    /**
+     * 
+     * @param HttpRequest $request
+     * @return type
+     */
+    public function parse($request){        
+        $postData= $request->getBody();        
+        $url = $request->getMethod() . " " . $request->getURL()->getUri().'?'.$request->getURL()->getQueryString();
+        $output  =  $url . " HTTP/1.1\r\n";
+        $output .= "Host: " . $request->getURL()->getHost() . "\r\n";
+        $output .= "User-Agent: Zenvia PHP API\r\n";
+        $output .= $this->parseCustomHeaders($request);
+        $output .= "Content-Length: " . strlen($postData) . "\r\n";
+        $output .= "Connection: close\r\n\r\n";
+        $output .= $postData;
+        return $output;        
+    }
+    
+    /**
+     * @param HttpRequest $request
+     * @return string 
+     */
+    private function parseCustomHeaders($request){
+        $headers = $request->getHeaders();
+        $output = "";
+        foreach($headers as $header){
+            $output .= sprintf("%s:%s \r\n", $header->getName(), $header->getValue());            
+        } 
+        $output .= "User-Agent: Zenvia PHP API\r\n";
+        return $output;
+    }
+    
+    
+}

api/app/Utils/Sms/rest-client/HttpResponse.php

@@ -0,0 +1,83 @@
+<?php
+
+class HttpResponse {
+    
+    /**     
+     * @var int 
+     */
+    private $httpCode;
+    /**     
+     * @var string 
+     */
+    private $httpDescription;
+    /**     
+     * @var array 
+     */
+    private $headers=array();
+    /**
+     * @var string 
+     */
+    private $body;
+    /**
+      * @var HttpRequest 
+     */
+    private $requestOrigin;
+    
+    public function getHttpCode() {
+        return $this->httpCode;
+    }
+
+    public function getHttpDescription() {
+        return $this->httpDescription;
+    }
+
+    public function setHttpCode($httpCode) {
+        $this->httpCode = $httpCode;
+    }
+
+    public function setHttpDescription($httpDescription) {
+        $this->httpDescription = $httpDescription;
+    }
+
+        
+    public function getHeaders() {
+        return $this->headers;
+    }
+
+    public function getBody() {
+        return $this->body;
+    }
+
+    public function getRequestOrigin() {
+        return $this->requestOrigin;
+    }
+      
+    public function setBody($body) {
+        $this->body = $body;
+    }
+    
+    /**
+     * @param HttpHeader $header
+     */
+    public function addHeader($header){
+        array_push($this->headers, $header);
+                
+    }
+
+    public function setRequestOrigin(HttpRequest $requestOrigin) {
+        $this->requestOrigin = $requestOrigin;
+    }
+    
+    public function __toString() {     
+        $headers=null;
+        if(is_array($this->headers)){
+            $headers = implode(", ", $this->headers);
+        }
+        $responseString = get_class($this)."[Http Code=".$this->httpCode.'-'.$this->httpDescription.", \nHeaders=".$headers.", \nBody=".$this->body.", Request Origin=".$this->requestOrigin."]";
+        return $responseString;
+    }
+
+
+    
+    
+}

api/app/Utils/Sms/rest-client/HttpResponseParser.php

@@ -0,0 +1,71 @@
+<?php
+
+class HttpResponseParser {
+
+    /**
+     * @param string
+     * @return HttpResponse 
+     */
+    public function parse($httpContent) {
+        $httpResponse = new HttpResponse();
+        $responseArray = explode("\r\n\r\n", $httpContent);
+        $headersData = $responseArray[0];
+        $headersArray = explode("\n", $headersData);
+        $totalHeaders = count($headersArray);
+        for ($i = 0; $i < $totalHeaders; $i++) {
+            $indexHttpHeader = strpos($headersArray[$i], "HTTP");
+            if ($indexHttpHeader !== false) {
+                //HTTP/1.1 200 OK
+                $httpCode = substr($headersArray[$i], $indexHttpHeader + 9, 3);
+                $httpDescription = substr($headersArray[$i], $indexHttpHeader + 13);
+                $httpResponse->setHttpCode(intval(trim($httpCode)));
+                $httpResponse->setHttpDescription(trim($httpDescription));
+            } else {
+                $httpResponse->addHeader($this->parseHeader($headersArray[$i]));                
+            }
+        }
+        $bodyData = $this->getRequestBody($headersData, $responseArray[1]);    
+        $httpResponse->setBody($bodyData);
+        return $httpResponse;
+    }
+
+    /**
+     * 
+     * @param string $headerText
+     * @return HttpHeader
+     */
+    private function parseHeader($headerText) {
+        $indexVal = strpos($headerText, ":");
+        $header=null;
+        if ($indexVal !== false) {
+            $headerName = substr($headerText, 0, $indexVal);
+            $headerValue = substr($headerText, $indexVal + 1);
+            $header = new HttpHeader($headerName, trim($headerValue));
+        } else {
+            $header = new HttpHeader("$i", trim($headerText));
+        }
+        return $header;
+    }
+
+    /**
+     * 
+     * @param string $headersData
+     * @param string $bodyData
+     * @return string
+     */
+    private function getRequestBody($headersData, $bodyData) {
+        $content = $bodyData;
+        if (!(strpos($headersData, "Transfer-Encoding: chunked") === false)) {
+            $aux = explode("\r\n", $bodyData);
+            $countAux = count($aux);
+            for ($i = 0; $i < $countAux; $i++) {
+                if ($i == 0 || ($i % 2) == 0) {
+                    $aux[$i] = "";
+                }
+            }
+            $content = implode("", $aux);
+        }
+        return $content;
+    }
+
+}

api/app/Utils/Sms/rest-client/RestClient.php

@@ -0,0 +1,113 @@
+<?php
+
+
+class RestClient {
+    
+    /**     
+     * @var HttpClient 
+     */
+    private $httpClient = null;
+    const DEFAULT_CONTENT_TYPE="application/x-www-form-urlencoded;charset=UTF-8";
+    
+    /**
+     * 
+     * @param HttpClient $httpClient
+     */
+    public function __construct($httpClient=null) {
+        if($httpClient==null){
+            $this->httpClient = new DefaultHttpClient();
+        }
+		else{
+			$this->httpClient = $httpClient;
+		}
+    }
+    
+    /**
+     * 
+     * @param string $url
+     * @param array $additionalHeaders
+     * @return HttpResponse 
+     * @throws RuntimeException
+     */
+    public function get($url, $additionalHeaders=array()){
+        $response = $this->request($url, HttpRequest::HTTP_GET, null, $additionalHeaders);
+        return $response;
+    }    
+    
+    /**
+     * 
+     * @param string $url
+     * @param string|array $data
+     * @param array $additionalHeaders
+     * @return HttpResponse 
+     * @throws RuntimeException
+     */
+    public function post($url, $data=null, $additionalHeaders=array()){
+        $response = $this->request($url, HttpRequest::HTTP_POST, $data, $additionalHeaders);
+        return $response;
+    }
+    
+    /**
+     * 
+     * @param string $url
+     * @param string $method
+     * @param string|array $data
+     * @param string $additionalHeaders
+     * @return HttpResponse 
+     * @throws RuntimeException
+     */
+    private function request($url, $method, $data=null, $additionalHeaders=array()){
+        $request = $this->createRequest($url, $method, $this->serializeRequestBody($data), $additionalHeaders);
+        try{
+            $response = $this->httpClient->makeRequest($request);  
+        }catch(Exception $ex){            
+            throw new RuntimeException($ex);
+        }
+        return $response;
+    }
+    
+    /**    
+     * 
+     * @param string $data
+     * return string
+     */
+    private function serializeRequestBody($data){
+        $serializedData = null;        
+        if($data!= null && is_array($data) ){
+            $serializedData = http_build_query($data);
+        }elseif ($data!= null && is_string($data)) {
+            $serializedData = $data;
+        }
+        return $serializedData;
+        
+    }
+    
+    /**
+     * 
+     * @param string $url
+     * @param string $method
+     * @param string|array $data
+     * @param array $additionalHeaders
+     * @return HttpRequest
+     */
+    private function createRequest($url, $method, $data=null, $additionalHeaders=array()){
+        $httpRequest = new HttpRequest();
+        $httpRequest->setUrl(new SMSURL($url));
+        $httpRequest->setMethod($method);        
+        if(is_array($additionalHeaders) && count($additionalHeaders) > 0){
+            foreach($additionalHeaders as $headerName=>$headerValue){
+                $httpRequest->addHeader(new HttpHeader($headerName, $headerValue));
+            }            
+        }
+        if(!$httpRequest->hasHeader('Content-Type')){
+            $httpRequest->addHeader(new HttpHeader('Content-Type', self::DEFAULT_CONTENT_TYPE));
+        }
+        $httpRequest->setBody($data);
+        return $httpRequest;
+        
+    }
+            
+    
+    
+    
+}

api/app/Utils/Sms/rest-client/SMSURL.php

@@ -0,0 +1,85 @@
+<?php
+
+class SMSURL {
+
+    /**
+     * @var string 
+     */
+    private $host;
+
+    /**
+     * @var string 
+     */
+    private $uri;
+
+    /**
+     * @var int 
+     */
+    private $port;
+
+    /**
+     * @var string 
+     */
+    private $queryString;
+	
+	/**
+     * @var string 
+     */
+    private $scheme;
+    
+   /**
+    * @param string $url
+    */
+    public function  __construct($url) {
+       $this->fill($url);
+    }
+    
+    private function fill($url){
+        $parsedUrl = parse_url($url);                
+        $this->host=$parsedUrl['host']; 
+        $this->uri=$parsedUrl['path'];
+		$this->scheme=$parsedUrl['scheme'];
+        if(key_exists('port', $parsedUrl)){
+            $this->port=$parsedUrl['port'];        
+        }
+        if(key_exists('query', $parsedUrl)){
+             $this->queryString=$parsedUrl['query'];
+        }       
+    }
+
+    public function getHost() {
+        return $this->host;
+    }
+
+    public function getUri() {
+        return $this->uri;
+    }
+
+    public function getPort() {
+        return $this->port;
+    }
+
+    public function getQueryString() {
+        return $this->queryString;
+    }
+	
+	public function getScheme() {
+        return $this->scheme;
+    }
+    
+    public function __toString() {
+        $urlString=$this->host;
+        if($this->port!=null && $this->port!=80){
+            $urlString.=':'.$this->port;
+        }
+        if($this->uri!=null && $this->uri!=""){
+            $urlString.=$this->uri;
+        }
+        if($this->queryString!=null && $this->queryString!=""){
+            $urlString.='?'.$this->queryString;
+        }
+        return $urlString;
+    }
+    
+
+}

api/app/Utils/Sms/util/ApiClassLoader.php

@@ -0,0 +1,46 @@
+<?php
+
+class ApiClassLoader {
+
+    private static $packages = array();
+
+    /**
+     * @packages
+     */
+    public static function register($packages) {
+        self::$packages=$packages;
+        return spl_autoload_register(array('ApiClassLoader', 'load'));
+    }
+
+    public static function load($classname) {
+        if ((class_exists($classname))) {
+            return false;
+        }
+        $filePhp = $classname . '.php';
+        foreach (self::$packages as $package) {
+            self::mapperClass($package, $filePhp);
+        }
+    }
+
+    private static function mapperClass($dir, $file) {
+        $pObjectFilePath = $dir . DIRECTORY_SEPARATOR . $file;
+        if ((file_exists($pObjectFilePath) === false) || (is_readable($pObjectFilePath) === false)) {
+            $itemHandler = opendir($dir);           
+            while (($item = readdir($itemHandler)) !== false) {
+                if (trim($item) != "." && trim($item) != "..") {
+                    $dirTmp = $dir . DIRECTORY_SEPARATOR . $item;
+                    if (is_dir($dirTmp) && substr($item, 0, 1) != ".") {
+                        if (self::mapperClass($dirTmp, $file)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        } else {
+            require($pObjectFilePath);
+            return true;
+        }
+    }
+
+}