POO, PHP, DAO e MySQLi
Veremos o desenvolvimento de uma pequena aplicação para que possamos entender como funcionam Classes, Atributos, Métodos, Herança e Instância.
Iremos desenvolver uma aplicação com o intuito de praticarmos o desenvolvimento de sistemas com POO no PHP.
Quais situações utilizam esses recursos?
Como já mencionado em diversos os artigos e como é sabido da maioria dos desenvolvedores, criar sistemas seguindo os princípios da orientação a objetos é uma das melhores práticas que podemos empregar em qualquer sistema.
POO: Programação Orietada a Objetos certamente é o tema que mais chama a atenção de todos. Por que será? A explicação é simples: com POO o sistema torna-se mais robusto, inteligente, de rápido manutenção e sem dúvida nenhuma melhor entendível. Podemos aplicar POO em todas as linguagens de programação.
Veremos como trabalhar com POO em PHP puro, criando classes, atributos, métodos e utilizando um dos conceitos mais interessantes o Data Access Objects para separarmos regras de negócios de camadas de acesso a dados e layout.
Na edição passada, vimos o principais conceitos da utilização e deenvolvimento de sistemas com POO no PHP. Vimos como criar classes, herança, o que são atributos, métodos e uma série de outras informações pertinentes a um projeto POO. De fato o tema POO parece nunca cair de moda e a razão é bem simples. Com orientação a objetos poupamos tempo, melhoramos o entendimento dos sistemas, reutilizamos código evitando a perda de tempo (já mencionada). Uma montanha de recursos e vantagens podem se mencionadas aqui e em outros artigos. Realmente o tema é extremamente longo e detalhado.
A idéia desse artigo é colocar em prática tudo que aprendemos no artigo anterior. Faremos a criação de um sistema que nos possibilitará entender perfeitamente tudo o que já foi dito. Mão na massa!
Exemplo real de uso
Sim, foram mostrados vários conceitos, exemplos, e tenho certeza que sempre fica uma dúvida, isso é normal. Temos que nos aprofundar um pouco mais nisso, para isso vamos criar uma aplicação(Contas Pagar e Receber) em OO, utilizando logicamente PHP, banco de dados MySQL, e o mais interessante a extensão MySQLi. A principal idéia aqui é também utilizar a DAO (Data Access Objects), para a persistência de dados, separando as regras de negócios das regras de acesso a banco de dados.
Lembrando que aqui não estaremos utilizando nenhum editor. Você pode escolher um de sua preferência. Apenas crie um diretório a sua escolha para que possa ser salvo todos os arquivos que criaremos nesse projeto. É interessante também você ter um servidor instalado na sua máquina, rodando PHP e MySQL e caso não tenha nenhum recomendo a utilização do WAMP (um pacote que faz a instalação do apache, php, mysql em alguns cliques).
A extensão MySQLI, conhecida como MySQL melhorada, foi desenvolvida para dar suporte as novas funcionalidades do MySQL 4.1. Outra coisa interessante é que com ela podemos utilizar ela no modo orientado a objetos, já que não verdade ela é uma classe.
Banco de Dados
Primeiramente vamos criar nosso banco de dados. Não entrarei em detalhes aqui sobre isso por não ser o escopo principal do artigo. Basicamente teremos quatro tabelas: Clientes, Fornecedores, ContasPagar e ContasReceber. Criaremos também um sistema simples, mas com base nele será possível sim e, com facilidade, você incrementar mais funcionalidades ao sistema. É importante salientar também algumas regras da nossa aplicação, onde uma conta a pagar, será paga a um fornecedor e conta a receber será recebida de um cliente, com essa pequena idéia você já vai entender as tabelas do banco de dados. Conforme a Figura 1, crie as tabelas necessárias.
Classe Contas Pagar e Contas Receber
Para iniciar nosso desenvolvimento, termos que começar criando as classes ContasPagar e ContasReceber. Essas classes serão responsáveis por abstrair as tabelas do nosso banco de dados, que irão conter nossos atributos e propriedades com métodos GET e SET, que são os campos das suas respectivas tabelas.
Inicie um novo arquivo no Bloco de Notas ou no seu editor preferido. Digite o código da Listagem 1. Crie no diretório principal da aplicação um subdiretório denominado Classes e salve as respectivas classes no mesmo com os nomes de ContasPagar.php e ContasReceber.php.
Como dito, na Listagem 1 temos o código das classes Contas a Receber e Contas a Pagar. No início da listagem estamos definindos os atributos da classe Conta a Receber. Veja que criamos 6 atributos que são:
- $id_contasreceber: id do registro;
- $documento_contasreceber: documento do contas a receber;
- $valor_contasreceber: evidentimente o valor desse documento;
- $cliente_contasreceber: id do cliente para que possamos identificá-lo;
- $status_contasreceber: o status da documento, ou seja, o andamento do documento;
- $vencimento_contasreceber: vencimento do registro.
Perceba que todos os atributos estão declarados como Private, ou seja, estarão disponíveis apenas para classe. Em seguida temos a declaração de todos os métodos Get e Set das classes. Como mencionado, esse métodos servem para que possamos recuperar ou gravar um valor no sistema. Tanto a classe ContasReceber quanto ContasPagar possuem atributos e métodos semelhantes. O importante a observar é que a construção é idêntica para ambos os casos.
Listagem 1. ContasPagar e ContasReceber.
<?php
//Contas Receber
class ContasReceber{
private $id_contasreceber = null;
private $documento_contasreceber = null;
private $valor_contasreceber = null;
private $cliente_contasreceber = null;
private $status_contasreceber = null;
private $vencimento_contasreceber = null;
public function getCliente_contasreceber(){
return $this->cliente_contasreceber;
}
public function getDocumento_contasreceber(){
return $this->documento_contasreceber;
}
public function getId_contasreceber(){
return $this->id_contasreceber;
}
public function getStatus_contasreceber(){
return $this->status_contasreceber;
}
public function getValor_contasreceber({
return $this->valor_contasreceber;
}
public function getVencimento_contasreceber(){
return $this->vencimento_contasreceber;
}
public function setCliente_contasreceber($cliente_contasreceber){
$this->cliente_contasreceber = $cliente_contasreceber;
}
public function setDocumento_contasreceber($documento_contasreceber){
$this->documento_contasreceber = $documento_contasreceber;
}
public function setId_contasreceber($id_contasreceber){
$this->id_contasreceber = $id_contasreceber;
}
public function setStatus_contasreceber($status_contasreceber){
$this->status_contasreceber = $status_contasreceber;
}
public function setValor_contasreceber($valor_contasreceber){
$this->valor_contasreceber = $valor_contasreceber;
}
public function setVencimento_contasreceber($vencimento_contasreceber){
$this->vencimento_contasreceber = $vencimento_contasreceber;
}
}
?>
<?php
//Contas Pagar
class ContasPagar{
private $id_contaspagar = null;
private $documento_contaspagar = null;
private $valor_contaspagar = null;
private $fornecedor_contaspagar = null;
private $status_contaspagar = null;
private $vencimento_contaspagar = null;
public function getDocumento_contaspagar(){
return $this->documento_contaspagar;
}
public function getFornecedor_contaspagar(){
return $this->fornecedor_contaspagar;
}
public function getId_contaspagar(){
return $this->id_contaspagar;
}
public function getStatus_contaspagar(){
return $this->status_contaspagar;
}
public function getValor_contaspagar(){
return $this->valor_contaspagar;
}
public function getVencimento_contaspagar(){
return $this->vencimento_contaspagar;
}
public function setDocumento_contaspagar($documento_contaspagar){
$this->documento_contaspagar = $documento_contaspagar;
}
public function setFornecedor_contaspagar($fornecedor_contaspagar){
$this->fornecedor_contaspagar = $fornecedor_contaspagar;
}
public function setId_contaspagar($id_contaspagar){
$this->id_contaspagar = $id_contaspagar;
}
public function setStatus_contaspagar($status_contaspagar){
$this->status_contaspagar = $status_contaspagar;
}
public function setValor_contaspagar($valor_contaspagar){
$this->valor_contaspagar = $valor_contaspagar;
}
public function setVencimento_contaspagar($vencimento_contaspagar){
$this->vencimento_contaspagar = $vencimento_contaspagar;
}
}
?>
Conexão usando a extensão MySQLI
Antes de começarmos a criar nossas classes DAO, criaremos, no diretório principal do projeto, um arquivo denominado Conexao.php que será responsável pela conexão com nosso banco de dados. Para isso vamos criar uma variável que será uma instância da classe MySQLI e no seu próprio construtor já informar os parâmetros como (servidor, login, senha, banco) com isso podemos utilizar apenas o objeto $con que será do tipo MySQLI como citei para realizar a conexão com o BD. Nós visualizaremos melhor isso tudo com as classe DAO.
Nota: Para que possa usar a extensão MySQLI é necessário habilitá-la no arquivo PHP.INI que fica no diretório de instalação do PHP. Basta localizar a referência a biblioteca e descomentar a linha retirando o caractere #.
Na realidade apenas teremos uma linha de código nesse arquivo PHP. Como visto logo a seguir. Para que não sabe quando uma variável é atribuída no PHP é a torna-se diponível a todos os scripts que fazem chamada ao script onde essa variável foi atribuída. Ou seja, usaremos o método require() ou require_once() toda vez que precisarmos usar tal variável.
$con = new mysqli("localhost", "root", "", "financeiro");
Criando as classes DAO
Vamos criar nesse momento as classes DAO (Data Access Objects), mas antes disso devemos entender como que funcionam essas classes. Data Access Object é um modelo de persistência de dados muito utilizando por desenvolvedores que desejam criar seus sistemas baseados em conceitos de orietação a objetos, como o MVC (Model – View – Controller), por exemplo. Em MVC todas as funções para persistência de dados e qualquer outra integração com o banco de dados devem se feitas em classe do tipo DAO. O principal objetivo disso é separar regras de negócios de regras de acesso a dados.
Model-view-controller (MVC) é um padrão de arquitetura de software. Com o aumento da complexidade das aplicações desenvolvidas torna-se fundamental a separação entre os dados (Model) e o layout (View). Desta forma, alterações feitas no layout não afectam a manipulação de dados, e estes poderão ser reorganizados sem alterar o layout.
O model-view-controller resolve este problema através da separação das tarefas de acesso aos dados e lógica de negócio, lógica de apresentação e de interação com o utilizador, introduzindo um componente entre os dois: o Controller. MVC é usado em padrões de projeto de software, mas MVC abrange mais da arquitetura de uma aplicação do que é típico para um padrão de projeto.
Crie então um sub-diretório denominado DAO no diretório principal de nossa aplicação. Logo após vamos criar as duas classes citadas no diretório que foi criado. A DAO será responsável por conter os métodos de INSERT, SELECT, DELETE E UPDATE, em outras palavras: os métodos CRUD (Create, Read, Update e Delete). Com isso não vamos nos preocupar com os códigos SQL na hora de realizar alguma ação no banco de dados.
Como tinha mencionado anteriormente tudo será responsabilidade da nossa DAO, já que ela é a responsável pelo acesso a base de dados. Nas nossas telas de inclusão, edição, e outros, simplesmente vamos chamar seus respectivos métodos. Vamos iniciar primeiramente criando a ContasPagarDAO.php com os seguintes métodos: InsertContasPagar, DeleteContasPagar, ShowContasPagar, UpdateContasPagar, ShowFornecedores.
Pelos nomes já possível entender o que cada método fará. Você deve te percebido que indiquei a criação também de método chamado ShowFornecedores. Ele nada mais fará do que buscar todos fornecedores, precisamos disso simplesmente para quando realizarmos um cadastro ou edição do registro. Ele seja exibido em uma SelectList como na Listagem 2, onde temos todo o código das classes ContasPagarDAO.php e ContasReceberDAO.php.
Vamos entender como funciona a classe ContasPagarDAO. Como ambas as classe são bem semelhantes, vamos entender apenas ContasPagarDAO. ContasRecebeDAO encontra-se disponível no site da DevMedia para que todos possam fazer os devidos testes. Vejamos então.
Logo de início declaramos a função InsertContasPagar() que recebe como parâmetro a conta a ser paga. Na primeira linha da função encontramos uma chamada a variável $con que contém a conexão com o banco de dados. Logo em seguida preparamos uma instrução SQL para fazer a inclusão no banco. Passamos para a instrução, todos os dados necessários para a execução do script. Na sequência usamos o método bind_param() para informar o tipo de cada parâmetro informado na linha anterior. O método bind_param() recebe como parâmetro o tipo de cada dado e seus parâmetros, respectivamente. Perceba que usamos uma espécie de constante: sdiss. Isso significa que os parâmetros serão String, Double, Integer, String e String.
Agora vem a parte interssante do artigo. Nós recebemos um objeto do tipo ContasPagar no parâmetro de nossa function(). Isso porque agora teremos que usá-lo em conjunto com os métodos Get das respectivas classes. Precisamos agora informar quais valores precisam ser gravados no banco, veja o trecho a seguir:
$P1 = $ContasPagar->getDocumento_contaspagar();
$P2 = $ContasPagar->getValor_contaspagar();
$P3 = $ContasPagar->getFornecedor_contaspagar();
$P4 = $ContasPagar->getStatus_contaspagar();
$P5 = $ContasPagar->getVencimento_contaspagar();
Perceba que usamos os métodos getDocumento_contaspagar(), getValor_contaspagar(), getFornecedor_contaspagar(), getStatus_contaspagar(), getVencimento_contaspagar() que já nos é familiar. Por fim executamos a inclusão chamando o método Execute().
Não fechamos por aqui, ainda precisamos qual o resultado disso tudo. Portanto, é importante sabermos o quantos registros foram afetados pela instrução executada. Fazemos isso com uma chamada ao método affected_rows(). Ele deve nos retornar uma valor superior a zero (0) indicando que forma executados registros com sucesso.
O que vemos nas linhas subsequentes é bastante semelhante ao que acabamos de entender, porém as instruções SQL usadas fazem parte do restante do método CRUD. A função ShowContasPagar(), por exemplo, também recebe como parâmetro um objeto do tipo $ContaPagar. Novamente fazemos uma referência a variável $con para ter acesso ao banco de dados. Nós fazemos uma consulta ao banco de dados no intuito de receber o ID do registro, por isso usamos o método getId_contaspagar(). Caso não retorne nulo, montamos nosso retorno.
O método ShowFornecedores() apenas executa um loop no banco de dados para resgatar todos os fornecedores disponíveis. Perceba a instrução SQL que fazemos: SELECT * FROM FORNECEDORES. Depois retormamos o resultado em uma variável do tipo SelectList. DeleteContasPagar() e UpdateContasPagar() seguem basicamente as mesmas regras das funções já explicadas.
Como podemos ver não há nenhum grande mistério nisso tudo. A classe ContasReceberDAO() tem exatamente a mesma estrutura e propósito, porém concentrando suas operações nas respectivas tabelas.
Listagem 2. Código da classe ContasPagarDAO.
<?php
class ContasPagarDAO{
public function InsertContasPagar(ContasPagar $ContasPagar){
global $con;
$SQL = $con->prepare("INSERT INTO contaspagar (documento_contaspagar,
valor_contaspagar, fornecedor_contaspagar, status_contaspagar,
vencimento_contaspagar) VALUES (?, ?, ?, ?, ?)") or die ($mysqli->error);
$SQL->bind_param("sdiss", $P1, $P2, $P3, $P4, $P5);
$P1 = $ContasPagar->getDocumento_contaspagar();
$P2 = $ContasPagar->getValor_contaspagar();
$P3 = $ContasPagar->getFornecedor_contaspagar();
$P4 = $ContasPagar->getStatus_contaspagar();
$P5 = $ContasPagar->getVencimento_contaspagar();
$SQL->execute();
if ($SQL->affected_rows > 0){
return true;
}
public function ShowContasPagar(ContasPagar $ContasPagar){
global $con;
if ($ContasPagar->getId_contaspagar() == null){
$SQL = $con->query("SELECT * FROM contaspagar");
return $SQL;
}else{
$SQL = $con->query("SELECT * FROM contaspagar WHERE id_contaspagar =
'".$ContasPagar->getId_contaspagar()."'");
$rs = $SQL->fetch_array();
$ContasPagar->setId_contaspagar($rs["id_contaspagar"]);
$ContasPagar->setDocumento_contaspagar($rs["documento_contaspagar"]);
$ContasPagar->setFornecedor_contaspagar($rs["fornecedor_contaspagar"]);
$ContasPagar->setValor_contaspagar($rs["valor_contaspagar"]);
$ContasPagar->setVencimento_contaspagar($rs["vencimento_contaspagar"]);
$ContasPagar->setStatus_contaspagar($rs["status_contaspagar"]);
}
}
public function ShowFornecedores(ContasPagar $ContasPagar){
global $con;
$SQL = $con->query("SELECT * FROM fornecedores");
if ($ContasPagar->getId_contaspagar() == null){
while($registros = $SQL->fetch_array()){
$selectList[] = "<option
value='".$registros["id_fornecedor"]."'>".]
$registros["nome_fornecedor"]."</option>";
}
}else{
$id = $ContasPagar->getFornecedor_contaspagar();
while($registros = $SQL->fetch_array()){
($registros["id_fornecedor"] == $id ? 'selected=""' : '')
$selectList[] = "<option ".
($registros["id_fornecedor"] == $id ? 'selected=""' : '')."
value='".$registros["id_fornecedor"]."'>".
$registros["nome_fornecedor"]."</option>";
}
}
return $selectList;
}
public function DeleteContasPagar(ContasPagar $ContasPagar){
global $con;
$SQL = $con->prepare("DELETE FROM contaspagar WHERE id_contaspagar = ?");
$SQL->bind_param("i", $P1);
$P1 = $ContasPagar->getId_contaspagar();;
$SQL->execute();
if($SQL->affected_rows > 0)
return true;
}
public function UpdateContasPagar(ContasPagar $ContasPagar){
global $con;
$SQL = $con->prepare("UPDATE contaspagar SET documento_contaspagar = ?,
valor_contaspagar = ?, fornecedor_contaspagar = ?,
status_contaspagar = ?, vencimento_contaspagar = ?
WHERE id_contaspagar = ?");
$SQL->bind_param("sdissi", $P1, $P2, $P3, $P4, $P5, $P6);
$P1 = $ContasPagar->getDocumento_contaspagar();
$P2 = $ContasPagar->getValor_contaspagar();
$P3 = $ContasPagar->getFornecedor_contaspagar();
$P4 = $ContasPagar->getStatus_contaspagar();
$P5 = $ContasPagar->getVencimento_contaspagar();
$P6 = $ContasPagar->getId_contaspagar();
$SQL->execute();
if($SQL->affected_rows > 0)
return true;
}
}
?>
Desenvolvendo as telas de cadastro
Até aqui temos todas as classe necessárias para o bom funcionamento do nosso sistema. Agora é o momento de trabalharmos com elas, para isso simplesmente vamos criar dois diretórios que conterão as telas de cadastro e consulta. Desenvolveremos algumas telas para que tenhamos uma noção de como trabalhar orietado a objetos com o PHP.
Vamos lá então. Crie duas pastas chamadas contaspagar e ContasReceber na pasta principal do nosso Web Site. Dentro delas vão conter os arquivos listar.php, apagar.php, atualizar.php e cadastrar.php, todos em ambos diretórios. Para entendermos mais fácil, vamos desmembrar as listagens e ver os detalhes de cada uma. Na Listagem 3 temos o código da tela responsável por listar nossos registros do Contas a Pagar. Digite o código da listagem indicada e salve-a como lista.php.
Entre as Linhas 2 e 4 iniciamos o nosso script declarando os arquivos Conexao.php, ContasPagar.php e ContasPagarDAO.php. Esses foram os arquivos de desenvolvemos até o momento. O primeiro deles contém a variável $con com a conexão do banco de dados salva. Os demais arquivos são nossas classes.
Até a Linha 21 como podemo notar, temos apenas código HTML que fará a impressão de uma tabela na tela. Na Linha 22 até 27 estamos começando a utilizar nossas classes. Declarmos e atribuimos ao mesmo tempo três variáveis. A primeira delas recebe uma instância da classe ContasPagar() e a segunda a classe ContasPagarDAO(). Por fim recebemos os registros da tabela na variável $query (Linha 25). Na linha seguinte iniciamos um laço while para imprimir em tela os dados resultantes da SELECT efetuada pela classe ShowContasPagar(). Repare nas linhas seguintes que estamos mesclando código HTML com código PHP. Isso é bastante comum. Na Linha 29, por exemplo abrimos uma tag <td>, célula, e na Linha 30 imprimimos o valor que está contido no array $reg iniciado e alimentado pelo laço while. Na sequência imprimimos o restante dos dados usando o mesmo método: HTML + PHP até que os registros cheguem ao final. Repare agora na Linha 46. Ela contém apenas a chave de fechamento do laço while, isso é muito importante de ser observado.
Uma dica importante que passo a todos, é sempre fazer primeiro a parte de design na página, depois implementar em seu código as regras de negócios, ou seja, o código que vai buscar no banco dados aquilo que precisa ser impresso. Dessa forma fica mais fácil gerenciar e finalizar com qualidade o código de qualquer Web Site.
Listagem 3. Código do arquivo listar.php.
<?php
include "../Conexao.php";
include "../Classes/ContasPagar.php";
include "../DAO/ContasPagarDAO.php";
?>
<head>
<style type="text/css">
@import url(../padrao.css);
</style>
</head>
<h1>Lista de Contas a Pagar</h1>
<hr/>
<table class="ms-classic3-main" style="width: 77%">
<tr>
<td class="ms-classic3-tl" style="width: 209px">Documento:</td>
<td class="ms-classic3-top" style="width: 165px">Valor:</td>
<td class="ms-classic3-top" style="width: 160px">Status</td>
<td class="ms-classic3-top" style="width: 66px">Editar</td>
</tr>
<?php
$CP = new ContasPagar();
$CPDAO = new ContasPagarDAO();
$query = $CPDAO->ShowContasPagar($CP);
while($reg = $query->fetch_array()){
?>
<tr>
<td class="ms-classic3-left" style="width:209px">
<?=$reg["documento_contaspagar"];?></td>
<td class="ms-classic3-even" style="width: 165px">
<?=$reg["valor_contaspagar"];?></td>
<td class="ms-classic3-even" style="width: 160px">
<?=$reg["status_contaspagar"];?></td>
<td class="ms-classic3-even" style="width: 66px">
<center>
<a href="atualizar.php?ID=<?=$reg["id_contaspagar"];?>">
<img alt="" height="16" src="../imagens/editar.png" width="16" class="style1"
border="0"></a>
<a href="apagar.php?ID=<?=$reg["id_contaspagar"];?>">
<img alt="" height="16" src="../imagens/apagar.png" width="16" class="style1"
border="0"></a>
</center>
</td>
</tr>
<?php } ?>
</table>
O próximo arquivo a vermos nessa etapa de desenvolvimento dos layouts, é o arquivo que terá a responsabilidade de excluir o registro do Contas a Pagar. O script precisa também adicionar os arquivos Conexao.php, ContasPagar.php e ContasPagarDAO.php no início do código para que tenhamos acesso as classes e conexões com o banco. O script certamente é um dos mais simples até aqui. Primeiro verificamos se estamos recebendo a QueryString ID. Para quem não sabe, QueryString são os parâmetros recebidos na url de do browser, por exemplo:
www.meusite.com.br/cadastro.php?ID=1203130
Perceba que após o nome do arquivo cadastro.php informamos um ponto de interrogação e o parâmetro ID. Se a url estive digitada até cadastro.php, significa que a função isset() nos retornaria nulo para o parâmetro ID. Voltando ao script, havendo o parâmetro criamos uma instância da classe ContasPagar(), enviamos o ID para ela e criamos uma instância de ContasPagarDAO(). Feito isso, chamamos o método DeleteContasPagar() passando como parâmetro o objeto que fará a referência para excluir o registro desejado (Linha 9). Por fim exibimos a mensagem de confirmação (Linha 10). Não esqueça de salvar o script como apagar.php no diretório correto. (Listagem 4)
Listagem 4. Código do script apagar.php.
<?php
include "../Conexao.php";
include "../Classes/ContasPagar.php";
include "../DAO/ContasPagarDAO.php";
if (isset($_GET['ID'])){
$CP = new ContasPagar();
$CP->setId_contaspagar($_GET["ID"]);
$CPDAO = new ContasPagarDAO();
if ($CPDAO->DeleteContasPagar($CP)){
echo "<script>alert('Conta a pagar, deletada com succeso!');</script>";
}
}
?>
Estamos quase fechando nosso sistema. Veremos agora como funciona a atualização de registros do contas a pagar. Crie um novo arquivo chamado atualizar.php. Esse script é necessário para que possamos dar a oportunidade ao usuário de alterar um registro do contas a pagar.
Nota: Para poupar espaço na revista e proporcionar maior entendimento do arquivo e dos código, omitimos alguns trechos de código que podem ser obtidos diretamene no site da DevMedia. Os trechos foram substituidos por [...] indicando que nesse pedaço de script há mais código. Os códigos omitidos não invalidam o artigo, pois são trecho HTML que podem facilmente se incorporados a qualquer momento.
O código da Listagem 5 é um pouco mais extenso, portanto omitimos alguns trechos menos importantes para facilitar mais o aprendizado. Vamos as partes mais importantes do script. Novamente invocamos os arquivos necessários para ter acesso as classes e conexão com o banco. Na sequência, instanciamos a classe ContasPagar() e invocamos o método setId_contaspagar() para receber o ID da conta que vamos alterar. Criamos uma instância de ContasPagarDAO() e verificamos se existe o parâmetro atualizar na QueryString. Existindo, gravamos os dados necessários na tabela usando os métodos Set da classe (Linhas 11 a 15). Por último chamamos o método UpdateContasPagar() passando o objeto $CP que na verdade é uma referência ao objeto ContasPagar recebido na Linha 6. No final exibimos uma mensagem informando que ação teve sucesso.
A primeira parte desse script é bem simples, mas não termina por ai. Vejamos o que mais estamos fazendo para atualizar esses dados. Na Linha 23 chamamos novamente o método ShowContasPagar() para que possamos obter novamente os dados do BD. Faremos a impressão dessas informações na tela.
Mais uma vez estamos mesclando código HTML e PHP. Criamos um formulário na Linha 27. Repare que o action do formulário está sendo apontado parar o arquivo atualizar.php, ou seja, o arquivo de script que estamos desenvolvendo nesse momento. Estamos enviando como parêmtro o ID do Contas a Pagar, lembra da história do QueryString? Pois bem, é nesse momento que a url é alterada e a primeira parte do script é executada.
Da Linha 27 até o final fiz questão de manter, pois é a parte principal desse script. Veja nas Linhas 31, 38, 46 a 50, 55 e 63 que temos código PHP. Basicamente o código vem dentro de tags <td>, células, ou seja estamos imprimindo em tela os dados do registro que selecionamos, nada mais. No final ainda temos a inclusão de um botão para confirmar a atualização dos dados.
Listagem 5. Código do script atualizar.php.
<?php
[...]
include "../Conexao.php";
include "../Classes/ContasPagar.php";
include "../DAO/ContasPagarDAO.php";
$CP = new ContasPagar();
$CP->setId_contaspagar($_GET["ID"]);
$CPDAO = new ContasPagarDAO();
$CP->setFornecedor_contaspagar($CP->getFornecedor_contaspagar());
if (isset($_GET['atualizar'])){
$CP->setDocumento_contaspagar($_POST['txtDocumento']);
$CP->setValor_contaspagar($_POST['txtValor']);
$CP->setFornecedor_contaspagar($_POST['cbFornecedor']);
$CP->setVencimento_contaspagar($_POST['txtData']);
$CP->setStatus_contaspagar($_POST['txtStatus']);
if ($CPDAO->UpdateContasPagar($CP)){
echo "<script>alert('Conta a pagar, atualizada com succeso!');</script>";
}
}
?>
[...]
<?php
$CPDAO->ShowContasPagar($CP);
?>
[...]
<form action="atualizar.php?atualizar&ID=<?=$_GET["ID"];?>" method="post">
<table style="width: 100%" class="ms-classic3-main">
<tr>
<td style="width: 136px" class="ms-classic3-tl">Documento:</td>
<td class="ms-classic3-top"><input name="txtDocumento" value="
<?=$CP->getDocumento_contaspagar();?>"
style="width: 292px" type="text" />
</td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left">Valor:</td>
<td class="ms-classic3-even"><input name="txtValor" value="
<?=$CP->getValor_contaspagar();?>"
style="width: 292px" type="text" />
</td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left">Fornecedor:</td>
<td class="ms-classic3-even">
<select name="cbFornecedor">
<?php
foreach($CPDAO->ShowFornecedores($CP) as $exibir){
echo $exibir;
}
?>
</select>
</td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left">Data de Vencimento:</td>
<td class="ms-classic3-even"><input name="txtData" value="
<?=$CP->getVencimento_contaspagar();?>"
style="width: 127px" type="text" />
</td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left">Status:</td>
<td class="ms-classic3-even">
<input name="txtStatus" value="
<?=$CP->getStatus_contaspagar();?>"
style="width: 127px" type="text" /> (S = Postivo(Pago), N =
Negativo)
</td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left"> </td>
<td class="ms-classic3-even"><input name="btCadastrar" type="submit"
value="Atualizar" />
</td>
</tr>
</table>
</form>
</body>
</html>
Enfim, veremos a última parte de nossos scripts: o cadastro. O cadastro deve nos permitir incluir novos registros de Contas a Pagar. O início do script contém o mesmo que fizemos até agora, ou seja, inclusão do link com o arquivos de classes e conexão. Já deu para perceber que precisaremos fazer isso sempre certo? Se fizermos uma comparação com Delphi ou .net, digamos que seria o mesmo que fazer um uses (Delphi) ou declararmos o namespace (.net) que contém as funções que usaremos.
Nosso script é novamente divido em dois assim como no script anterior. A primeira parte consiste verificar se existe a QueryString cadastro, havendo, instanciamos a classe ContasPagar() (Linha 7), setamos o conteúdo de cada campo, instanciamos ContasPagarDAO() (Linha 13) e chamamos o métod InsertContasPagar(). Esse procedimento todo será chamado quando o usuário clicar no botão para confirmar a inclusão do registro, como já veremos.
Novametne omiti algumas parte do código para que possamos entender mais facilmente. Lembre-se de baixar o exemplo completo no site da edição.
Na Linha 21 estamos novamente criado um formulário e passando como parâmetro para a QueryString a string cadastro. Ela é usada na primeira parte desse script como já mencionado. Em seguida criamos uma tabela com a tag <table> onde será impresso o registro que queremos incluir no banco. Repare nas Linhas 25 a 31 que estamos instanciando o ContasPagar() e ContasPagarDAO() para depois fazermos um laço foreach() em fornecedores e imprimir em tela. Por fim, completamos o nosso formulário com um botão para confirmar o cadastro. Tudo isso estamos fazendo na Listagem 6 que deverá ser salva como cadastro.php.
Listagem 6. Código do arquivo cadastro.php
[...]
<?php
inlude "../Conexao.php";
include "../Classes/ContasPagar.php";
include "../DAO/ContasPagarDAO.php";
if (isset($_GET['cadastro'])){
$CP = new ContasPagar();
$CP->setDocumento_contaspagar($_POST['txtDocumento']);
$CP->setValor_contaspagar($_POST['txtValor']);
$CP->setFornecedor_contaspagar($_POST['cbFornecedor']);
$CP->setVencimento_contaspagar($_POST['txtData']);
$CP->setStatus_contaspagar("N");
$CPDAO = new ContasPagarDAO();
if ($CPDAO->InsertContasPagar($CP)){
echo "<script>alert('Conta a pagar, cadastrada com succeso!');</script>";
echo "<script>window.location = 'listar.php';</script>";
}
}
?>
[...]
<form action="?cadastro" method="post">
<table style="width: 100%" class="ms-classic3-main">
[...]
<select name="cbFornecedor">
<?php
$CP = new ContasPagar();
$CPDAO = new ContasPagarDAO();
foreach($CPDAO->ShowFornecedores($CP) as $exibir){
echo $exibir;
}
?>
</select>
</td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left">Data de Vencimento:</td>
<td class="ms-classic3-even"><input name="txtData" style="width: 127px"
type="text" /></td>
</tr>
<tr>
<td style="width: 136px" class="ms-classic3-left"> </td>
<td class="ms-classic3-even"><input name="btCadastrar" type="submit"
value="Cadastrar" /></td>
</tr>
</table>
</form>
</body>
</html>
Não estamos completamente prontos, já que é necessário criar as telas de manutenção do Contas a Receber. Como os código são muito semelhantes, não veremos aqui. O ideal é que baixe o código-fonte completo no site da DevMedia e teste-o, pois o objetivo desse artigo é mostrar os principais pontos para que seja possível entender e reproduzir os exemplo mostrado.
Você pode ver parte do sistema funcionando nas Figuras 2 e 3. Como mencionei no início do artigo, o tema POO e muito complexo e detalhado. O recomendável é que recorra a outros artigos e até a livros especializados em conceitos para aprofundar-se ao máximo no tema.
Conclusão
Finalizamos nosso artigo com chave de ouro. Uma boa parte dos conceitos da POO puderam ser abordados ao longo de todo artigo. Pudemos observar de perto como criar uma classe DAO e usá-la em conjunto com MySQLI. Procurei ser o mais objetivo possível para que todo o conteúdo pudesse ser entendido. Não pudemos ver a segurança da aplicação, infelizmente. Isso vai ficar como lição de casa para os companheiros. Porém, quem tiver interesse em aprofundar-se ainda mais em POO ou mesmo em segurança de aplicações, há diversos artigos no próprio site da DevMedia.
Como dito diversas vezes, a POO é um tema bastante extenso e somento como muito estudo e treino é possível entendermos a fundo. Recomendo a leitura de outros artigos e livros especializados no tema.
Artigos relacionados
-
Artigo
-
Artigo
-
Artigo
-
Artigo
-
Artigo