Ir para conteúdo

POWERED BY:

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

Andrey Knupp Vital

[Resolvido] Classe Para XML - HTML

Por , em PHP

Recommended Posts

Andrey Knupp Vital    136

Andrey Knupp Vital
Postado

Olá Galerinha ..

Há alguns dias atras, prescisei lidar com XML

 

Então escrevi uma classe para manipular o XML, ou HTML .. alterando, removendo, gravando

 

Dados nesse Arquivo, Então apos terminei oque eu presisava fazer, resolvi compartilhar

 

a classe, caso algum dia alguem presise fazer feed, ou integrar a NF-e seu sistema em PHP

 

a classe pode ajudar, Deixei documentado cada metodo da classe e uma pasta com Exemplos

Trabalhando Com JSON, XML .. Entre outras coisas que a class faz, e Tambem a documentação gerada

 

Pelo Doxygen \ PHPDoc Está em 2 Arquivos Index na Pasta Raiz, Qualquer Duvida Pode Postar Aqui

Oque Estiver ao Meu Alcançe Tentarei Resolver ;) , Vou dar Algumas Atualizaçoes claro, melhorando o desempenho

e algumas coisas que sei que posso melhorar ^_^

 

Então o Codigo Completo Abaixo da Classe

 

 

<?php
        /**
         * Classe Document
         * Construida para Simples Manipulação de Arquivos XML, HTML
         * No Qual Permite Você Manipular Todos Seus Dados
         * De Uma Maneira Facil e Flexivel, Por Isso o Uso da Fluent Interface
         * Já Que a Maioria dos Retornos dos Metodos Não Aceitam em Si
         * Sua Formatação Pra String, O Fluent Interface Pode Ser Usado
         * Normalmente em Cada Metodo Que Tem Proximos Metodos a Serem
         * Chamados Durante o Uso
         *
         * @author Andrey Knupp Vital
         * @copyright (C) 2011 - 2012im
         * @package Document
         * @version 1.1.0
         * @since 1.0.0
         * @access Public
         *
         * @tutorial http://www.php.net/manual/en/class.domattr.php
         * @tutorial http://www.php.net/manual/en/class.domdocument.php
         * @tutorial http://www.php.net/manual/en/class.domxpath.php
         * @tutorial http://www.php.net/manual/en/class.domelement.php
         * @tutorial http://www.php.net/manual/en/class.domexception.php
         * @tutorial http://www.php.net/manual/en/class.domnamednodemap.php
         * @tutorial http://www.php.net/manual/en/class.domnode.php
         * @tutorial http://www.php.net/manual/en/class.domnodelist.php
         * @tutorial http://www.php.net/manual/en/class.domtext.php
         */

        final class Document{

                    /**
                     * Armazena a Instancia da Classe DOMDocument
                     * @access Public
                     * @var Object $DOMDocument
                     */
                    public $DOMDocument;
                    /**
                     * Armazena a Instancia da Classe DOMXPath
                     * @access Public
                     * @var Object $DOMXPath
                     */
                    public $DOMXPath;
                    /**
                     * Armazena o Local Que o Documento Foi Carregado
                     * @access Private
                     * @var String $Path
                     */
              	     private $Path;
                    /**
                     * Armazena o Elemento Que foi Anexado No Documento
                     * @access Public
                     * @var String $appendedElement
                     */
              	     public $appendedElement;
                    /**
                     * Armazena o Array dos Resultados Do Metodo Query
                     * @acces Public
                     * @var Array $result
                     */
              	     public $result;
                    /**
                     * Armazena a Query do DOMXPath
                     * @access Protected
                     * @var String $setQuery
                     */
                    protected $setQuery;
                    /**
                     * Armazena a Instancia do Banco de Dados
                     * Objeto do PDO
                     * @access Public
                     * @var Object $DBHandler
                     */
                    public $DBHandler;
                    /**
                     * Armazena o Elemento Raiz do Documento
                     * Carregado Atraves do Metodo Load
                     * @access Private
                     * @var String $DOCRootElement
                     */
                    private $DOCRootElement;
                    /**
                     * Armazena a Query Do DOMXPath
                     * @access Public
                     * @var String $Query
                     */
                    public $Query;
                    /**
                     * Armazena o Nome de um Elemento Criado
                     * @access Private
                     * @var String $ElementName
                     */
                    private $ElementName;
                    /**
                     * Armazena o Nome de um Elemento Criado
                     * Pelo Metodo ->createElement
                     * No Qual Faz o Tratamento da String Removendo Tags HTML, E Aspas Simples '
                     * @access Private
                     * @var String $ElementName
                     */
                    private $ElementNodeName;
                    /**
                     * Construtor da Classe
                     * Faz uma Nova Instancia do DOMDocument
                     * Setando Para a Classe, Uma Versão e Charset do Documento
                     * @param String $version
                     * @param String $charset
                     */
                    public function __construct( $version = '1.0', $charset = 'iso-8859-1' ){
                              $this->DOMDocument = new DOMDocument( $version, $charset );
                    }
                    /**
                     * Faz uma Nova Instancia da Classe
                     * DOMXPath Usado Para Localizar Elementos no Documento
                     * Se Não Quiser Invocar Esse Metodo, Basta Setar o Segundo Parametro
                     * Do Metodo Load Como True, Isso vai Fazer Com Que a Classe DOMXPath
                     * Seje Inicializada Apos o Documento Ser Carregado
                     * @method xPath
                     * @return Document
                     */
                    public function xPath(){
                          if( $this->DOMDocument instanceOf DOMDocument ){
                              $this->DOMXPath = new DOMXPath( $this->DOMDocument );
                          }
                          return $this;
                    }
                    /**
                     * Carrega o Documento Para Modificaçoes
                     * Esse Metodo e Neccessario Para Uso De Todos os Outros
                     * A Maioria Dos Outros Metodos dessa Classe Dependem do Documento
                     * Carregado Para Interação a Ele, Sem o Documento Carregado
                     * Atraves Desse Metodo, a Maioria Das Funçoes
                     * Não Teram Funcionamento Adequado Para Uso
                     * @method load
                     * @param String $Path
                     * @param Boolean $LoadXPath
                     * @return Document
                     */
                    public function load( $Path, $LoadXPath = false ){
                            $this->Path = sprintf( '%s', $Path );
                            $this->DOMDocument->preserveWhiteSpace = false;
                            $this->DOMDocument->formatOutput = true;
                            if( !file_exists( $this->Path ) ){
                                 throw new OutOfBoundsException( sprintf( 'O Arquivo %s Não Existe, Não Foi Possivel Carregar', $this->Path ) );
                            }
                            $this->DOMDocument->load( $this->Path );
                            if( $LoadXPath != false && $LoadXPath == true ){
                                    if( $this->DOMDocument instanceOf DOMDocument ){
                                       $this->DOMXPath = new DOMXPath( $this->DOMDocument );
                                    }
                            }
                            return $this;
                    }
                    /**
                     * Faz uma Consulta no Documento Carregado
                     * Trazendo um Array Com Os Elementos e Seus Respectivos Valores
                     * @method query
                     * @param String $Query
                     * @param String $UnsetFields
                     * @return Array $this->result
                     */
                    public function query( $Query, $UnsetFields = NULL ){
                           if( $Query == NULL || empty( $Query ) ):
                               throw new Exception( 'Sua Query Não Deve Estar Vazia !' );
                           endif;
                           $this->result = Array();
                           foreach( $this->DOMXPath->query( $Query ) as $this->values ){
                                    $this->item = Array();
                                    foreach( $this->values->childNodes as $this->node ){
                                          $this->item[ $this->node->nodeName ] = $this->node->nodeValue;
                                    }
                                    $this->result[] = $this->item;
                           }
                           if( isset( $UnsetFields ) != NULL ):
                               if( strpos( $UnsetFields, ',' ) == 0 or strpos( strrev( $UnsetFields ), ',' ) == 0 ):
                                     throw new InvalidArgumentException( 'Query Invalida, Verifique Se Há Virgulas No Inicio e No Final Da String' );
                               endif;
                           		for( $i = 0; $i < count( $this->result ); $i++ ):
                           			   foreach( split( ',', str_replace( " ", NULL, $UnsetFields )) as $Index => $Field ):
                           			   			unset( $this->result[$i][$Field] );
                           			   endforeach;
                           		endfor;
                           endif;
                           return $this->result;

                    }
                    /**
                     * Cria Novos Elementos no Documento
                     * Setando Valores Para Eles
                     * Caso o Valor For Nulo , Cria Apenas o Elemento no Documento
                     * @method createElement
                     * @param String or Integer $Element
                     * @param String or Integer $Value
                     * @return Document
                     */
                    public function createElement( $Element, $Value = NULL ){
                           $this->Element = sprintf( '%s', $Element );
                           $this->ElementNodeName = sprintf( '%s', strip_tags( stripslashes( $Element ) ) );
                           $this->Value = isset( $Value ) ? sprintf( '%s', $Value ) : '';
                           if( $this->Element != NULL && $this->Value != NULL ){
                               $this->createElement = $this->DOMDocument->createElement( $this->Element, $this->Value );
                           }elseif( $this->Element != NULL && $this->Value == NULL ){
                               $this->createElement = $this->DOMDocument->createElement( $this->Element );
                           }
                           return $this;
                    }
                    /**
                     * Salva o Documento Apos Suas Devidas Modificações
                     * Isso se o Path For Setado Corretamente Atraves
                     * do Metodo Load
                     * @method save
                     * @return Document
                     */
                    public function save(){
                            if( isset( $this->Path ) != NULL ){
                                $this->DOMDocument->preserveWhiteSpace = false;
                                $this->DOMDocument->formatOutput = true;
                                $this->DOMDocument->save( sprintf( '%s', $this->Path ));
                            }
                            return $this;
                    }
                    /**
                     * Anexa o Elemento Criado no Documento
                     * Apos Ter A Invocação do Metodo ->createElement
                     * Espesificando seu Nome , ou Valor
                     * @method append
                     * @return Document
                     */
                    public function append(){
                             $this->append = $this->DOMDocument->appendChild( $this->createElement );
                             return $this;
                    }
                    /**
                     * Cria uma Arvore De Elementos Para um Pai
                     * @method appendTo
                     * @param String or Integer $RootElement
                     * @param Array $Elements
                     * @param Array $Attributes
                     * @return Document
                     */
                    public function appendTo( Array $Elements = NULL, Array $Attributes = NULL ){
                           $this->DOMXQuery = self::query( '../*/parent::node()[1]' );
                           $this->DOCRootElement = key( reset( $this->DOMXQuery ) );
                           foreach( $this->DOMDocument->getElementsByTagName(sprintf( '%s', $this->DOCRootElement )) as $Root ){
                                    $this->rootElement = $this->DOMDocument->appendChild( $Root );
                                    $this->element = $this->rootElement->appendChild( $this->createElement );
                                    foreach( $Elements as $Key => $Value ){
                                            $this->Elements = $this->DOMDocument->createElement( $Key, isset( $Value ) ? $Value : '' );
                                            $this->appendedElement = $this->element->appendChild( $this->Elements );
                                            if( count( $Attributes ) != 0 && $Attributes != NULL ){
                                                foreach( $Attributes as $attr => $value ):
                                                     $this->appendedElement->setAttribute( $attr, $value );
                                                endforeach;
                                           }
                                    }
                           }
                           return $this;
                    }
                    /**
                     * Altera o Valor de Um Elemento
                     * Você Deve Espesificar o Nome do Elemento a Ser Alterado
                     * é o Novo Valor Para Esse Elemento , Você Deve
                     * Espesificar o Path Pro Elemento na Query
                     * @method replace
                     * @param String $Query
                     * @param String or Integer $Element
                     * @param String or Integer $Value
                     * @return Document
                     */
                    public function replace( $Query = NULL, $Element, $Value ){
                           $this->replaceElement = sprintf( '%s', $Element );
                           $this->replaceValue = sprintf( '%s', $Value );
                           if(!isset( $this->setQuery ) and $this->setQuery == NULL ){
                                $this->setQuery = isset( $Query ) != NULL ? sprintf( '%s/%s', $Query, $this->replaceElement ) : '';
                           }
                           if( $this->setQuery != '' || $this->setQuery != NULL ){
                               $this->QueryDOM = $this->DOMXPath->query( $this->setQuery );
                               if( $this->QueryDOM->length ){
                                   for( $i = 0; $i < $this->QueryDOM->length; ++$i ){
                                        $this->childs = $this->QueryDOM->item( $i );
                                        $this->limit = $this->childClone->attributes->length;
                                        $this->appendChanges = $this->DOMDocument->createElement( $this->replaceElement );
                                        $this->createReplaceTextNode = $this->DOMDocument->createTextNode( $this->replaceValue );
                                        foreach( $this->childs->attributes as $this->attr ):
                                             $this->appendChanges->setAttribute( $this->attr->name, $this->attr->value );
                                        endforeach;
                                        $this->appendElement = $this->appendChanges->appendChild( $this->createReplaceTextNode );
                                        $this->QueryDOM->item( $i )->parentNode->replaceChild( $this->appendChanges, $this->QueryDOM->item( $i ) );
                                   }
                               }
                           }
                           return $this;
                    }
                    /**
                     * Remove Um Elemento do Documento
                     * Você Deve Espesificar o Path Pra Esse Elemento
                     * Na Query
                     * @method delete
                     * @param String $Query
                     * @return Document
                     */
                    public function delete( $Query = NULL ){
                           if(!isset( $this->setQuery ) and $this->setQuery == NULL ){
                                $this->setQuery = isset( $Query ) != NULL ? sprintf( '%s', $Query ) : '';
                           }
                           if( $this->setQuery != '' || $this->setQuery != NULL ){
                               $this->QueryDOM = $this->DOMXPath->query( $this->setQuery );
                               if( $this->QueryDOM->length ){
                                    foreach( $this->QueryDOM as $this->ResultNodes ){
                                        $this->ResultNodes->parentNode->removeChild( $this->ResultNodes );
                                    }
                               }
                           }
                           return $this;
                    }
                    /**
                     * Formata o Output e Trata os Espaços
                     * Em Branco no Documento, Setado Como Default
                     * False Para a Preservação de Espaços em Branco
                     * E True para a Formatação do Documento
                     * @method format
                     * @throws InvalidArgumentException
                     * @param Boolean $Whitespace
                     * @param Boolean $Output
                     * @return Document
                     */
                    public function format( $Whitespace = False, $Output = True ){
                       $this->Whitespace = $Whitespace;
                       $this->Output = $Output;
                         if( !is_bool( $this->Whitespace ) ):
                              throw new InvalidArgumentException( sprintf( 'Entrada %s Não Suportada Para Definição De Formatação', $this->Whitespace ) );
                         endif;
                         if( !is_bool( $this->Output ) ):
                              throw new InvalidArgumentException( sprintf( 'Entrada %s Não Suportada Para Definição De Formatação', $this->Output ) );
                         endif;
                           if( $Whitespace != False || $Output != True ){
                                 $this->DOMDocument->preserveWhiteSpace = $Whitespace;
                                 $this->DOMDocument->formatOutput = $Whitespace;
                           }else{
                                $this->DOMDocument->preserveWhiteSpace = false;
                                $this->DOMDocument->formatOutput = true;
                           }
                           return $this;
                    }
                    /**
                     * Seta um Attributo Para um Elemento
                     * Espesificado, Os Attributos Podem Ser um Array Com Os Nomes Dos
                     * Attributos e Seus Respectivos Valores, Ou Apenas um Attributo
                     * E Seu Respectivo Valor
                     * @method setAttribute
                     * @param String $Query
                     * @param String or Integer $Element
                     * @param String or Integer $Attribute
                     * @param String or Integer $Value
                     * @return Document
                     */
                    public function setAttribute( $Query = NULL, $Element = NULL, $Attribute , $Value = NULL){
                           $this->findElement = isset( $Element ) != NULL ? stripslashes( $Element ) : '';
                           if(!isset( $this->setQuery ) and $this->setQuery == NULL ){
                                if( $this->findElement != '' || $this->findElement != NULL ):
                                      $this->setQuery = isset( $Query ) != NULL ? sprintf( '%s/%s', $Query, $this->findElement ) : '';
                                endif;
                                if( $this->findElement == '' || $this->findElement == NULL ):
                                      $this->setQuery = isset( $Query ) != NULL ? sprintf( '%s', $Query ) : '';
                                endif;
                           }
                           if( is_array( $Attribute ) ):
                                 foreach( $Attribute as $Attr => $Val ):
                                            if( $this->setQuery != '' || $this->setQuery != NULL ):
                                                   $this->findElement = $this->DOMXPath->query( $this->setQuery );
                                                   for( $i = 0; $i < $this->findElement->length; $i ++ ):
                                                         $this->findElement->item( $i )->setAttribute(sprintf( '%s', $Attr ), sprintf( '%s', $Val ));
                                                   endfor;
                                            endif;
                                 endforeach;
                           endif;
                           if( $this->setQuery != '' || $this->setQuery != NULL ){
                               $this->findElement = $this->DOMXPath->query( $this->setQuery );
                               if( $this->findElement->length and !is_array( $Attribute ) ){
                                   for( $i = 0; $i < $this->findElement->length; ++$i ){
                                        $this->findElement->item( $i )->setAttribute(sprintf( '%s', $Attribute ), sprintf( '%s', $Value ));
                                   }
                               }
                           }elseif( !isset( $this->setQuery ) and $this->setQuery != NULL ){
                                   $this->element->setAttribute(sprintf( '%s', $Attribute ), sprintf( '%s', $Value ));
                           }
                           return $this;
                    }
                    /**
                     * Seta uma Query Para Ser Usada
                     * Em Toda a Interação dos Metodos
                     * Assim os Metodos Que Neccessitam de uma Query
                     * Para Localizar os Elementos no Documento Poderam
                     * Ser Setados Como NULL pois já Existe uma Query Como Default
                     * @method setDefaultQuery
                     * @param String $Query
                     * @return String
                     */
                    public function setDefaultQuery( $Query ){
                           $this->setQuery = isset( $Query ) != NULL ? sprintf( '%s', $Query ) : '';
                           return $this->setQuery;
                    }
                    /**
                     * Seta um Manipulador de Banco de Dados
                     * Nesse Caso a Instancia de Uma Conexção Aberta
                     * Com o Banco de Dados, Para Poder Ser Usados Como Opçao
                     * De Alguns Metodos Que Converte os Registros da Sua Tabela Para XML
                     * Ou os Registros do XML [ Documento ] Para Registros em Sua Tabela
                     * @method setDBHandler
                     * @throws PDOException
                     * @param String $Server
                     * @param String $Username
                     * @param String $Password
                     * @param String $Database
                     * @return Document
                     */
                    public function setDBHandler( $Server = NULL, $Username = NULL, $Password = NULL, $Database = NULL ){
                           $this->DBHandler = new PDO( "mysql:host=$Server;dbname=$Database", $Username, $Password );
                           if( $this->DBHandler instanceOf PDO ):
                                  $this->DBHandler->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
                                  $this->DBHandler->setAttribute( PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC );
                                  $this->DBHandler->setAttribute( PDO::ATTR_TIMEOUT, 5 );
                           endif;
                    }
                    /**
                     * Transforma Registros de um Documento
                     * Para Registros em Sua Tabela, Você Pode Opinar Pela
                     * Pela Execução da Query Gerada Por Esse Metodo
                     * Caso Haja uma Instancia de Banco de Dados Aberta
                     * Caso O Ultimo Parametro $execute Não for Definido
                     * ou For False Apenas té retorna o SQL Gerado Pelo Metodo
                     * Possibilitando a Sua Execução Manualmente
                     * @method toSQL
                     * @throws OutOfBoundsException
                     * @throws LogicException
                     * @param String $table
                     * @param String $fields
                     * @param String $resultFields
                     * @param Boolean $execute
                     * @return String
                     */
                    public function toSQL( $table, $fields, $resultFields = NULL, $execute = false ){
                           $this->formatedField = Array();
                           $this->ArrayFields = explode( ',', $resultFields );
                           $this->TableName = sprintf( '%s', $table );
                           $this->execute = $execute;
                           $this->TableFields = split( ',', str_replace( " ", NULL, $fields ) );
                           foreach( $this->TableFields as $this->TableIndex => $this->TableField ):
                                    $this->TblField[] = '`'.$this->TableField.'`';
                           endforeach;
                           $this->data = Array();
                           for( $i = 0; $i < count( $this->result ); $i ++ ):
                             if( isset( $resultFields ) != '' || isset( $resultFields ) != NULL ){
                                  foreach( $this->ArrayFields as $this->Field ):
                                           if(!array_key_exists( str_replace( ' ', NULL,  $this->Field ), $this->result[ $i ] ) and $resultFields != ''):
                                                 throw new OutOfBoundsException( sprintf( 'Chave %s Não Existe no Array', $this->Field ) );
                                           endif;
                                            $this->Field = trim( $this->Field );
                                            $this->data[$i][$this->Field] = '\''.$this->result[$i][$this->Field].'\'';
                                   endforeach;
                                }else{
                                   foreach( $this->result[$i] as $key => $value ):
                                          $this->data[$i][$key] = '\''.$value.'\'';
                                   endforeach;
                                }
                                $this->formatedFields[] = "(".implode( ',', $this->data[$i] ).")";
                           endfor;
                           for( $x = 0; $x < count( $this->data ); ++$x ):
                                if( count( $this->TblField ) != count( $this->data[$x]  ) and $resultFields != NULL ):
                                        throw new LogicException( sprintf( 'Campos Da Tabela %s [ %s ] Não São Compatives Com %s ', $this->TableName, implode(",", $this->TblField), implode( ',', $this->data[ $x ] )));
                                endif;
                           endfor;
                           /*
                            * Inicia Montagem da Query
                            * O Quarto Parametro Deste Metodo
                            * Espesifica a Execução Da Query Apos de Pronta a Executar na Sua Tabela
                            * True => Monta a Query é Executa
                            * False => Apenas Monta a Query
                            */
                           $this->SQLQuery = "INSERT INTO `".$this->TableName."`( ".implode( ',', $this->TblField )."  ) VALUES ".implode( ',', $this->formatedFields );
                           if( !is_bool( $this->execute ) ):
                                  throw new InvalidArgumentException(sprintf( 'Entrada %s Não E Valida Para uma Execução, %s Deve Ser Booleano', $this->execute, $this->execute ));
                           endif;
                            if( is_bool( $this->execute ) && $this->execute == true ):
                                $this->Query = $this->DBHandler->prepare( $this->SQLQuery );
                                $this->Query->execute();
                                if( !$this->Query ):
                                     throw new LogicException( 'Não Foi Possivel Executar A Query, Verifique Sua Conexção com Banco de Dados' );
                                endif;
                            endif;
                           return $this->SQLQuery;
                    }
                    /**
                     * Transforma Registros de uma Tabela
                     * Para XML ou HTML, Você Deve Espesificar
                     * Onde Sem Encontram Esses Registros ( $table )
                     * E Os Campos Que Você Deseja, Assim Não é Neccessario
                     * Enviar Para Seu Documento Coisas Indesejaveis
                     * Tem Tambem Como Ultimo Parametro uma Espesificação de uma Clausa
                     * Você pode Fazer um Inner Join, Where, Like ou Qualquer Coisa Que Seje Possivel
                     * Fazer com a SQL Apos o SELECT ::campos:: FROM ::tabela:: Sua Clausula
                     * Escrita Manualmente, Não é Restringido o Tipo de SQL Apos a Query
                     * Pois Cabe ao Usuario Que Desenvolva a Aplicação Baseada no que Irá presisar
                     * Toda a Extração de Conteudos Que se Localizam em um Banco de Dados
                     * Então, Digitando uma Query Corretamente Como Especificado, Você Tera Successo
                     * Na Geração do Documento, Caso Contrario o Problema for no SQL, Será Disparado
                     * Uma Excessao Informando o Erro Cometido na Query
                     * @method toXML
                     * @throws PDOException
                     * @throws BadFunctionCallException
                     * @throws ErrorException
                     * @param String $table
                     * @param String $fields
                     * @param String $rootElement
                     * @return Document
                     */
                    public function toXML( $table, $fields = NULL, $clause = NULL ){
                           $this->DBTable = $table;
                           $this->DBTableFields = explode( ',', str_replace( " ", NULL, $fields ));
                           $this->fields = Array();
                           $this->DBTableQuery = 'DESCRIBE `'.$this->DBTable.'`';
                           if( isset( $this->DBHandler ) && $this->DBHandler instanceOf PDO ){
                                  $this->Query = $this->DBHandler->prepare( $this->DBTableQuery );
                                  $this->Query->execute();
                                  if( !$this->Query ){
                                         throw new ErrorException( sprintf('Não Foi Possivel Descrever a Tabela %s', $this->DBTable) );
                                  }else{
                                         $this->DBTableFetch = $this->Query->fetchAll( PDO::FETCH_ASSOC );
                                          if( $fields == '' || $fields == NULL  ){
                                                   for( $i = 0; $i < count( $this->DBTableFetch ); ++$i ){
                                                            $this->fields[] = $this->DBTableFetch[$i]['Field'];
                                                   }
                                          }elseif( isset( $this->DBTableFields ) != NULL ){
                                                $this->fields = $this->DBTableFields;
                                          }
                                          $this->SQLClause = isset( $clause ) != NULL ? sprintf( '%s', $clause ) : '';
                                          $this->DOMXQuery = self::query( '../*/parent::node()[1]' );
                                          $this->DOCRootElement = key( reset( $this->DOMXQuery ) );
                                          $this->TblFields = count( $this->fields ) != 0 ? implode( ',', $this->fields ) : '*';
                                          $this->DBTableDataSelect = $this->DBHandler->prepare( 'SELECT '. $this->TblFields .' FROM `'.$this->DBTable.'` '.$this->SQLClause.'' );
                                          $this->DBTableDataSelect->execute();
                                          $this->DBTableData = $this->DBTableDataSelect->fetchAll( PDO::FETCH_ASSOC );
                                          foreach( $this->DBTableData as $DataValue ){
                                                   foreach( $this->DOMDocument->getElementsByTagName(sprintf( '%s', $this->DOCRootElement )) as $this->RootElement ){
                                                            $this->Root = $this->DOMDocument->appendChild( $this->RootElement );
                                                            $this->ElementName = $this->Root->appendChild( $this->DOMDocument->createElement( $this->DBTable ) );
                                                            foreach( $DataValue as $this->Index => $this->Data ){
                                                                   $this->ElementName->appendChild( $this->DOMDocument->createElement( utf8_encode( $this->Index ), utf8_encode( $this->Data ) ) );
                                                            }
                                                   }
                                          }
                                  }
                           }elseif( !isset( $this->DBHandler ) ){
                                  throw new BadFunctionCallException( 'Não Foi Possivel Encontrar a Instancia do Banco De Dados' );
                           }elseif( isset( $this->DBHandler ) && !$this->DBHandler instanceOf PDO ){
                                  throw new BadFunctionCallException( 'A Instancia do Banco de Dados Não é Uma Instancia Suportada' );
                           }
                           return $this;
                    }
                    /**
                     * Codifica Dados Retornados no Resultado da Query
                     * Para o Formato JSON, Java Script Object Notation
                     * @method toJSON
                     * @param String $Query
                     * @return String, JSON Encoded
                     */
                    public function toJSON( $Query = NULL ){
                          if(!isset( $this->setQuery ) and $this->setQuery == NULL ){
                                $this->setQuery = isset( $Query ) != NULL ? sprintf( '%s', $Query ) : '';
                          }
                          $this->results = self::query( $this->setQuery );
                          $this->json = json_encode( $this->result  );
                          return $this->json;
                    }

                    /**
                     * Converte Do Formato JSON Para XML
                     * O Metodo Para Criar o Elemento Pai Para os Childs
                     * Deve Ser Criado Atraves de ->createElement, no Qual Retorna uma Instancia
                     * de DOMNode para Criação dos Filhos Atraves Dele
                     * @method fromJSON
                     * @param String $JSON
                     * @return Document
                     */
                    public function fromJSON( $JSON ){
                           $this->JSONString = $JSON;
                           if( $this->JSONString == NULL || $this->JSONString == '' ){
                                 throw new LogicException( 'String do JSON Está Vazia' );
                           }else{
                                 $this->JSON = json_decode( $this->JSONString, true );
                                 $this->DOMXQuery = self::query( '../*/parent::node()[1]' );
                                 $this->DOCRootElement = key( reset( $this->DOMXQuery ) );
                                 for( $j = 0; $j < count( $this->JSON ); $j++ ):
                                          foreach( $this->DOMDocument->getElementsByTagName(sprintf( '%s', $this->DOCRootElement ) ) as $this->RootElement ):
                                                 $this->Root = $this->DOMDocument->appendChild( $this->RootElement );
                                                 $this->ElementName = $this->Root->appendChild( $this->DOMDocument->createElement( $this->ElementNodeName ) );
                                               foreach( $this->JSON[$j] as $this->Index => $this->Data ):
                                                        $this->ElementName->appendChild( $this->DOMDocument->createElement( utf8_encode( $this->Index ), utf8_encode( $this->Data ) ) );
                                               endforeach;
                                          endforeach;
                                  endfor;
                           }
                           return $this;
                    }

        }

 

 

 

Arquivos Para Download:

 

:seta: http://www.mediafire.com/?fbzfqs751schc4r

:seta: http://www.speedyshare.com/files/28162034/XML.rar

:seta: http://www.megaupload.com/?d=U4WUOVIX

Compartilhar este post

Link para o post
Compartilhar em outros sites
Ir para a lista de tópicos PHP
×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.

  Aceito