DigitalDev » DigitalDev http://www.digitaldev.com.br Para quem gosta de programar Thu, 09 Feb 2012 17:04:46 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 [Dica] Instalando o Plugin do flash no Google Chrome no Debian Squeeze http://www.digitaldev.com.br/2012/01/29/dica-instalando-o-plugin-do-flash-no-google-crhome-no-debian-squeeze/ http://www.digitaldev.com.br/2012/01/29/dica-instalando-o-plugin-do-flash-no-google-crhome-no-debian-squeeze/#comments Mon, 30 Jan 2012 02:16:17 +0000 Tarcísio http://www.digitaldev.com.br/?p=703

Continue lendo »]]>


Essa semana, instalei o Browser Google Chrome no meu Desktop com Debian 6 Squeeze para testar o comportamento de alguns layouts em que estou trabalhando. Como já era esperado, ainda era necessário a instalação do plugin do flash player para poder visualizar algumas animações e videos.

Ao longo da tarefa de instalação do plugin, enfrentei alguns problemas na tentativa de encontrar repositórios para o download do mesmo. Então, decidi instalar o flash player na mão e com isso postar os passos usados por mim na instalação.

1 – Passo (Efetuando o download do plugin)

Vá até a página do Adobe Flash Player clicando aqui, selecione o sistema operacional e navegador (no nosso caso o Chrome) que você está usando e escolha como tipo de arquivo pra download “tar.gz para outro linux”. Logo após, clique em Baixe Agora.

2 – Passo (Descompactando e instalando o plugin)

Após a finalização do download, abra o terminal (Aplicativos > Acessórios > Terminal) e navegue até a posta onde o arquivo do plugin foi descarregado (geralmente em ~/Downloads).

cd ~/Downloads

Agora, descompacte o arquivo do plugin (no meu caso, o plugin se chama install_flash_player_11_linux.x86_64.tar.gz)

tar -zxf install_flash_player_11_linux.x86_64.tar.gz

Se você estiver logado no sistema como um usuário incluso no grupo de sudoers (usuários que podem usar o comando sudo), execute o comando para mover o arquivo do plugin para o diretório /opt/google/chrome

sudo mv libflashplayer.so /opt/google/chrome

Caso contrário, logue-se como root usando o comando su e então mova o arquivo para o diretório /opt/google/chrome usando o comando

mv libflashplayer.so /opt/google/chrome

Feche o Google Chrome e abra novamente, nesse momento o seu navegador já estará configurado para mostrar à você animações e videos em flash

Com esse post, espero ajudar pessoas que estão enfrentando ou irão enfrentar o mesmo problema que eu. Qualquer dúvida, usem a área de perguntas e respostas abaixo.

]]> http://www.digitaldev.com.br/2012/01/29/dica-instalando-o-plugin-do-flash-no-google-crhome-no-debian-squeeze/feed/ 0 Intercalando cores entre linhas de uma tabela ou lista usando CSS3 http://www.digitaldev.com.br/2012/01/27/intercalando-cores-entre-linhas-de-uma-tabela-ou-lista-usando-css3/ http://www.digitaldev.com.br/2012/01/27/intercalando-cores-entre-linhas-de-uma-tabela-ou-lista-usando-css3/#comments Fri, 27 Jan 2012 18:01:31 +0000 Tarcísio http://www.digitaldev.com.br/?p=687

Continue lendo »]]>


Intercalar as cores de um uma tabela ou lista está muito presente no dia a dia de um programador ou webdesigner. Se você é desenvolvedor web, sabe bem do que estou falando.

Já vi muitos programadores escrevem códigos PHP ou ASP para produzir esse efeito de zebra, já vi tambem alguns webdesigners usam CSS + JavaScript para isso. Mas, graças ao CSS3, isso se tornou possível usando apenas duas linhas de código CSS.

tr:nth-child(even) {background: #FFF}
tr:nth-child(odd) {background: #EEE}

onde “even” corresponde às linhas pares e “odd” às linhas impáres.

esse pequeno bloco de código pode tambem ser usado em conjunto com vários outros componentes HTML ou em classes CSS. Veja um exemplo do uso em Listas.

li:nth-child(even) {background: #FFF}
li:nth-child(odd) {background: #EEE}

Agora, veja um exemplo do uso do zebrado anexado a uma classe css feita para formatar uma tabela.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<style type="text/css">

		/*css global tabela*/
		.full_table_list{width: 200px;border-collapse: collapse;}

		/*colocando bordas nas linhas*/
		.full_table_list tr{border:1px black solid;}

		/*Definido cor das linhas pares*/
		.full_table_list tr:nth-child(even) {background: #FFF}

		/*Definindo cor das Linhas impáres*/
		.full_table_list tr:nth-child(odd) {background: #EEE}		

	</style>
</head>

<body>
	<table class="full_table_list">
		<tr>
			<td>
				Linha 1
			</td>
		</tr>
		<tr>
			<td>
				Linha 2
			</td>
		</tr>
		<tr>
			<td>
				Linha 3
			</td>
		</tr>
		<tr>
			<td>
				Linha 4
			</td>
		</tr>
	</table>
</body>
</html>

Isso reproduziu o efeito mostrado na imagem abaixo.

Eu não sou nenhum especialista em CSS, mas se houver alguma dúvida relacionado ao assunto do post, usem a área de perguntas e respostas abaixo.

]]> http://www.digitaldev.com.br/2012/01/27/intercalando-cores-entre-linhas-de-uma-tabela-ou-lista-usando-css3/feed/ 0 Comunicando-se com o Facebook usando PHP http://www.digitaldev.com.br/2011/12/04/se-comunicando-com-o-facebook-usando-php/ http://www.digitaldev.com.br/2011/12/04/se-comunicando-com-o-facebook-usando-php/#comments Sun, 04 Dec 2011 21:38:44 +0000 Tarcísio http://www.digitaldev.com.br/?p=611

Continue lendo »]]>


Com o crescimento do Facebook como rede social, o desejo de desenvolvedores e donos de sites em conectar suas aplicações web com a mais famosa rede social do mundo vem se tornando cada vez mais comum.

Se você se enquadra nesse grupo de desenvolvedores, então veio ao lugar certo, pois nesse post irei explicar como conectar o seu site feito em PHP com o Facebook seguindo alguns passos e usando uma classe de comunicação escrita em PHP.

1º Passo – Criando uma App no Facebook

Antes de começarmos, precisaremos criar uma App do Facebook, ela servirá como um canal de comunicação entre o nosso script PHP e a rede social.

Entre no Facebook e efetue login usando seu usuário e senha, logo após, acesse a página de desenvolvedores do Facebook pelo endereço https://developers.facebook.com/ e clique em Aplicativos.

Na próxima página, clique em + Criar Novo Aplicativo.

Uma caixa de formulário se abrirá no meio da tela, preencha a mesma de acordo com os dados (nome) do aplicativo que você deseja criar e clique em Continuar.

Na próxima página, preencha o campo de validação de acordo com o texto que aparece na imagem e clique em Enviar.

Para garantir que sua conta de usuário no Facebook está realmente ligada a uma pessoa e que ela não é uma conta fake, o Facebook dirá que a conta precisa ser verificada. Você poderá fazer isso adicionando seu número de celular o cartão de credito (se você for usuário das operadoras Vivo ou Oi, aconselho optar pela validação por cartão de crédito)

Observação: Se sua conta no Facebook já foi validada anteriormente, você será redirecionado para a pagina final da criação do App.

Validação por Celular

Ao escolher a validação por celular, uma janela para adicionar seu telefone será exibida. Preencha a mesma como seu telefone e clique em Confirmar.

Na próxima tela, um código será requisitado, provavelmente você recebeu esse código por SMS. Preencha o campo com tal código e clique novamente em Confirmar.

Observação: Talvez o SMS demore alguns minutos, mas se o mesmo não chegar, clique em reenviar código ou refaça o procedimento optando pela validação por cartão de crédito.

Validação por Cartão de Crédito

Ao escolher a validação por cartão de crédito, sua senha poderá ser novamente requisitada. Preencha o campo Senha e clique em Continuar

Preencha o formulário de acordo com os dados do seu cartão de crédito e clique em Salvar.

Se tudo correu bem com a validação via cartão, o Facebook irá exibir os dados do seu cartão na próxima pagina.

Voltando para a criação do aplicativo

Após os passos de validação da conta, tanto via telefone ou cartão de credito, volte a página de criação do aplicativo. Se você não fechou a mesma, a página de criação da APP deve estar aberta em paralelo com a de validação da conta, caso contrario, terá que recomeçar o processo de criação do App (o processo de validação da conta não se repetirá)

Na tela mostrada pela imagem abaixo, clique em Continuar.

Novamente, você deve preencher o campo de validação de acordo com o texto que aparece na imagem mostrada pelo Facebook e clicar em Enviar.

Se tudo correu bem até agora, uma página com os dados da sua App do Facebook será mostrada. Nela você poderá modificar os dados da aplicação e fazer upload de um ícone.

Nessa página, preencha o campo App Domain com o domínio do seu site e o campo Site Url com a url de onde seu código de integração se encontra. No meu caso, o meu dominio é digitaldev.com.br e a pasta onde coloquei o script de integração é http://digitaldev.com.br/facebook, por esse motivo, preenchi os campos como mostra a imagem abaixo.

Ainda na mesma página, anote os números de App ID e App Secret. Pois eles serão usados pelo nosso script PHP para fazer referencia ao App do Facebook. Veja a localização dos mesmos visualizando a imagem abaixo.

Ao final do processo, clique em Salvar alterações

2º Passo – Escrevendo o script PHP

Para facilitar o nosso trabalho, iremos usar uma classe para gerenciar a comunicação entre nossa aplicação e o Facebook. Efetue o download da mesma clicando aqui.

Ao descompactar o pacote, constataremos a existência de alguns exemplos de uso da classe, mas os arquivos que realmente serão usados são os que se encontram dentro da pasta src. Copie-os para uma pasta dentro da sua aplicação, pois você precisará efetuar um include ou require deles dentro do arquivo de integração.

Vamos ao código PHP

<?php
//incluindo a classe de conexão com o facebook
require_once 'FacebookApi/facebook.php';

/*
* ID da App, vocé obteve isso na ultima
* página de geração do seu aplicativo no facebook
*/
$App_ID = '';

/*
* App Secret, você obteve isso na ultima
* página de geração do seu aplicativo no facebook
*/
$App_Secret = '';

//Instanciando o Objeto da classe do facebook
$facebook = new Facebook(array(
	    'appId'  => $App_ID ,
	    'secret' => $App_Secret
));

//Pegando Id do usuário Logado
$o_user = $facebook->getUser();

/*
* Verificando se está conectado
*/
if($o_user == 0)
{

	//Envia para a página de permissão do facebook, nela voce irá dar permissão ao aplicativo
	//acessar dados da sua conta
	$url = $facebook->getLoginUrl(array('scope' => array('publish_stream','read_stream')));
	header("Location:".$url);
}
else
{
	//Verificando se o comando de logout foi enviado
	if($_GET['action'] == 'finish' )
	{
		//Retirando a permissão do Aplicativo à sua conta no facebook
		session_destroy();
		header('Location: '.$facebook->getLogoutUrl());
	}
	else
	{
		//Atualizando seu status no facebook
		if( $_GET['action'] == 'publish' && strlen($_POST['status']) > 0 )
		{
			$post =  array('message' => $_POST['status']);
			$feed = $facebook->api('/me/feed', 'POST', $post);
		}
		else
		    //pegando as publicações do seu mural
			$feed = $facebook->api('/me/feed');
			//Use ver_dump($feed) ou print_r($feed)
			//para ver todos os campos retornados

		//pegando as informações do usuário conectado
		$me = $facebook->api('/me');
		//Use ver_dump($me) ou print_r($me)
		//para ver todos os campos retornados

		//pegando as publicações da sua home
		$home = $facebook->api('/me/home');
		//Use ver_dump($home) ou print_r($home)
		//para ver todos os campos retornados
	}
}

?>

<!DOCTYPE unspecified PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
   <title>Integração com o Facebook</title>
   <meta content='text/html; charset=utf-8' http-equiv='Content-Type'>
  </head>
  <body>
  <div align="center">
	<table width='600' border='1'>
		<tr>
			<td colspan="4" align="center">
				<a href="<?php echo $me['link']?>">
					<?php echo $me['name']?>
				</a>
			</td>
		</tr>
		<tr>
			<td align="right">
				Primeiro Nome:
			</td>
			<td align="center">
				<?php echo $me['first_name']?>
			</td>
			<td align="right">
				Ultimo Nome:
			</td>
			<td align="center">
				<?php echo $me['last_name']?>
			</td>
		</tr>
		<tr>
			<td align="right">
				Cidade Natal:
			</td>
			<td align="center">
				<?php echo $me['hometown']['name']?>
			</td>
			<td align="right">
				Cidate onde mora:
			</td>
			<td align="center">
				<?php echo $me['location']['name']?>
			</td>
		</tr>
	</table>
	<br/>

	<?php
	//Imprimindo publicações do mural do usuário
	if(is_array($feed['data']))
	{
	?>
		<table width="700" border="1">
			<tr>
				<td align="center">
					Seu Mural
				</td>
			</tr>
			<?php
			foreach($feed['data'] AS $hist)
			{
			?>
			<tr>
				<td align="center">
					<?php
					if(isset($hist['story']))
						echo $hist['story'];
					else
					{
						echo $hist['message'].'<br/>';
						if(isset($hist['picture']))
						?>
						<img src='<?php echo $hist['picture']?>'>
						<?php
					}
					?>
				</td>
			</tr>
			<?php
			}
			?>
		</table>
		<br/>
	<?php
	}
	?>

	<?php
	//imprimindo publicações da home do usuário
	if(is_array($home['data']))
	{
	?>
		<table width="700" border="1">
			<tr>
				<td align="center">
					Home
				</td>
			</tr>
			<?php
			foreach($home['data'] AS $hist)
			{
			?>
			<tr>
				<td align="center">
					<?php
					if(isset($hist['story']))
						echo $hist['story'];
					else
					{
						echo $hist['message'].'<br/>';
						if(isset($hist['picture']))
						?>
						<img src='<?php echo $hist['picture']?>'>
						<?php
					}
					?>
				</td>
			</tr>
			<?php
			}
			?>
		</table>
		<br/>
	<?php
	}
	?>

	<div>
		<form action="?action=publish" method="POST">
			<textarea name="status" rows="4" cols="20"></textarea>
		<br/>
		<button type="submit">Enviar</button>
		</form>
	</div>

	<a href="?action=finish">Sair</a>
</div>
</body>
</html>

Como você pode observar no código acima, eu copiei todo o conteúdo da pasta src do pacote que fizemos download para uma pasta chamada FacebookApi na raiz da pasta do meu script.

Para ver esse código funcionando, acesse http://digitaldev.com.br/facebook

Para fazer o download do código fonte do exemplo acima, clique aqui

Para melhorar o seu entendimento do código do exemplo, leia as documentações abaixo.
Graph API – https://developers.facebook.com/docs/reference/api/
PHP SDK overview – https://developers.facebook.com/docs/reference/php/

Espero ter ajudado aos leitores que desejam efetuar a integração entre uma aplicação em PHP e o Facebook. Qualquer dúvida, entre em contato usando a área de perguntas e respostas desse post.

]]> http://www.digitaldev.com.br/2011/12/04/se-comunicando-com-o-facebook-usando-php/feed/ 11 Plugin jQuery para criação de máscara de moedas http://www.digitaldev.com.br/2011/12/01/plugin-jquery-para-criacao-de-mascara-de-moedas/ http://www.digitaldev.com.br/2011/12/01/plugin-jquery-para-criacao-de-mascara-de-moedas/#comments Thu, 01 Dec 2011 22:06:01 +0000 Elaine http://www.digitaldev.com.br/?p=601

Continue lendo »]]>



Web 2.0 está aí, exigindo cada vez mais interatividade dos sites com os usuários.

Como conseguir isso?

Um dos modos, é utilizando javascript, o que pode não ser tão fácil assim.

Por isso, existem bibliotecas gratuitas com MooTools, Dojo, Script.aculo.us e Prototype, que simplificam o desenvolvimento de aplicações web.

Entre elas, está jQuery, com vasta documentação e constante atualização.

Mas… Por que utilizar jQuery?

Porque ela pode reduzir o tempo de criação, por exemplo, de efeitos visuais em uma página html.

Como o próprio slogan diz: ” Escreva menos, faça mais” (Write less, do more).

É possível criar animações com pouquíssimas linhas de código javascript, ao invés de utilizar flash ou outros recursos.

Quer um exemplo? Que tal brincar um pouco com o efeito drag ‘n drop (arrastar e soltar) nessa página?

http://jqueryui.com/demos/droppable/#photo-manager

Outro fator importante é a grande compatibilidade entre navegadores.

Você não precisa se preocupar com a criação de funções específicas para cada um; a biblioteca já compatibiliza o código para você.

É possível utilizar requisições ajax de maneira muito fácil.

Gostou? Quer uma dica?

O jQuery tornou-se popular pelos inúmeros plugins disponíveis na internet. Esses plugins permitem criar novas funções com base nessa biblioteca.

A dica de hoje é o plugin para criação de máscara para moeda em campos html, ou seja, esse campo exibirá as casas decimais na digitação, por exemplo, do preço de um produto.

Recomendo o plugin MaskMoney.

Qual a diferença dos demais?

Ele permite a edição do campo sem a necessidade de apagar o valor completamente.

Muitas das máscaras disponíveis apresentam um bug quanto a isso.

É possível também customizar a máscara, para exibição de mais de duas casas após a vírgula com apenas uma linha de código.

Simples, não?

Mas cuidado na criação de código jQuery. Lembrem-se sempre de que o código é executado no navegador do cliente, então, se o código não for muito grande, pode travar o programa.

Fica a dica sobre alta performace com essa biblioteca:

http://geeklove.com.br/2009/11/09/escrevendo-jquery-de-alta-performace/

]]> http://www.digitaldev.com.br/2011/12/01/plugin-jquery-para-criacao-de-mascara-de-moedas/feed/ 0 Construindo uma classe em PHP para validação de dados de entrada http://www.digitaldev.com.br/2011/11/30/construindo-uma-classe-em-php-para-validacao-de-dados-de-entrada/ http://www.digitaldev.com.br/2011/11/30/construindo-uma-classe-em-php-para-validacao-de-dados-de-entrada/#comments Thu, 01 Dec 2011 02:09:32 +0000 Tarcísio http://www.digitaldev.com.br/?p=533

Continue lendo »]]>


Em uma aplicação Web dinâmica, as entradas de dados (formulários, Web Services, importação de arquivos) são responsáveis por alimentar e manter atualizada a nossa base de dados, ao mesmo tempo, essas entradas podem ser uma porta aberta para dados mal formatados, ataques do tipo script injection ou qualquer outro tipo de sujeira.

Nesse post iremos construir uma classe de validação que será capaz de filtrar, validar e criticar os dados de entrada de uma aplicação, garantindo a integridade dos dados e impedindo ataques.

Requerimentos

Para facilitar o entendimento do código abaixo, aconselho a leitura da documentação da classe Exception e das funções isset, strlen, str_replace, is_numeric, mb_detect_encoding, htmlentities, html_entity_decode, nl2br, strip_tags no site www.php.net.

1º Passo – Criando uma classe de tratamento de erros

Iremos criar uma classe para gerenciar os erros e exceções geradas por nossas classes principal e secundária e para que ela funcione adequadamente, deverá ser herdeira da classe Exception (nativa do PHP).

class DDException extends Exception
{

}

Você deve estar se perguntando “Por que não usar a classe Exception, já que a classe herdeira não tem nada implementado?”. Minha resposta é “Se em algum momento quisermos adicionar algum controle de erros ainda não implementado na classe Exception, basta modificar a classe DDException e tudo será resolvido”.

2º Passo – Implementando classe de gerenciamento dos dados a serem validados

Essa será a classe principal, ela será usada para armazenar e gerenciar os nossos dados

class DDDataValidation
{
	private $v_data_values;
	private $v_data_itens_object;

	//constantes de charset
	const UTF_8 = 1;
	const ISO_8859_1 = 2;

	//constantes para formato de data
	const DATE_EN = 1;
	const DATE_BR = 2;

	//constantes de erro
	const ErrorEmpty = 1;
	const ErrorNumeric = 2;
	const ErrorMaximum = 3;
	const ErrorMinimum = 4;
	const ErrorCPF = 5;
	const ErrorEmail = 6;
	const ErrorDate = 7;

	function __construct()
	{
		$this->v_data_values = array();
		$this->v_data_itens_object = array();
	}

	/**
	* Adiciona dados para ser validados
	*
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia ao dado
	* @param mixed $mx_data - Dado a ser validado
	*/
	public function setData($st_alias,$st_value)
	{
		$this->v_data_values[$st_alias] = $st_value;
		$this->v_data_itens_object[$st_alias] = new DDDataValidationItem(addslashes($st_value));
	}

	/**
	* Retorna um objeto contendo dados a serem validados
	*
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia ao dado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function getData($st_alias)
	{
		if(isset($this->v_data_itens_object[$st_alias]))
			return $this->v_data_itens_object[$st_alias];
		else
			throw new DDException('Alias '.$st_alias.' not found');
	}

	/**
	* Retorna os dados sem nenhuma modificação
	*
	* @param string $st_alias - Alias definido pelo desenvolvedor para fazer referencia aos dados
	* @throws DDException
	*/
	public function getOriginal($st_alias)
	{
		if(isset($v_campos[$st_alias]))
			return $v_data_values[$st_alias];
		else
			throw new DDException('Alias '.$st_alias.' not found');
	}

	/**
 	* Retorna a quantidade de erros, idenpendente
 	* do alias referente ao campo
 	*
 	* @return integer
	*/
	public function countErrors()
	{
		foreach($this->v_data_itens_object AS $data_objects)
			$in_errors += $data_objects->countErrors();
		return $in_errors;
	}
}

3º Passo – Implementando classe responsável pelos filtros

Nesse momento, iremos implementar uma classe secundária. Ela será responsável por encapsular o dado propriamente dito e por executar os métodos de restrição, filtro e conversão dos dados.

class DDDataValidationItem
{
	private $mx_value;
	private $v_error;
	private $v_boolean_error;

	/**
	* O valor do dado pode ser definidos ou não
	*
	* @param mixed $mx_value
	*/
	function __construct($mx_value = null)
	{
		if($mx_value != null)
			$this->set($mx_value);
	}

	/**
	* Recebe o dado à ser validado
	*
	* @param mixed $mx_value
	*/
	public function set($mx_value)
	{
		$this->mx_value = $mx_value;
	}

	/**
	* Retorna o dado validado
	*
	* @return mixed
	*/
	public function get()
	{
		return $this->mx_value;
	}

	/**
	* Retorna, se houver, o erro referente ao alias de verficação
	*
	* @param flag $mx_erro_code
	* 	Use DDDataValidation::ErrorEmpty - retorna o erro de preenchimento do campo
	*		DDDataValidation::ErrorNumeric - retorna o erro da validação de numero
	*		DDDataValidation::ErrorMaximum - retorna o erro da validação de quantidade de caracteres
	*		DDDataValidation::ErrorMinimum - retorna o erro da validação de quantidade de caracteres
	*		DDDataValidation::ErrorCPF - retorna o erro da validação de CPF
	*		DDDataValidation::ErrorEmail - retorna o erro da validação de e-mail
	*		DDDataValidation::ErrorDate - retornar o erro da validação de data
	*
	* @return string
	*/
	public function getErrorMsg($mx_erro_code)
	{
		if(isset($this->v_error[$mx_erro_code]))
			return $this->v_error[$mx_erro_code];
		else
			return new DDValidationItem();
		return $this->v_error[$mx_erro_code];
	}

	/**
	* Retorna o último erro ocorrido
	*
	* @return string
	*/
	public function getLastErrorMsg()
	{
		$st_message = end($this->v_error);
		if(isset($st_message))
			return $st_message;
	}

	/**
	* Retorna o primeiro erro ocorrido
	*
	* @return string
	*/
	public function getFirstErrorMsg()
	{
		$st_message = reset($this->v_error);
		if(isset($st_message))
			return $st_message;
	}

	/**
	* Retorna positivo se houver erro e nega
	*
	* @param mixed $mx_erro_code - Alias de referencia do campo
	* @return boolean
	*/
	public function getError($mx_erro_code)
	{
		if(isset($this->v_boolean_error[$mx_erro_code]))
			return $this->v_boolean_error[$mx_erro_code];
	}

	/**
	* Retorna todos os erros, separados apenas pelo delimitador
	*
	* @param character $ch_delimiter - Delimitador
	* @return string
	*/
	public function getAllErrosMessages($ch_delimiter = ' - ')
	{
		foreach($this->v_error AS $st_error)
			if(isset($st_all_error))
				$st_all_error .= $ch_delimiter.$st_error;
			else
				$st_all_error .= $st_error;
		return $st_all_error;
	}

	/**
	* Retorna a quantidade de erros gerados para aquele campo
	*
	* @return integer
	*/
	public function countErrors()
	{
		return count($this->v_error);
	}

	/************************/
	/* Métodos de restrição */
	/************************/

	/**
	* Verifica se o dado passado está vazio
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isEmpty( $st_message = null, $mx_error_code = DDDataValidation::ErrorEmpty )
	{
		$mx_value = $this->trim()->get();
		if(!(strlen($mx_value) > 0))
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}

	/**
	* Verifica se o dado passado é um numero
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isNumeric( $st_message = null, $mx_error_code = DDDataValidation::ErrorNumeric )
	{
		$mx_value = $this->trim()->get();
		$mx_value = str_replace(',', '.', $mx_value);
		if(!(is_numeric($mx_value)))
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}

	/**
	* Verifica se o dado passado tem quantidade de
	* caracteres acima do limite passado como parametro
	*
	* @param integer $in_max_caracter_count - Quantidade máxima de caracteres
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isMaximum( $in_max_caracter_count , $st_message = null , $mx_error_code = DDDataValidation::ErrorMaximum )
	{
		if(is_int($in_max_caracter_count))
		{
			if((strlen($this->mx_value) >= $in_max_caracter_count))
			{
				if($st_message != null)
					$this->v_error[$mx_error_code] = $st_message;
				$this->v_boolean_error[$mx_error_code] = TRUE;
			}
		}
		else
			throw new DDException('the variable in_max_caracter_count isn\'t numeric');
		return $this;
	}

	/**
	* Verifica se o dado passado tem quantidade de
	* caracteres abaixo do limite passado como parametro
	*
	* @param integer $in_min_caracter_count - Quantidade mínima de caracteres
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isMinimum( $in_min_caracter_count , $st_message = null , $mx_error_code = DDDataValidation::ErrorMinimum )
	{
		if(is_numeric($in_min_caracter_count))
		{
			if(strlen($this->mx_value) <= $in_min_caracter_count)
			{
				if($st_message != null)
					$this->v_error[$mx_error_code] = $st_message;
				$this->v_boolean_error[$mx_error_code] = TRUE;
			}
		}
		else
			throw new DDException('the variable in_min_caracter_count isn\'t numeric');
		return $this;
	}

	/**
	* Verifica se o dado é um CPF válido
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isCPF( $st_message , $mx_error_code = DDDataValidation::ErrorCPF )
	{
		$st_cpf = $this->mx_value;
		$st_cpf = str_pad(ereg_replace('[^0-9]', '', $st_cpf), 11, '0', STR_PAD_LEFT);
		if
		(
			strlen($st_cpf) != 11 ||
			$st_cpf == '00000000000' ||
			$st_cpf == '11111111111' ||
			$st_cpf == '22222222222' ||
			$st_cpf == '33333333333' ||
			$st_cpf == '44444444444' ||
			$st_cpf == '55555555555' ||
			$st_cpf == '66666666666' ||
			$st_cpf == '77777777777' ||
			$st_cpf == '88888888888' ||
			$st_cpf == '99999999999'
		)
			$this->v_error[$mx_error_code] = $st_message;
		else
			for ($t = 9; $t < 11; $t++)
			{
				for ($d = 0, $c = 0; $c < $t; $c++)
					$d += $st_cpf{$c} * (($t + 1) - $c);

				$d = ((10 * $d) % 11) % 10;
				if ($st_cpf{$c} != $d)
				{
					if($st_message != null)
						$this->v_error[$mx_error_code] = $st_message;
					$this->v_boolean_error[$mx_error_code] = TRUE;
				}
			}
		return $this;
	}

	/**
	* Verifica se o dado é um e-mail válido
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	*/
	public function isEmail( $st_message , $mx_error_code = DDDataValidation::ErrorEmail )
	{
		$st_email = $this->mx_value;
		$bo_valid = eregi
		(
			"^[0-9a-z]([-_.]?[0-9a-z])*@[0-9a-z]([-.]?[0-9a-z])*\\.[a-z]{2,3}$",
			$st_email,
			$check
		); 

		if(!$bo_valid)
		{
			if($st_message != null)
				$this->v_error[$mx_error_code] = $st_message;
			$this->v_boolean_error[$mx_error_code] = TRUE;
		}
		return $this;
	}

	/**
	* Verifica se o dado é uma data válida
	* @param integer $in_format - Usado para definir qual o formato da data
	* 		Use DDDataValidation::DATE_BR para formato DD/MM/AAAA
	* 		Use DDDataValidation::DATE_EN para formato AAAA/MM/DD
	*
	* @param string $st_message - Mensagem de erro
	* @param mixed $mx_error_code - Código de erro, pode ser personalizado
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function isDate( $st_message = null , $in_format = DDDataValidation::DATE_BR , $mx_error_code = DDDataValidation::ErrorDate )
	{
		$dt_date = $this->mx_value;
		$v_date = preg_split('/[[:punct:]]/',$dt_date);
		if( !is_numeric($v_date[0]) || !is_numeric($v_date[1]) || !is_numeric($v_date[2])  )
		{
			{
					if($st_message != null)
						$this->v_error[$mx_error_code] = $st_message;
					$this->v_boolean_error[$mx_error_code] = TRUE;
				}
			return $this;
		}

		if($in_format == DDDataValidation::DATE_BR)
		{
			$in_day = $v_date[0];
			$in_month =  $v_date[1];
			$in_year =  $v_date[2];
		}
		elseif($in_format == DDDataValidation::DATE_EN)
		{
			$in_day = $v_date[2];
			$in_month =  $v_date[1];
			$in_year =  $v_date[0];
		}
		else
			throw new DDException('Invalid value for variable $in_format');

		if (!checkdate( $in_month , $in_day , $in_year ))
			$this->v_error[$mx_error_code] = $st_message;
		return $this;
	}

	/*********************/
	/* Métodos de filtro */
	/*********************/

	/**
	* Retira, por padrão, caracteres de espaço ( ), tab (\t), retorno de carro (\r)
	* e quebra de linhas (\n) no inicio e no fim do dado. Pode ser personalizada
	* usando a variável $st_characters
	*
	* @param string $st_characters - Caracteres que devem ser retirados no inicio
	* 		e no fim do dado, o valor padrão é " \t\n\r"
	*
	* @return DDDataValidationItem
	*/
	public function trim( $st_characters = " \t\n\r" )
	{
		$this->mx_value = trim( $this->mx_value , $st_characters );
		return $this;
	}

	/**
	* Retira, por padrão, todas as tags HTML encontradas no dado
	*
	* @param string $allowable_tags - Use-a para permitir tags especificadas
	* @return DDDataValidationItem
	*/
	public function noHTML( $allowable_tags = '' )
	{
		$this->mx_value = strip_tags($this->mx_value,$allowable_tags);
		return $this;
	}

	/**
	* Retira tudo que não for uma letra do alfabeto
	* ou um numero de 0 a 9 do dado
	*
	* @return DDDataValidationItem
	*/
	public function alphaNum()
	{
		$this->trim();
		$this->noHTML();
		$this->mx_value = ereg_replace("([[:punct:]]| )","",$this->mx_value);
		return $this;
	}

	/**
	* Retira tudo que não for um numero do dado
	*
	* @return DDDataValidationItem
	*/
	public function numeric()
	{
		$this->trim();
		$this->noHTML();
		$this->mx_value = ereg_replace("([[:punct:]]|[[:alpha:]]| )","",$this->mx_value);
		return $this;
	}

	/************************/
	/* Métodos de conversão */
	/************************/

	/**
	* Converte uma data do formato Brasileiro Ex: 10/11/2011
	* 	para o formato Americano Ex: 2011/11/10 ou vice-versa
	*
	* @param integer $f_actual_format - Especificar o formato atual da data
	* 	Use DDDataValidation::DATE_BR para formato Brasileiro
	* 	Use DDDataValidation::DATE_EN para formato Americano
	* @param integer $f_to_format - Especificar o formato de data desejado
	* 	Use DDDataValidation::DATE_BR para formato Brasileiro
	* 	Use DDDataValidation::DATE_EN para formato Americano
	* @param character $ch_delimiter - Especificar o caractere de separação
	* 	para dia mês e ano
	* @throws DDException
	*/
	public function convertDate($f_actual_format = DDDataValidation::DATE_BR , $f_to_format = DDDataValidation::DATE_EN , $ch_delimiter = '-' )
	{
		$dt_date = $this->mx_value;
		$v_date = preg_split('/[[:punct:]]/',$dt_date);

		if( !is_numeric($v_date[0]) || !is_numeric($v_date[1]) || !is_numeric($v_date[2])  )
			throw new DDException('this data isn\'t a valid date');

		if($f_actual_format != DDDataValidation::DATE_BR && $f_actual_format != DDDataValidation::DATE_EN)
			throw new DDException('$f_actual_format isn\'t a valid flag');

		if($f_to_format != DDDataValidation::DATE_BR && $f_to_format != DDDataValidation::DATE_EN)
			throw new DDException('$f_to_format isn\'t a valid flag');

		if($f_actual_format == DDDataValidation::DATE_BR)
		{
			$in_day = $v_date[0];
			$in_month =  $v_date[1];
			$in_year =  $v_date[2];
		}
		elseif($f_actual_format == DDDataValidation::DATE_EN)
		{
			$in_day = $v_date[2];
			$in_month =  $v_date[1];
			$in_year =  $v_date[0];
		}

		if (!checkdate( $in_month , $in_day , $in_year ))
			throw new DDException('this data isn\'t a valid date');

		if($f_to_format == DDDataValidation::DATE_BR)
			$this->mx_value = $in_day . $ch_delimiter . $in_month . $ch_delimiter . $in_year;
		elseif($f_to_format == DDDataValidation::DATE_EN)
			$this->mx_value = $in_year . $ch_delimiter . $in_month . $ch_delimiter . $in_day;
		return $this;
	}

	/**
	* Converte todos os caractéres especiais em suas
	* respectivas entidades HTML
	*
	* @return DDDataValidationItem
	*/
	public function htmlEntities()
	{
		$this->mx_value = htmlentities($this->mx_value);
		return $this;
	}

	/**
	* Converte entidades HTML em seus respectivos
	* caracteres especiais
	*
	* @return DDDataValidationItem
	*/
	public function htmlEntitiesDecode()
	{
		$this->mx_value = html_entity_decode($this->mx_value);
		return $this;
	}

	/**
	* Converte characteres de final de linha (\n) para
	* para a tag <br/> do HTML
	*
	* @return DDDataValidationItem
	*/
	public function nlToBr()
	{
		$this->mx_value = nl2br($this->mx_value);
		return $this;
	}

	/**
	* seta o charset do dado
	*
	* @param integer $in_actual_charset - Seta o charset atual do dado
	* 	Use DDDataValidation::ISO_8859_1 para ISO-8859-1
	* 	Use DDDataValidation::UTF-8 para UTF-8
	* @param integer $in_to_charset - Define o charset desejado
	* 	Use DDDataValidation::ISO_8859_1 para ISO-8859-1
	* 	Use DDDataValidation::UTF-8 para UTF-8
	* @return DDDataValidationItem
	* @throws DDException
	*/
	public function setCharset($in_actual_charset = DDDataValidation::ISO_8859_1 , $in_to_charset = DDDataValidation::UTF_8)
	{
		if($in_actual_charset != DDDataValidation::ISO_8859_1 && $in_actual_charset != DDDataValidation::UTF_8)
			throw new DDException('invalid actual charset variable'); 

		if($in_to_charset != DDDataValidation::ISO_8859_1 && $in_to_charset != DDDataValidation::UTF_8)
			throw new DDException('invalid to charset variable');

		if($in_actual_charset == DDDataValidation::UTF_8 && $in_to_charset == DDDataValidation::ISO_8859_1)
			$this->mx_value = utf8_decode($this->mx_value);

		if($in_actual_charset == DDDataValidation::ISO_8859_1 && $in_to_charset == DDDataValidation::UTF_8)
			$this->mx_value = utf8_encode($this->mx_value);
		return $this;
	}
}

Você deve está pensando “Nossa! Quanto código.“. Eu sei, é realmente muito código, mas ele será escrito apenas uma vez e usado milhares de vezes. Você só terá que mexer nele novamente se houver a necessidade de implementar um novo método ou fazer a manutenção em alguma parte do código. Resumindo, você só terá que entender o código (se você for um bom programador e não gosta de pegar código pronto na Internet) e aprender a usar.

4º Passo – Testando o código

Como teste, iremos usar nossa classe para validar um formulário. Veja o código em anexo abaixo.

<?php
//se o formulário foi enviado

require_once 'DDFormValidation.php';
$o_validation = new DDDataValidation();

//verificando se algo foi enviado
if(count($_POST))
{
	//encapsulando os dados
	$o_validation->setData('nome', $_POST['nome']);
	$o_validation->setData('email', $_POST['email']);
	$o_validation->setData('cpf', $_POST['cpf']);
	$o_validation->setData('data_nascimento', $_POST['data_nascimento']);

	//efetuando as validações

	//validando nome
	$o_validation->getData('nome')->isEmpty('Nome é obrigatório');

	//validando email
	$o_validation->getData('email')->isEmpty('E-mail é obrigatório');
	$o_validation->getData('email')->isEmail('E-mail inválido');

	//validando CPF
	$o_validation->getData('cpf')->isEmpty('CPF é obrigatório');
	$o_validation->getData('cpf')->isCPF('CPF inválido');

	//validando data de nascimento
	$o_validation->getData('data_nascimento')->isEmpty('Data de Nascimento é obrigatória');
	$o_validation->getData('data_nascimento')->isDate('Data de Nascimento inválida',DDDataValidation::DATE_BR);

	if($o_validation->countErrors() == 0)
		$st_mensagem =  'cadastrado com sucesso';
}	

	?>
<html>
<head>
<style>
body
{
font-family:"tahoma";
}
</style>
</head>
<body>
<div align=center>
	<br/>
	<br/>
	<form method="post">
		<table>
			<tr>
				<td colspan="2" align="center" style="font-size: 30px;">
					DigitalDev Form
				</td>
			</tr>
			<tr>
				<td>
					&nbsp;
				</td>
			</tr>
			<?php
			if(isset($st_mensagem))
			{
			?>
			<tr>
				<td colspan="2" align="center">
					<font color='red' size='4'><?php echo $st_mensagem?></font>
				</td>
			</tr>
			<?php
			}
			?>
			<tr>
				<td align="right">
					Nome:
				</td>
				<td>
					<input type="text" name="nome" value="<?php echo $_POST['nome']?>" maxlength="40">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('nome')->getErrorMsg(DDDataValidation::ErrorEmpty)?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					E-mail:
				</td>
				<td>
					<input type="text" name="email" maxlength="40" value="<?php echo $_POST['email']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('email')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					CPF:
				</td>
				<td>
					<input type="text" size="11" name="cpf" maxlength="14" value="<?php echo $_POST['cpf']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('cpf')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td align="right">
					Data de nascimento:
				</td>
				<td>
					<input type="text" size="10" name="data_nascimento" maxlength="10" value="<?php echo $_POST['data_nascimento']?>">
					<font size='2' color='red'>
						<?php echo $o_validation->getData('data_nascimento')->getFirstErrorMsg()?>
					</font>
				</td>
			</tr>
			<tr>
				<td colspan="2" align="center">
					<button type="submit">Cadastrar</button>
				</td>
			</tr>
		</table>
	</form>
</div>
</body>
</html>

Faça o download do código fonte do exemplo acima clicando aqui.

Apesar dessa classe de validação de dados de entrada ser capaz de nos auxiliar na validação, filtro e conversão de dados de entrada, sempre irá existir situações em que ela não poderá nos auxiliar. Nessas situações o programador deverá efetuar manutenções no código ou implementar novos métodos.

Faça o download do código fonte da classe clicando aqui.

Artigos Relacionados

Construindo uma classe em PHP para conexão com Banco de Dados
SQL Injection, como evitar esse tipo de ataque em páginas PHP

]]> http://www.digitaldev.com.br/2011/11/30/construindo-uma-classe-em-php-para-validacao-de-dados-de-entrada/feed/ 0 Centralizando objetos na tela com CSS http://www.digitaldev.com.br/2011/11/30/centralizando-objetos-na-tela-com-css/ http://www.digitaldev.com.br/2011/11/30/centralizando-objetos-na-tela-com-css/#comments Wed, 30 Nov 2011 18:16:55 +0000 sergio http://www.digitaldev.com.br/?p=562

Continue lendo »]]>


Veremos aqui como alinhar objetos no centro da tela, usando css. Usaremos como exemplo o alinhamento de uma imagem com DIV. Verifiquem que o processo é o mesmo caso queremos alinhar tabelas contendo textos ou imagens.

Agora vejamos:

A imagem possui um tamanho de 400 x 300, respectivamente, largura e altura (width e height).

Insira a imagem dentro de um DIV, como abaixo:

<div>
     <img src=”imagem.jpg” alt=”" />
</div>

Explicando o CSS:
Acompanhando o tamanho da imagem, ou seja, 400px x 300px, definiremos no CSS uma largura de 400px e uma altura de 300px que “guardará” a imagem:

width: 400px;
height: 300px;

É necessário entender que o alinhamento não é feito a partir do centro do objeto. Neste caso alinhamos pelas extremidades, onde o canto esquerdo superior passa ser o centro.

Então definimos:

position: absolute;

E também:
Distância de 50% a partir do topo e 50% a partir do lado esquerdo:

top: 50%;
left: 50%;

Para encerrar faremos uma espécie de hack do CSS:
Definiremos valores negativos para a imagem, mais precisamente nas margens do topo e esquerda. Os valores negativos serão exatamente a metade da altura e da largura da imagem, conforme abaixo:

margin-top: -150px;
margin-left: -200px;

Vejamos agora como deverá ficar o CSS final:

.center {
     width: 400px;
     height: 300px;
     position: absolute;
     top: 50%;
     left: 50%;
     margin-top: -150px;
     margin-left: -200px;
}

Veja como ficou o html:

<html>
     <head>
          <title>Título<title>
     </head>
     <body>
          <div  class=”center”><img src=”imagem.jpg” /></div>
     </body>
</html>

Isso também é possível:

<html>
     <head>
          <title>Título<title>
     </head>
     <body>
<table width=”400″ border=”0″ cellspacing=”0″ cellpadding=”0″>
               <tr> 
                    <td>
<div  class=”center”><img src=”imagem.jpg” /></div>
</td>
</tr>
</table>
</body>
</html>

Espero ter ajudado.

]]> http://www.digitaldev.com.br/2011/11/30/centralizando-objetos-na-tela-com-css/feed/ 0 Construindo uma classe em PHP para conexão com Banco de Dados http://www.digitaldev.com.br/2011/10/22/construindo-uma-classe-em-php-para-conexao-com-banco-de-dados/ http://www.digitaldev.com.br/2011/10/22/construindo-uma-classe-em-php-para-conexao-com-banco-de-dados/#comments Sun, 23 Oct 2011 00:57:53 +0000 Tarcísio http://www.digitaldev.com.br/?p=444

Continue lendo »]]>


Ao se construir uma aplicação ou site em PHP que se comunique com algum banco de dados, uma classe de banco de dados de fácil uso e compreensão pode simplificar bastante o nosso trabalho.

Nesse artigo mostrarei como construir uma classe da banco de dados, baseada na classe PDO (nativa do PHP), capaz de fazer múltiplas conexões simultâneas e com suporte aos principais gerenciadores de banco de dados usados hoje em dia.

Requisitos

Como iremos usar a classe PDO do PHP na implementação de uma segunda classe, precisaremos que as extensões php_pdo_mssql, php_pdo_mysql, php_pdo_oci, php_pdo_pgsql, php_pdo_sqlite estejam ativas nas configurações do seu servidor PHP.

Para facilitar o entendimento do código abaixo, aconselho a leitura da documentação das classes PDO e Exception no site www.php.net.

1º Passo – Criando uma classe de configuração

Antes de mais nada, precisaremos construir uma classe para guardar as configurações de cada conexão, como por exemplo, endereço do banco, tipo do banco, porta, nome do banco, usuário e senha.

class DDConnectSettings
{
	const MYSQL = 1;
	const PGSQL = 2;
	const MSSQL = 3;
	const ORACLE = 4;
	const SQLite = 5;

	private $f_application;
	private $st_host;
	private $in_port;
	private $st_dbase;
	private $st_user;
	private $st_password;

	/**
	* define o gerenciador de banco de dados
	* @param int $f_aplication
	* @example $ob->setAplication(DDConnectSettings::MYSQL);
	*	Use
	* 	DDConnectSettings::MYSQL - para MySQL
	* 	DDConnectSettings::PGSQL - para PostgreSQL
	* 	DDConnectSettings::MSSQL - para Microsoft SQL Server
	* 	DDConnectSettings::ORACLE - para Oracle
	*	DDConnectSettings::SQLite - para SQLLite
	*/
	public function setApplication($f_aplication)
	{
		$this->f_application = $f_aplication;
	}

	/**
	* retorna qual o gerenciador de banco de dados definido
	* @return int
	*/
	public function getApplication()
	{
		return $this->f_application;
	}

	/**
	* define endereço (IP ou domínio) do servidor
	* @param string $st_host
	*/
	public function setHost($st_host)
	{
		$this->st_host = $st_host;
	}

	/**
	* retorna o endereço do servidor definido
	* @return string
	*/
	public function getHost()
	{
		return $this->st_host;
	}

	/**
	* define a porta a ser usada na conexão
	* @param int $in_port
	*/
	public function setPort($in_port)
	{
		$this->in_port = $in_port;
	}

	/**
	* retorna a porta definida
	* @return int
	*/
	public function getPort()
	{
		return $this->in_port;
	}

	/**
	* define o nome do banco de dados ou arquivo
	* @param string $st_dbase
	*/
	public function setDatabase($st_dbase)
	{
		$this->st_dbase = $st_dbase;
	}

	/**
	* retorna o nome do banco de dados ou arquivo definido
	* @return string
	*/
	public function getDatabase()
	{
		return $this->st_dbase;
	}

	/**
	* define o nome do usuário a ser usado em uma conexão protegida
	* @param string $st_user
	*/
	public function setUser($st_user)
	{
		$this->st_user = $st_user;
	}

	/**
	* retorna o nome do usuário definido no caso de uma conexão pretegida
	* @return string
	*/
	public function getUser()
	{
		return $this->st_user;
	}

	/**
	* define a senha de usuário a ser usado em uma conexão protegida
	* @param string $st_password
	*/
	public function setPassword($st_password)
	{
		$this->st_password = $st_password;
	}

	/**
	* retorna a senha de usuário definido no caso de uma conexão pretegida
	* @return string
	*/
	public function getPassword()
	{
		return $this->st_password;
	}
}

2º Passo – Criando uma classe de tratamento de erros

Também precisaremos de uma classe de tratamento de erros e para que ela funcione adequadamente, deverá ser herdeira da classe Exception (também nativa do PHP).

class DDDException extends Exception
{

}

Você deve estar se perguntando “Por que não usar a classe Exception, já que a classe herdeira não tem nada implementado?”. Minha resposta é “Se em algum momento quisermos adicionar algum controle de erros ainda não implementado na classe Exception, basta modificar a classe DDDException e tudo será resolvido”.

3º Passo – Implementando classe de dados

Esta classe de dados será responsável por encapsular os dados retornados na consulta SQL, como por exemplo, quantidade de linhas, colunas e dados propriamente ditos.

class DDData
{
	const OBJECT = 1;
	const ARRAY_ASSOC = 2;
	const ARRAY_NUM = 3;
	const ARRAY_BOTH = 4;	

	private $o_PDOStatment;	

	/**
	* Retorna dados de uma consulta SQL
	*
	* @param int $f_tout - Usada para formatar a saída dos dados
	* @example $ob->getData(DDData::ARRAY_NUM)
	* 	Use
	* 	DDData::ARRAY_NUM - para retornar um array multidimensional de índices numéricos
	*	DDData::OBJECT - para retornar um array contendo como valores, objetos stdClass com os dados de cada linha
	*	DDData::ARRAY_ASSOC - para retornar um array multidimensional contendo como índices os nomes dos campos
	*   DDData::ARRAY_BOTH - para retornar um array contendo índices numericos e os nomes dos campos
	* @return array
	* @throws DDDException
	*/
	public function getData($f_tout = self::OBJECT)
	{
		if(!is_a($this->o_PDOStatment,'PDOStatement'))
			throw new DDDException('Nothing to return');

		if($this->o_PDOStatment->columnCount() > 0)
		{
			$v_return = array();

			try
			{
				switch($f_tout)
				{
					case self::OBJECT:
						while($o_line = $this->o_PDOStatment->fetchObject())
							array_push($v_return, $o_line);
					break;

					case self::ARRAY_ASSOC:
						$v_return = $this->o_PDOStatment->fetchAll(PDO::FETCH_ASSOC);
					break;

					case self::ARRAY_NUM;
						$v_return = $this->o_PDOStatment->fetchAll(PDO::FETCH_NUM);
					break;

					case self::ARRAY_BOTH;
						$v_return = $this->o_PDOStatment->fetchAll(PDO::FETCH_BOTH);
					break;
				}
			}
			catch(PDOException $e)
			{
				throw  new DDDException($e->getMessage());
			}
		}
		else
			$v_return = FALSE;
		return $v_return;
	}

	/**
	* Recebe um objeto da classe PDOStatment,
	* este objeto será usado apenas pela classe DDDatabase
	* @param PDOStatement $o_PDOStatment
	*/
	public function setData(PDOStatement $o_PDOStatment)
	{
		$this->o_PDOStatment = $o_PDOStatment;
	}

	/**
	* Retorna o numero de linhas geradas na consulta SQL
	* @throws DDDException
	* @return integer
	*/
	public function getNRows()
	{
		if(!is_a($this->o_PDOStatment,'PDOStatement'))
			throw new DDDException('Nothing to return');

		return $this->o_PDOStatment->rowCount();
	}

	/**
	* Retorma o numero de colunas geradas na consulta SQL
	* @return integer
	* @throws DDDException
	*/
	public function getNCols()
	{
		if(!is_a($this->o_PDOStatment,'PDOStatement'))
			throw new DDDException('Nothing to return');

		return $this->o_PDOStatment->columnCount();
	}
}

4º Passo – Implementando a classe principal

A classe principal será responsavel por administrar as conexões e as requisições feitas por consultas SQL

class DDDatabase
{
	private $v_connections;
	private $v_database;

	/**
	* Estabele conexão com o gerenciador de banco de dados
	* @param string $st_database - Alias definido pelo desenvolvedor para uma conexão
	* @param DDConnectSettings $o_DDCSettings - Objeto contendo as configurações de uma conexão
	* @throws DDDException
	*/
	public function setConnectSettings($st_database, DDConnectSettings $o_DDCSettings)
	{
		$v_database[$st_database] = $o_DDCSettings;

		$st_dbname = $o_DDCSettings->getDatabase();

		switch($o_DDCSettings->getApplication())
		{
			case DDConnectSettings::MYSQL:
				$st_dsn = "mysql:dbname=$st_dbname";
			break;

			case DDConnectSettings::PGSQL:
				$st_dsn = "pgsql:dbname=$st_dbname";
			break;

			case DDConnectSettings::MSSQL:
				$st_dsn = "mssql:dbname=$st_dbname";
			break;

			case DDConnectSettings::ORACLE:
				$st_dsn = "oci:dbname=$st_dbname";
			break;

			case DDConnectSettings::SQLite:
				$st_dsn = "sqlite:$st_dbname";
			break;

			default:
				throw new DDDException('Invalid drive');
			break;
		}

		$st_host = $o_DDCSettings->getHost();
		$st_username = $o_DDCSettings->getUser();
		$st_password = $o_DDCSettings->getPassword();
		$in_port = $o_DDCSettings->getPort();

		try
		{
			if(isset($st_host))
			{
				$st_dsn .= ";host=$st_host";
				if(isset($in_port))
					$st_dsn .= ";port=$in_port";
			}

			if(isset($st_username) && isset($st_password))
			{
				$this->v_connections[$st_database] = new PDO($st_dsn, $st_username, $st_password );
			}
			else
			{
				$this->v_connections[$st_database] = new PDO($st_dsn);
			}	

			$this->v_connections[$st_database]->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
		}
		catch (PDOException $e)
		{
			throw new DDDException($e->getMessage());
		}
	}

	/**
	* Retorna um objeto contendo os dados das configurações de uma conexão
	* @param string $st_database - Alias defindo pelo desenvolvedor para a conexão em questão
	*/
	public function getConnectSettings($st_database)
	{
		return $this->v_database[$st_database];
	}

	/**
	* Executa uma consulta SQL, retornando uma instância da classe DDData
	* @param string $st_database - Alias da conexão que desenvolvedor deseja usar
	* @param  string $st_query - Consulta SQL
	* @return DDData
	* @throws DDDException
	*/
	public function execQuery($st_database,$st_query)
	{
		try
		{
			$v_row = $this->v_connections[$st_database]->query($st_query);
			$o_DDData = new DDData();
			$o_DDData->setData($v_row);
		}
		catch (PDOException $e)
		{
			throw new DDDException($e->getMessage());
		}
		return $o_DDData;
	}
}

5º Passo – Exemplo de como usar a classe

//Setando as configurações da conexão
$o_dbconfig = new DDConnectSettings();
$o_dbconfig->setApplication(DDConnectSettings::PGSQL);
$o_dbconfig->setHost('localhost');
$o_dbconfig->setUser('xxx');
$o_dbconfig->setPassword('xxx');
$o_dbconfig->setDatabase('digitaldev');
$o_dbconfig->setPort(5432);

//Instanciando a classe de banco
$o_db = new DDDatabase();
$o_db->setConnectSettings('ddev', $o_dbconfig);
$st_query = "SELECT * FROM control.tbl_usuario";
$o_data = $o_db->execQuery('ddev', $st_query);

//imprimindo dados
var_dump($o_data->getData(DDData::OBJECT));

//imprimindo numero de linhas
echo 'Linhas = '.$o_data->getNRows();

//imprimindo numero de colunas
echo 'Colunas = '.$o_data->getNCols();

Faça download de um outro exemplo de uso, dessa com SQLite, clicando aqui.

Apesar de poder ser usada na maioria das interações com banco de dados em uma aplicação PHP, essa classe ainda não possui métodos que permitem controle de transições. Fica a encargo dos desenvolvedores continuar a implementação de acordo com as necessidades de suas aplicações.

Quem quiser usar a classe, pode fazer o download da mesma clicando aqui.

Qualquer dúvida, usem a área de respostas abaixo do post.

Artigos relacionados
Classe, encapsulamento, herança, composição e agregação
O que é PHP e qual é sua historia?
Instalando o ambiente de desenvolvimento PHP (PHP 5.3.x + Apache + Eclipse)

]]> http://www.digitaldev.com.br/2011/10/22/construindo-uma-classe-em-php-para-conexao-com-banco-de-dados/feed/ 1 Instalando e configurando o Zend Framework http://www.digitaldev.com.br/2011/10/11/instalando-e-configurando-o-zend-framework/ http://www.digitaldev.com.br/2011/10/11/instalando-e-configurando-o-zend-framework/#comments Wed, 12 Oct 2011 02:40:57 +0000 Tarcísio http://www.digitaldev.com.br/?p=379

Continue lendo »]]>


O Zend Framework (também conhecido como ZF) é um framework para aplicações Web de código aberto, orientado a objeto, implementado em PHP 5 e licenciado como New BSD License. Este framework foi desenvolvido com o objetivo de simplificar o desenvolvimento Web enquanto promove as melhores práticas na comunidade de desenvolvedores PHP.

O Zend foi fundado pelos contribuidores do núcleo PHP Zeev Suraski e Andi Gutmans, a junção do nome dos criadores deram origem ao nome do framework.

Requisitos

Antes de mais nada, você precisará de um ambiente de desenvolvimento PHP instalado e configurado, se você ainda cumpriu esse requisito clique aqui.

1 – Download de aquivos necessários

 
Zend Framework 1.11.11 (56,3 MB) – Windows / Linux

Ao longo desse tutorial, também usarei dois outros programas para auxiliar na instalação e configuração do Zend Framework. Eles são o Notepad++ (famoso editor de texto) e o Winrar (compactador/descompactador de arquivos). Faça o download dos mesmos clicando nos links abaixo e depois efetue a instalação.

Notepad++ (5,28 MB) – Windows
Winrar (2,83 MB) – Windows 32 bits / Windows 64 bits

2 – Configurando o Apache

Em ambiente de desenvolvimento, será necessário configurar o apache para interpretar o arquivo .htaccess, mas não se preocupe com essas configurações em servidores Web na Internet, provavelmente as modificações na configuração já foram feitas pelo administrador do servidor.

2.1 – Abra o arquivo httpd.conf do apache usando o editor de texto Notepad++. Em uma instalação padrão no Windows 7, a localização do arquivo é C:\Program Files\Apache Software Foundation\Apache2.2\conf\httpd.conf, já no Windows XP, ele está localizado em C:\Arquivos de programas\Apache2.2\conf\httpd.conf.

2.2 – Procure pela ocorrência do texto #LoadModule rewrite_module modules/mod_rewrite.so e substitua o mesmo por LoadModule rewrite_module modules/mod_rewrite.so

2.3 – Procure pela ocorrência do texto Options FollowSymLinks e substitua por Options FollowSymLinks Includes

2.4 – Procure pelas ocorrências (são duas) do texto Options AllowOverride None e substitua por AllowOverride All

2.5 – Adicione o texto AccessFileName .htaccess no final do arquivo

2.6 – Reinicie o Apache usando o Monitor Apache Servers que fica acessível na barra de ferramentas ao lado do relógio. De um clique com o botão equerdo do mouse em seu ícone e escolha a opção restart.

3 – Descompactando o Zend Framework

Use o programa Winrar para descompactar o arquivo do ZendFramework-1.11.11.zip (Zend Framework 1.11.11) que você acabou de efetuar download na raiz do disco (C:/).

Com isso, o diretório C:/ZendFramework-1.11.11 foi criado.

4 – Configurando os variáveis de ambiente do Windows

Depois de termos descompactado o Zend Framework na raiz do disco, iremos configurar o Windows para incluir o diretorio C:\ZendFramework-1.11.11\bin na variável de ambiente Path.

4.1 – Vá em Painel de Controle->Sistema->Configurações Avançadas->Aba Avançado->Variáveis de Ambiente

4.2 – Na caixa Variáveis de Ambiente, procure pela variável Path e de um duplo clique na mesma, com isso uma caixa edição se abrirá. vá até o fim da mesma e adicione ;C:\ZendFramework-1.11.11\bin.

4.3 – Após essas modificações, reinicie o computador

5 – Criando um projeto de Teste

5.1 – No Windows 7, vá no menu Iniciar e digite cmd na caixa de busca, já no Windows XP, o comando cmd deve ser efetuado na caixa executar no menu Iniciar. Com isso, uma janela do programa cmd será apresentada.

5.2 – Dentro do programa cmd, digite cd C:\Program Files\Apache Software Foundation\Apache2.2\htdocs caso esteja no Windows 7 ou cd C:\Arquivos de programas\Apache Software Foundation\Apache2.2\htdocs caso esteja no Windows XP e aperte Enter.

Estou assumindo que você está usando as configurações padrões do apache, ou seja, que você não modificou o parametro DocumentRoot do arquivo httpd.conf. Caso contrário, você deverá usar o caminho do seu DocumentRoot no comando acima. Exemplo: Digite cd C:\www no programa cmd caso o seu DocumentRoot seja C:\www

5.3 – Agora nós criaremos um projeto, para isso digite o comando zf create project digitadev e aperte Enter

5.4 – Antes de podermos efetuar os testes, precisaremos copiar a pasta C:\ZendFramework-1.11.11\library\Zend para C:\Program Files\Apache Software Foundation\Apache2.2\htdocs\digitaldev\library caso esteja no Windows 7 ou C:\Arquivos de programas\Apache Software Foundation\Apache2.2\htdocs\digitaldev\library caso esteja no Windows XP.

6 – Testando a configuração

6.1 – Abra o navegador web de sua preferencia e digite o seguinte endereço http://localhost/digitaldev/public. Se tudo ocorreu bem, o seu navegador mostrará uma página como a da imagem abaixo.

Aqui está o tutorial passo a passo para instalar o Zend Framework.
Qualquer dúvida ou sugestão, usem a parte de respostas no final do post.

Post relacionados
O que é PHP e qual é sua historia?
Instalando o ambiente de desenvolvimento PHP (PHP 5.3.x + Apache + Eclipse)

]]> http://www.digitaldev.com.br/2011/10/11/instalando-e-configurando-o-zend-framework/feed/ 3 Classe, encapsulamento, herança, composição e agregação http://www.digitaldev.com.br/2011/09/27/classe-encapsulamento-heranca-composicao-e-agregacao/ http://www.digitaldev.com.br/2011/09/27/classe-encapsulamento-heranca-composicao-e-agregacao/#comments Tue, 27 Sep 2011 23:54:18 +0000 Tarcísio http://www.digitaldev.com.br/?p=279

Continue lendo »]]>


Para um programa em uma linguagem qualquer ser orientado a objeto, ele tem que ser formado por classes, heranças, composições e agregações. A maioria das linguagens de programação hoje em dia suporta esse paradigma de desenvolvimento. Vamos então a alguns conceitos básicos sobre o assunto.

Classes

Uma classe é uma espécie de modelo de dados formado por atributos e métodos.

Atributos e métodos

Atributos são variáveis internas de uma classe. Por exemplo, se fôssemos criar uma classe para representar uma Pessoa, provavelmente as variáveis Nome e RG seriam alguns dos seus atributos.

Métodos são funções internas de uma classe. Por exemplo, se fossemos criar uma classe para representar uma Pessoa, provavelmente as funcionalidades definirNome e retornarNome seriam alguns dos seus métodos.

Construtores e destrutores de uma Classe

Construtores são métodos de inicialização de uma classe. Eles serão executados automaticamente assim que um objeto dessa classe for instanciado dentro do programa. Geralmente são usados para inicializar variáveis ou executar algum bloco de código necessário.

Destrutores exercem função parecida a do construtor. São executados automaticamente, mas somente quando o programa decidir que um objeto de uma determinada classe não será mais usado ou quando uma instrução de destruição (inserida pelo programador) for encontrada no código. Geralmente são usados para liberar recursos alocados pelo objeto durante a execução.

Exemplo de classe

Quando queremos construir uma classe para representar um ponto em um universo 2D (coordenadas x,y), devemos definir os atributos e os métodos para ela. Nesse caso, os atributos são valores numéricos de x e y, já os métodos são as funções internas que permitem definir e recuperar os valores de x e y.

Exemplo de classe Ponto implementada em linguagem de programação PHP

class Ponto
{
    //atributos
    private $x;
    private $y;

    //construtor da classe
    function __construct($dx,$dy)
    {
        $this->x = $dx;
        $this->y = $dy;
    }

    //métodos
    public function definirX($dx)
    {
        $this->x = $dx;
    }

    public function retornarX()
    {
        return $this->x;
    }

    public function definirY($dy)
    {
        $this->y = $dy;
    }

    public function retornarY()
    {
        return $this->y;
    }

    //destrutor da classe
    function __destruct()
    {
    }
}

Exemplo da classe Ponto implementada em linguagem de programação C++

class Ponto
{
    private:
        int x,y; //atributos

    public:

        //construtor da classe
        Ponto(int dx, int dy)
        {
            this->x = dx;
            this->y = dy;
        }

        //métodos
        void definirX(int dx)
        {
            this->x = dx;
        }

        int retornarX(void)
        {
            return this->x;
        }

        void definirY(int dy)
        {
            this->y = dy;
        }

        int retornarY(void)
        {
             return this->y;
        }

        //destrutor da classe
        ~Ponto(void)
        {
        }
}

Encapsulamento

O encapsulamento nos permite definir como os atributos e métodos de uma classe serão acessados. Para isso, existem limitadores quem permitem definir quem poderá acessar os tais.

Cada linguagem de programação possui os seus próprios limitadores acesso, mas os mais comuns são:
público (public) – o método ou atributo pode ser acessado por qualquer classe.
protegido (protected) – o método ou atributo pode ser acessado apenas pela própria classe ou classes herdeiras.
privado (private) – o método ou atributo pode ser acessado apenas pela própria classe.

Herança

Uma herança permite que uma classe herde os métodos e atributos públicos e protegidos de uma outra classe. Com isso, a classe herdeira é chamada de classe filho e a classe herdada é chamada de classe pai.

Exemplo de herança

Definiremos uma classe Circulo representada em um universo 2D, a mesma terá como atributos as coordenas x e y que definem onde o seu ponto central está localizado e o seu ráio.

Classe Circulo implementada em linguagem de programação PHP

class Circulo
{
    //atributos
    private $x;
    private $y;
    private $raio

    //construtor da classe
    function __construct()
    {
    }

    //métodos
    public function definirX($dx)
    {
        $this->x = $dx;
    }

    public function retornarX()
    {
        return $this->x;
    }

    public function definirY($dy)
    {
        $this->y = $dy;
    }

    public function retornarY()
    {
        return $this->y;
    }

    public function definirRaio($draio)
    {
        $this->raio = $draio;
    }

    public function retornarRaio()
    {
        return $this->raio;
    }

    //destrutor da classe
    function __destruct()
    {
    }

}

Classe Circulo implementada em linguagem de programação C++

class Circulo
{
    //atributos
    private:
        int x, y, raio;

    public:

        //construtor da classe
        Circulo()
        {
        }

        //métodos
        void definirX(int dx)
        {
            this->x = dx;
        }

        int retornarX(void)
        {
            return this->x;
        }

        void definirY(int dy)
        {
            this->y = dy;
        }

        int retornarY(void)
        {
             return this->y;
        }

        void definirRaio(int draio)
        {
            this->raio = draio;
        }

        int retornarRaio()
        {
            return this->raio;
        }

        //destrutor da classe
        ~Circulo()
        {
        }
}

Agora, com base na classe Circulo, criaremos uma segunda classe chamada Bola (classe filho).

Classe Bola implementada em linguagem de programação PHP

class Bola extends Circulo
{
    //atributo
    private $cor;

    //construtor da classe
    function __construct()
    {
        //chamando o construtor da classe pai (Circulo)
        parent::__construct();
    }

    //métodos
    public function definirCor($dcor)
    {
        $this->cor = $dcor;
    }

    public function retornarCor($dcor)
    {
        return $this->cor;
    }

    //destrutor da classe
    function __destruct()
    {
        //chamando o destrutor da classe pai (Circulo)
        parent::__destruct();
    }

}

Classe Bola implementada em linguagem de programação C++

class Bola : public Circulo
{
    //atributo
    private:
        char* cor;

    public:
        //construtor da classe
        Bola()
        {
        }

        //métodos
        void definirCor(char* dcor)
        {
            this->cor = new char[(sizeof(dcor) / sizeof(char))];
            strcpy(this->cor,dcor);
        }

        char* retornarCor()
        {
            return this->cor;
        }

        //destrutor da classe
        ~Bola()
        {
            if(this->cor)
                delete this->cor;
        }
}

Com isso, todos os métodos da classe pai estarão acessíveis pela classe filho. Veja o exemplo no código abaixo.

Linguagem de programação PHP

    $bola= new Bola();

    //métodos da classe circulo herdados pela classe bola
    $bola->definirX(10);
    $bola->definirY(15);
    $bola->definirRaio(10);

    //método da própria classe bola
    $bola->definirCor("Azul");

Linguagem de programação C++

    Bola *bola;
    bola = new Bola();

    //métodos da classe circulo herdados pela classe bola
    bola->definirX(10);
    bola->definirY(15);
    bola->definirRaio(10);

    //método da própria classe bola
    bola->definirCor("Azul");

Composição

Uma composição acontece quando uma classe A tem instanciada dentro dela um objeto (ou lista de objetos) de uma outra classe B, quando a classe A for destruída, os objetos da classe B instanciados dentro da classe A também serão destruídos.

Pensando sobre a definição de composição acima, um bom exemplo para esclarecer essa associação é construir uma classe para representar o nosso Universo 2D com 20 coordenada possíveis no eixo x e 20 coordenada possíveis no eixo y.

Classe Universo implementada em linguagem de programação PHP

class Universo
{
    private $pontos[20][20];

    //construtor da classe
    function __construct()
    {
        for($x = 0; $x < 20 ; $x++ )
        {
            for($y = 0 ; $y < 20 ; $y++)
                $this->pontos[$x][$y] = new Ponto($x,$y);
        }
    }

    public function retornarPonto($x ,$y)
    {
        return $this->pontos[$x][$y];
    }

    //destrutor da classe
    function __destruct()
    {
    }

};

Classe Universo implementada em linguagem de programação C++

class Universo
{
    private:
        Ponto* pontos[20][20];

    public:
        //construtor da classe
        Universo()
        {
            for(int x = 0; x < 20 ; x++ )
            {
                for(int y = 0 ; y < 20 ; y++)
                    this->pontos[x][y] = new Ponto(x,y);
            }
        }

        Ponto* retornarPonto(int x, int y)
        {
            return this->pontos[x][y];
        }

        //destrutor da classe
        ~Universo()
        {
        }
};

Com o código acima, é fácil visualizar que se o universo for destruído, todos os pontos pertencentes a ele também serão destruídos.

Agregação

Uma Agregação acontece quando uma classe A agrega dentro dela um objeto (ou lista de objetos) de uma outra classe B, quando a classe A for destruída, o objeto da classe B permanece intacto, ou seja, os objetos contidos podem existir sem serem parte do objeto que os contém.

Para demonstrar como funciona uma agregação, iremos fazer algumas modificações na classe Circulo

Classe Circulo implementada em linguagem de programação PHP

class Circulo
{
    //atributos
    private $ponto;
    private $raio

    //construtor da classe
    function __construct()
    {
    }

    //métodos
    public function definirPonto(Ponto $ponto)
    {
        $this->ponto = $ponto;
    }

    public function retornarPonto()
    {
        return $this->ponto;
    }

    public function definirRaio($draio)
    {
        $this->raio = $draio;
    }

    public function retornarRaio()
    {
        return $this->raio;
    }

    //destrutor da classe
    function __destruct()
    {
    }
}

Classe Circulo implementada em linguagem de programação C++

class Circulo
{
    //atributos
    private:
        Ponto* ponto;
        int raio;

    public:
        //construtor da classe
        Circulo()
        {
        }

        //métodos
        Ponto* retornarPonto(void)
        {
            return this->ponto;
        }

        void definirPonto(Ponto* ponto)
        {
            this->ponto = ponto;
        }

        void definirRaio(int draio)
        {
            this->raio = draio;
        }

        int retornarRaio()
        {
            return this->raio;
        }

        //destrutor da classe
        ~Circulo()
        {
        }
}

Finalmente, usando a classe Universo e a classe Circulo, poderemos dar um exemplo real de agregação.
Agregaremos um objeto classe Ponto pertencente ao Universo 2D dentro de uma instância da classe Circulo

Linguagem de programação PHP

    //instanciando os objetos
    $universo = new Universo();
    $circulo = new Circulo();

    //Configurando o raio e as coordenadas do ponto central do circulo
    $circulo->definirRaio(5);
    $circulo->definirPonto($universo->retornarPonto(10,10));

Linguagem de programação C++

    //definindo as variáveis
    Universo* universo;
    Circulo* circulo;

    //instanciando os objetos
    universo = new Universo();
    circulo = new Circulo();

    //Configurando o raio e as coordenadas do ponto central do circulo
    circulo->definirRaio(5);
    circulo->definirPonto(universo->retornarPonto(10,10));

Aqui está uma breve introdução à OOP (Object-oriented programming ou Programação Orientada a Objeto).
Qualquer dúvida ou sugestão, usem a parte de respostas no final do post.

]]> http://www.digitaldev.com.br/2011/09/27/classe-encapsulamento-heranca-composicao-e-agregacao/feed/ 1 SQL Injection, como evitar esse tipo de ataque em páginas PHP http://www.digitaldev.com.br/2011/09/22/sql-injection-como-evitar-esse-tipo-de-ataque-em-paginas-php/ http://www.digitaldev.com.br/2011/09/22/sql-injection-como-evitar-esse-tipo-de-ataque-em-paginas-php/#comments Thu, 22 Sep 2011 20:56:51 +0000 Tarcísio http://www.digitaldev.com.br/?p=225

Continue lendo »]]>


O que é SQL Injection?

O SQL Injection, ou injeção de SQL, é um tipo de ameaça de segurança que se aproveita de falhas em sistemas que interagem com bases de dados via SQL. O SQL Injection ocorre quando o atacante consegue inserir uma série de instruções SQL dentro de uma consulta (query) através da manipulação das entrada de dados de uma aplicação.

No caso do PHP, o SQL Injection geralmente ocorre em páginas de formulários que possuam falhas. Através disso, o atacante poderá burlar sistemas de senhas ou apagar componentes da estrutura do banco de dados (tabelas, databases, registros, esquemas e outros).

Exemplo – Formulário de login

Para demonstrar como o ataque acontece, vou usar um formulário simples de login.

Formulário de Login

A imagem abaixo mostra um exemplo clássico de um código PHP e uma consulta SQL responsáveis por efetuar uma busca de usuários no banco de dados.

Código PHP e consulta SQL do formulário de login

Agora, imagine que eu escreva o código ‘ OR 1=1 OR ‘ ‘=’ no campo de Usuário do formulário de login e uma senha qualquer.

Formulário de Login - Imagem 1

A consulta SQL no código PHP ficaria assim

Código PHP e consulta SQL do formulário de login

Pensando um pouco sobre a consulta SQL resultante mostrada na imagem acima. O que você acha que aconteceria se ela fosse executada?
Ela simplesmente retornaria todos os usuários do banco, o resultado dela seria exatamente igual à

SELECT usu_in_id, usu_st_nome, usu_st_login, usu_st_email FROM control.tbl_usuario

e o atacante teria acesso ao sistema.

Imagine então que o o atacante seja um pouco mais malicioso, ao invés de entrar no sistema, ele queira apagar a tabela de usuários. Então ele só teria que escrever ‘; DELETE FROM tbl_usuario; SELECT * FROM tbl_usuario WHERE ‘ ‘=’ no campo de Usuário e então a consulta resultante ficaria

Código PHP e consulta SQL do formulário de login

Dividi a consulta resultante da imagem acima em três outras consultas para facilitar a visualização

Código PHP e consulta SQL do formulário de login

Como evitar esse tipo de ataque em páginas escritas em PHP

Olhando o exemplo do formulário de login acima, você consegue chegar a uma solução do problema?
Se você pensou em substituir o caractere ‘ por um outro qualquer, está no caminho certo.

O jeito mais simples é usar a função nativa do PHP addslashes($str) para substituir o caractere ‘ por \’ vindos de campos de texto do formulário. Isso deixaria o nosso código do formulário de login assim

Código PHP e consulta SQL do formulário de login


Com isso, a tentativa de injetar o código SQL ‘ OR 1=1 OR ”=’ resultaria em

Código PHP e consulta SQL do formulário de login

O Problema de usar a funçãoaddslashes($str) é que você não poderá esquecer de usá-la para nenhum campo de texto do formulário, ou seja, se o seu formulário possuir 50 campos de texto, você terá que filtrar todos eles.

Existe uma maneira de fazer com que o interpretador PHP filtre automaticamente todos os campos de formulários, substituindo o caractere ‘ por \’. Assim, não será mais necessário usar a função addslashes($str).

Para filtrar automaticamente os campos de formulários, substitua magic_quotes_gpc = Off por magic_quotes_gpc = On no arquivo php.ini (arquivo de configuração do interpretador PHP).

Com esses cuidados, o problema de segurança está resolvido?
Não. Ainda precisamos tomar cuidado com os campos numéricos dos formulários.

Eu não vou entrar muito nesse assunto, mas meu conselho é sempre verificar se os dados vindos de campos numéricos são realmente numéricos usando a função is_numeric($var)

if(is_numeric($in_idade))
{
//executa o código
}

Essas são as dicas que e tenho para dar sobre como se proteger de ataques do tipo SQL Injection. Espero ter ajudado vocês.

Qualquer dúvida ou sugestão, usem a área de respostas no final do post.

]]> http://www.digitaldev.com.br/2011/09/22/sql-injection-como-evitar-esse-tipo-de-ataque-em-paginas-php/feed/ 4