Workshop de PHP

[helldanger1]

Avaliações dos usuários em PHP



Sistema criado em PHP e MySQL para implementar a possibilidade de que os usuários possam votar uma página web.
Por Emmanuel García De Caro





O processo é parecido, ou melhor, é o mesmo empregado para tirar qualquer média, por exemplo: a média de notas de um estudante.

PTOS ACUMULADOS / TOTAL DE ACUMULAÇÕES

Para isso, utilizaremos uma tabela de dados:

<? CREATE TABLE `avaliacoes` (
`id_noticia` int(9) NOT NULL default '0',
`num_votos` int(20) NOT NULL default '0',
`ptos` int(20) NOT NULL default '0'
) TYPE=MyISAM;
?>

Cabe destacar que não é necessário utilizar uma tabela de dados individual, sempre e quando se conte com uma tabela geral de artigos ou conteúdos e obviamente se disponham pelo menos dos dois últimos campos desta tabela, para o funcionamento do script.

Este sistema trabalha com 1 só registro por artigo ou conteúdo, onde o campo id_noticia, se refere ao identificador de nossa notícia ou conteúdo, num_votos; o total de votos realizados em torno desse conteúdo e ptos a soma de todos os votos:

Por exemplo:

id_noticia= 00001 - nossa primeira notícia
num_votos= 3 - somente três votos nesta notícia.
Ptos= 15 - é provável que os três tenham votado por 5 pontos.

Então, logicamente, a avaliação média é de 5 ptos.

Código Fonte:

<?
#####CONEXÃO A MYSQL
@mysql_connect('localhost','usuario','pass')or die ('Falhou a conexão: '.mysql_error());
@mysql_select_db('base_de_dados')or die ('Erro ao selecionar a BD: '.mysql_error());
////end conexão
$SSQL_=mysql_query("SELECT * FROM avaliações WHERE id_noticia='".$_GET[id]."'")or die(mysql_erro());
$array_d=mysql_fetch_array($SSQL_);
$avaliacaO_total=@round($array_d[ptos]/$array_d[num_votos],2);

if(isset($_POST[valor])){
if(mysql_num_rows($SSQL_)==0){
@mysql_query("INSERT INTO avaliacoes VALUES('".$_GET[id]."','1','".$_POST[valor]."')")or die ('ERRO AO INSERIR REGISTRO: '.mysql_error());
}else{
@mysql_query("UPDATE avaliacoes SET num_votos=num_votos+1,ptos=ptos+".$_POST[valor]." WHERE id_noticia='".$_GET[id]."'")or die ('ERRO AO MODIFICAR REGISTRO: '.mysql_error());
}
header('Location:'.$REQUEST_URI);
exit;
}

'<strong>Avaliação Média : '.$avaliacaO_total.'</strong> <div style="background-color:#EFEFEF; width:50px"><img width="'.($ avaliacaO _total*5).'" height="6" style="background-color: #000099"></div> <br>Total de votos: '.$array_d[num_votos];

?><hr>
<form action="<? $REQUEST_URI;?>" method="post">
Nova avaliação:
<select name="valor" id="valor">
<? for ($i=1; $i<=10 ; $i++) '<option value="'.$i.'">'.$i.'</option>';?>
</select>
<input type="submit" value="Votar por este artigo">
</form>

Explicando:

Antes de nada, como de costume criamos a conexão ao servidor de mysql; onde devemos fornecer nossos dados de acesso reais.

Selecionamos a base de dados sobre a qual trabalharemos.

E geramos uma petição ao servidor Mysql mysql_query(); onde solicitamos os registros armazenados previamente por cada conteúdo ou artigo.

Atribuímos à variável $array_d, a matriz devolvida por mysql_fetch_array(), para logo agrupar na variável $avaliacaO_total; o valor devolvido pela divisão entre $array_d[ptos] y $array_d[num_votos], arredondamos o valor com 2 decimais round(), colocamos o @ ao começo da função para evitar que se mostrem possíveis erros se por acaso a divisão for entre 0 (zero).

Finalmente, iniciamos uma condição para comprovar se ($_POST[valor]) está definida, ou seja, se está se processando o formulário para inserir novas avaliações. Se a condição avalia TRUE então executamos uma série de instruções, sendo a primeira uma nova condição:

if(mysql_num_rows($SSQL_)==0):

Para comprovar se ainda não há nenhum registro e avaliação e inserir um novo.
@mysql_query("INSERT INTO…

Do contrário ( else) quer dizer nesta ocasião que pelo menos uma pessoa já votou e por isso não podemos fazer um novo registro, ou melhor, uma modificação do já existente.

@mysql_query("UPDATE avaliações…

Posteriormente, sem importar qual das duas rotinas encontra selecionado o script, realiza um encaminhamento header(Location: … ) a .$REQUEST_URI, que é exatamente a mesma URL , para que o usuário veja os dados atualizados. Ou seja, seu voto adicionado na lista.

Finalmente, imprimimos o resultado, com um gráfico e adicionamos o formulário que será utilizado para uma próxima votação.

Já ficaria a sua escolha, modificá-lo um pouco (se desejar) para que o usuário possa votar somente 1 vez.

 

[helldanger1]

Rastrear os robôs de buscadores




Código para fazer um rastreamento do comportamento de um buscador ou sua interatividade com nossa web.
Por Jorge De Freitas





Neste artigo vamos comentar sobre os buscadores e como poder fazer um rastreamento de seu comportamento ou interatividade com nossa web com as funções PHP $HTTP_USER_AGENT y $QUERY_STRING

O primeiro que vamos fazer é perguntarmos: Qual buscador vou rastrear? Uma vez respondido isto, neste caso, Google.com.

Vejamos o seguinte código php que deve ser usado em todas as páginas de nossa web que queremos rastrear ao robô (o ideal é criar uma página com este código e agregar a página criada às demais páginas com include, isto torna mais fácil às mudanças a este script mais adiante):

<?php
if(eregi("google",$HTTP_USER_AGENT))
{
if ($QUERY_STRING != "")
{$url = "http://".$SERVER_NAME.$PHP_SELF.'?'.$QUERY_STRING;}
else
{$url = "http://".$SERVER_NAME.$PHP_SELF;}
$today = date("F j, Y, g:i a");
mail("webmaster@criarweb.com", "Foi detectado um robô de Google em http://$SERVER_NAME",
"$today - Google indexou a página $url.\n
..:: MAIS OUTRA PÁGINA ::..");
}
?>

Explicamos o código

Este script reconhece ao robô de google e a página na qual realizou o rastreamento, e envía um e-mail ao webmaster da página com os dados dia e hora do sucedido e nos dá uma breve mensagem, ou também pode se armazenar em um banco de dados, etc.

Agora para os demais buscadores só basta mudar: ("google",$HTTP_USER_AGENT) pelo respectivo nome ao robô, exemplo:

- Google: ("google",$HTTP_USER_AGENT )
- Yahoo: ("slurp",$HTTP_USER_AGENT )
- Altavistar: ("scooter",$HTTP_USER_AGENT)

Esperamos que lhes sirva.

 

[helldanger1]

Recomendar um site usando PHP



Script que recomenda a um usuário a visitar o site, via e-mail.
Por Eugenia Bahit





Este sistema permite ao usuário enviar pela web, um e-mail a outra pessoa, convidando-o a visitar o site.

Requer somente um módulo PHP que se encarregará de mostrar o formulário de indicação, enviar o e-mail e devolver um acuse de envio.

recomendar.php

<!-- formulário de recomendação -->

<? if ($HTTP_GET_VARS["acao"] == "") {
?>

<form method="post" action="recomendar.php?acao=enviar" name="recomende">
<b>Recomende este site</b><br><br>
Seu Nome: <input type="text" name="n_remetente" size="10"><br>
Seu E-mail: <input type="text" name="e_remetente" size="20"><br>
Nome do seu amigo: <input type="text" name="n_destinatario" size="10"><br>
E-mail do seu amigo: <input type="text" name="e_destinatario" size="20"><br><br>
<input type="submit" value="Recomendar">
</form>

<!-- envio do formulário e confirmação de envio ou informação de erros -->
<?
}

elseif ($HTTP_GET_VARS["accion"] == "enviar") {

// recolho as variáveis que vem pelo formulário
$n_destinatario = $HTTP_POST_VARS["n_destinatario"];
$e_destinatario = $HTTP_POST_VARS["e_destinatario"];
$n_remetente = $HTTP_POST_VARS["n_remetente"];
$e_remetente = $HTTP_POST_VARS["e_remetente"];

// se os campos não estiverem vazios
if ($n_destinatario != "" && $e_destinatario != "" && $n_remetente != "" && $e_remetente != "") {

//indica url de seu site
$url = "http://www.seusite.com";
//indique o nome de seu site
$nome_do_site = "Seu Site";
//indique o assunto da mensagem
$assunto = $n_remetente . " lhe recomenda um site";
//redigir a mensagem
$mensagem = "Olá " . $n_destinatario . ":<br>";
$mensagem .= $n_remetente . " lhe recomenda que visite <b>" . $nome_do_site . "</b>.<br>";
$mensagem .= "Pode vê-lo em <a href='" . $url . "'>" . $url . "</a><br><br>Saudações!";

//indica que o e-mail será enviado em formato HTML

$titulo = "From:".$e_remetente."\nReply-To:".$e_remetente."\n";
$titulo .= "X-MailerHP/".phpversao()."\n";
$titulo .= "Mime-Versao: 1.0\n";
$titulo .= "Content-Type: text/html";

//envia a mensagem

mail($e_destinatario,$assunto,$mensagem,$titulo);

//Informa ao usuário que a mensagem foi enviada

echo "<b>A mensagem foi enviada</b>.<br>Obrigado por nos recomendar!";

}

//se existirem campos vazios, envia uma mensagem de erro

else {

echo "Por favor, é necessário completar todos os campos.<br>";
echo "<a href='recomendar.php'>Clique aqui</a> para corrigir os campos.";

}

}
?>

 

[helldanger1]

Criação de um log de erros


Como criar um arquivo que armazena os erros que foram produzidos durante a execução de um programa, acrescentar um log de erros a nossa página.
Por Eloi de San Martin Lagranje





Um log de erros permitirá controlar quando se produz um erro para corrigi-lo e evitar que se repita no
futuro.

Para criar um log, abriremos ,o arquivo em modo 'a' (escritura ao
final) e escreveremos o erro indicando a data, para simplificar o
trabalho podemos incluir tudo em uma função:

<?php
function error($numero,$texto){
$ddf = fopen('error.log','a');
fwrite($ddf,"[".date("r")."] Error $numero: $texto\r\n");
fclose($ddf);
}
?>

Uma vez declarada a função, teremos somente que chamá-la da
seguinte forma quando se produzir um erro para que se salve em
error.log:

<?php
// Se nao existe a cookie sessao
if(!isset($_COOKIE['sessao'])){
// Salvamos um erro
error('001','Nao existe a cookie de sessao');
}
?>

Desta maneira, cada vez que um usuário entra nesta página sem a
cookie sessao, armazena-se uma nova linha no arquivo, indicando:

[data] Erro 001: Nao existe a cookie de sessao

Vamos ver agora como podemos melhorar isto de forma que além de poder gravar os erros que nós definirmos em nosso site, que armazene também os erros produzidos durante a execução do script php.

Conseguiremos isto indicando ao intérprete Zend que chame à
função error() cada vez que o código PHP contenha um erro com a
função set_error_handler:

<?php
set_error_handler('error');
?>

Então, o código completo fica da seguinte forma:

<?php
function error($numero,$texto){
$ddf = fopen('error.log','a');
fwrite($ddf,"[".date("r")."] Error $numero:$texto\r\n");
fclose($ddf);
}
set_error_handler('error');
?>

E desta maneira finalizamos nosso script para gerar um
log de erros pessoais e de PHP.

 

[helldanger1]

Comprimir página PHP


Para abreviar o tempo de carregamento de nossas páginas geradas com PHP, podemos envia-las ao navegador comprimidas com Gzip.
Por Eloi de San Martin Lagranje





Para abreviar o tempo de carregamento de nossas páginas geradas com PHP, podemos enviá-las ao navegador comprimidas com GZip utilizando as funções de controle de saída, para isso, chamaremos à função pré-definida ob_gzhandler como tratante da função ob_start, vejamos um exemplo:

<?
ob_start("ob_gzhandler");

// Conteúdo da página, pode conter
// tanto HTML como PHP

ob_end_flush();
?>

Devemos ter em conta que todo o conteúdo deve estar no lugar indicado, portanto os primeiros caracteres do documento devem ser <? e os dois últimos ?> e não se deve acrescentar nada exceto onde se indique, se não formos com cuidado receberemos um erro parecido ao seguinte:

Warning: Cannot add header information...

Outra forma ainda mais completa de compressão, consiste em aplicar a mesma função, mas eliminando por sua vez os espaços e quebras de linha da fonte do documento, o que não terá nenhum efeito visual, mas diminuirá o tempo de download, vejamos como fazer:

<?
ob_start();

// Conteúdo da página, pode conter
// tanto HTML como PHP

$cntACmp =ob_get_contents();
ob_end_clean();
$cntACmp=str_replace("\n",' ',$cntACmp);
$cntACmp=ereg_replace('[[:space:]]+',' ',$cntACmp);
ob_start("ob_gzhandler");
echo $cntACmp;
ob_end_flush();
?>

Este método funciona igual que o anterior só que antes de comprimir elimina as quebras de linha e espaços desnecessários, mas devemos ter em conta as mesmas precauções porque senão, não funcionará.

Este método de compressão, desenvolvemos para Programação Web, como você pode comprovar ao ver o código fonte desta mesma página, todo o código aparece sem quebras de linha nem tabulações por uma simples questão de compressão.

 

[helldanger1]

Contador PHP com imagens



Criação de um contador simples de visitas a uma página com a linguagem PHP, que utiliza imagens para mostrar o número de acessos.
Por Josue Gutiérrez Olivares





Aqui lhes deixo o código PHP de um contador melhorado com a inclusão de imagens para gerar o número de visitas ao invés de utilizar texto como estava sendo realizado no artigo Contador simples de páginas PHP.

Para colocar em funcionamento o exemplo há que criar somente os números do 0 ao 9 em formato imagem. É preferível que os números sejam menores a estas propriedades: width="17" height="28"

Outra cosa, parte do código foi tomado deste contador. O que eu inclui desta vez é o que faz com que chame às imagens, que devem ser nomeadas "0. gif", "1.gif", .., "9.gif".

<html>
<head>
<title>Contador PHP com imagens</title>
</head>

<body>
<?php
$arquivo = "contador.txt";
$contador = 0;

$fp = fopen($arquivo,"r");
$contador = fgets($fp, 26);
fclose($fp);

++$contador;

$fp = fopen($arquivo,"w+");
fwrite($fp, $contador, 26);
fclose($fp);
?>

<table width="102" border="0" align="center" cellpadding="0" cellspacing="0">
<tr>
<?php

/* Arrumo de 0-9 nome dos arquivos gifs*/
$numero[0]="0.gif";
$numero[1]="1.gif";
$numero[2]="2.gif";
$numero[3]="3.gif";
$numero[4]="4.gif";
$numero[5]="5.gif";
$numero[6]="6.gif";
$numero[7]="7.gif";
$numero[8]="8.gif";
$numero[9]="9.gif";

/*Cria-se variável para que contenha a longitude da cadeia*/
/*é a partir daí onde se sabe que mostrará o contador em GIFS*/

$longitude = strlen ($contador);

/* Loops para mostrar os números*/
$ate = 6-$longitude;

For ($celula = 1;$celula <= $ate;$celula++)
{
echo "<td width=\"17\" height=\"28\" valign=\"top\"><div align=\"center\"><img src=\"$numero[0]\"></div></td>";
}
$ate = $longitude-1;
For ($celula = 0;$celula <= $ate;$celula++)
{
$num = substr ($contador, $celula, 1);
echo "<td width=\"17\" height=\"28\" valign=\"top\"><div align=\"center\"><img src=\"$numero[$num]\"></div></td>";
}

?>

</tr>
</table>
</div>
</body>
</html>

 

[helldanger1]

Editor PHP Maguma Studio



Apresentamos o editor de PHP Maguma Studio Light. Mostramos como configurá-lo para poder utilizar o debugger, muito útil para depurar nossos códigos PHP.
Por Agustin Jareño





Valorize este artigo: 0 votosSistema:
Win95/98/NT/ME/2000/XP
Idioma: Inglês
Licença: Shareware
Tamanho: 1.8 MB
Web: maguma.com


Introdução:

O principal problema que temos com php é que não podemos ver passo a passo o que está fazendo o código com o qual nos torna muito mais difícil descobrir as falhas que possam surgir.

Uma alternativa a isto é instalarmos um programa que nos permita realizar isto. Entre outros podemos destacar o PHP debugger (permite depurar programas escritos em php), que é Freeware e está disponível em PHP IDE - NuSphere PhpED - Complete PHP IDE for PHP Development..

Também temos o Maguma Studio Light for PHP, que permite escrever e depurar scripts de PHP e também é Freeware e o temos disponível em maguma.com.

Instalação e configuração do Maguma:

Uma vez baixado e instalado vamos à preferências em View>Preferences ou em Edit>Preferences.

Aqui devemos indicar o intérprete de php. Ou seja, devemos dizer onde se encontra o arquivo php.exe. Este deve estar na pasta onde descomprimimos o php, o buscamos e colocamos toda a rota.

Será uma página como esta:

Debaixo deste campo em Server Setting devemos colocar as opções do servidor web utilizado. Tal como:

Agora devemos instalar e configurar o DBG, ou seja, o debugger.

Descomprimimos e se criará um diretório cujo nome indica a versão utilizada pelo Maguma. Será algo como C:\dbg-2.11.3-Win32. Abrimos e copiamos o arquivo dll do subdiretório Server do DBG ao subdiretório extensões do PHP utilizado e o renomeamos:

Php_dbg.dll-4.2.3>php_dbg.dll.

Ou seja, tiramos os números do final e deixamos somente a extensão dll.

Agora para que o debugger nos funcione no Maguma deveremos modificar algumas partes mais.

•Buscamos o arquivo php.ini (que estará na pasta Windows) e mudamos a opção extensao_dir por:

Extensao_dir=c:\php-4.2.1-win32\extensao\


•Na seção Windows Extensão, acrescentamos:

Extensão=php_dbg.dll


•Ao final do arquivo php.ini acrescentaremos:

[Debugger]
debugger.enable_session_cookie=off
debugger.enabled = on
debugger.enabled = on
debugger.fail_silently = on
debugger.ignore_nops=off
debugger.JIT_enabled = off
debugger.JIT_host= clienthost
debugger.JIT_level = 3
debugger.JIT_port = 7869
debugger.profiler_enabled = trae
debugger.sessioni_nocache = on
debugger.timeout_seconds=300



Uma vez feito isso, configuraremos o DBG, ou seja; o único que nos falta é dar o arranque para que funcione. Para isso, vamos à pasta C:\dbg-2.11.3-Win32, a abrimos e abrimos outra pasta de dentro chamada "client". Aqui, vemos vários arquivos, o único que nos interessa é o install.bat. Executamos e comprovamos que nos aparece uma espécie de antena parabólica ao lado do relógio de Windows (parte direita inferior).

Agora abriremos o Maguma e voltamos a abrir a opção de preferências que se encontrava em Edit>Preferences ou em View>Preferenes e na opção PHP-Parsing a colocamos como indica a figura

As duas funções abaixo podem não estar (segundo versões) isto somente serve para vê-lo de nosso computador ou pelo servidor ao qual subimos a página. Também é opcional e funciona das duas formas (sempre que esteja configurado um servidor de Internet no caso de querermos mostrar externamente), mas se simplesmente é para fazer provas, podemos deixa-lo como indica o desenho.

Agora podemos abrir uma página no Maguma e comprovar que funciona o editor. Para isso, daremos a:

e dará o arranque ao debugger.

Os seguintes botões são os que controlam o debugger. São muito básicos:

1.arranca o debugger.

2.linha a linha.

3.de bloco em bloco.

4.até o final do script do php.

5.para o debugger.

 

[helldanger1]

SiteMaps de Google em PHP


Como criar um arquivo XML para nosso "São Google" usando PHP e não morrer na tentativa.
Por Juan Edgardo Jorquera Uribe





Antes de colocarmos mãos à obra, vamos falar um pouco sobre o Google SiteMaps.

Google Sitemaps permite aos webmasters acrescentar em um XML as páginas que querem que estejam no index de Google. A participação no programa é gratuita, a inclusão não está garantida, mas Google pensa que desta forma chegar a indexar um maior número de páginas do que com o simples rastreio tradicional.

O XML também deixará que os webmasters indiquem a cada quanto tempo se atualiza sua página ou a cada quanto querem que seja re-visitada.

Como funciona o novo programa?

Os webmasters criam um arquivo XML com as URLs que querem que sejam rastreadas, assim como uma pequena anotação por URL indicando a última atualização e o ritmo de atualização da página. Google hospedará o Sitemap nos seus servidores lhe indicando exatamente aonde se encontra.

Só é necessário utilizar uma conta de Google e se registrar de maneira gratuita.

Este script pega o diretório raiz de nosso web site, o lê e faz uma lista de todos aqueles arquivos cuja extensão for .php, porém, vocês podem mudá-lo para que faça a lista do que vocês desejarem, de acordo com as suas necessidades, isto é só um exemplo.

Agora chega de palavras e vamos ver o código:

<?php
if ($gestor = opendir('.')) { //Abrimos o diretorio onde estamos parados, aqui podem dar o diretorio que desejarem

echo "<" . "?xml versao=\"1.0\" encoding=\"UTF-8\"" . "?" . ">"; //etiqueta de inicio de um arquivo XML

/* Dados para o sitemaps de Google, confira esta parte em https://www.google.com/webmasters/sitemaps/docs/es/overview.html */
?>

<urlset xmlns="http://www.google.com/schemas/sitemap/0.84">

<url>
<loc>http://www.seusite.com/</loc>
<lastmod>2006-03-23</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>

<?
// comecamos a gerar a iteracao
while (false !== ($arquivo = readdir($gestor))) {
$p = explode(".",$arquivo);

if(strtolower($p[count($p)-1]) == "php")
{
echo "
<url>
<loc>http://www.seusite.com/$arquivo</loc>
<lastmod>2006-03-23</lastmod>
<changefreq>yearly</changefreq>
</url>";
}
}

//fechamos
closedir($gestor);
echo "
</urlset>";
}
?>

Bastante fácil, não é? Claro que se quisermos dar dados através do banco de dados, coisas como conteúdo.php?id=1 começa a complicar um pouquinho mais a coisa, mas mesmo assim não tem maiores mistérios. De qualquer forma, você desenvolverá, como já disse, de acordo com as suas necessidades.

 

[helldanger1]

Teste de velocidade de conexão à Internet



Como obter um reflexo aproximado da conexão à internet, medida em Kbps.
Por Emmanuel García De Caro





Estudando rapidamente os sistemas que obtém um reflexo aproximado da conexão à Internet, medida em Kbps; resolvi realizar algo similar em Php.

Qual é a utilidade?

Pode-se determinar em quanto tempo aproximado se baixa um arquivo da Internet.
Por exemplo, se estivermos elaborando uma página de downloads e quisermos mostrar ao usuário em quanto tempo APROX, estará esse arquivo em seu PC.

Na verdade é algo extremamente simples, já veremos mais adiante porquê.

Teoria Básica

É importante ressaltar que um caractere QUALQUER sempre terá um tamanho de 1 Byte, ou seja, 8 impulsos eletrônicos (8 Bit) , pelo qual uma cadeia de texto que contenha mil e vinte e quatro caracteres no total, terá uma dimensão de 1024 Bytes o que seria igual a 1 KB.

1 KB é igual a 1024 Bytes
1 MB é igual a 1024 KB
1 GB é igual a 1024 MB
1 TB é igual a 1024 GB

O código fonte:
arquivo : test.php

<?
set_time_limit(0);
$tempo_micro[1]= microtime();
$q_espacos = explode(" ",$tempo_micro[1]);
$tempo_[1]= $q_espacos[1]+$q_espacos[0];

$conteudo=file_get_contents('http://localhost/carregar_bytes.php'); /* mudar por path real (URL) http://seudominio/carregar_bytes.php)*/
$tamanho_KB= strlen($conteudo)/1024;

$tempo_micro[2] = microtime();
$q_espacos= explode(" ",$tempo_micro[2]);
$tempo_[2] =$q_espacos[1] + $q_espacos[0];
$tempo_utilizado = number_format(($tempo_[2] - $tempo_[1]),3, "." ,",");

$velocidade= round($tamanho_KB/$tempo_utilizado,2);
echo 'Sua velocidade de conexão é de: '.$velocidade.' Kbps <br> Foram enviados:'.$tamanho_KB.
' Kb, Tempo utilizado: '.$tempo_utilizado.' Segundos <hr>';

for ($i=10; $i>=1; $i--){
$val_Kb=$i*100;
if($velocidade>=800)$velocidade_=800;
else $velocidade_=$velocidade/2;

if($velocidade>=$val_Kb && !$col){
echo '<div style="background-color:#F0F0F0; width:500px; float:left"><img width="'.($velocidade_).'" height="8" style="background-color: #FF0000" border="0"></div><strong>Sua conexão</strong><br>';
$col=true;
}
echo '<div style="background-color:#F0F0F0; width:500px; float:left"><img width="'.($val_Kb/2).'" height="8" style="background-color: #000099" border="0"></div>'.$val_Kb.' Kbps<br>';
}
?>

arquivo : carregar_bytes.php

<?
print str_repeat("i",1024000);
?>

Explicando:

Criamos o arquivo carregar_bytes.php, que conterá unicamente um processo aleatório de repetições até alcançar o valor de 1024000, 1000 KB, utilizando a função str_repeat(); que funciona como algo parecido a um loop. Repetirá 1024000, a letra i

Chamaremos o arquivo test.php,

Primeiro, utilizaremos a função set_time_limit(), para indicar que não há limite no tempo de execução do script, lembremos que por default vem no php.ini 30 segundos, e se este tempo for alcançado será produzido um erro fatal de tempo de execução.

Obtemos o tempo nesse instante em milésimos de segundos

Logo, faremos uma abertura do arquivo anterior e obtemos o conteúdo, mediante a função file_get_contents(), cabe destacar que o parâmetro que devemos utilizar deve seguir o esquema: protocol:// para que seja tomado como uma URL e se extraia o resultado do processo repetido anteriormente, do contrário se assumirá que o arquivo é local e se executará o código fonte diretamente: ou seja devemos colocar;

file_get_contents('http://odominio/carregar_bytes.php'), para que funcione corretamente.
Porém, não imprimiremos na tela o conteúdo, somente o carregaremos.
Agrupamos na variável $tamanho_KB, a longitude de caracteres de $conteudo, e o dividimos entre 1024; para passá-lo de BYTES A KB.

Quanto à abertura, voltamos a obter o tempo em milésimos de segundos para verificar quanto tempo transcorreu durante a execução do passo anterior e agrupamos esse valor na variável $tempo_utilizado, lhe damos formato com a função number_format();

Obtemos a velocidade em KBPS, dividindo o total de KB carregados, entre o tempo empregado;
Por exemplo, se: 100 Kb, são carregados em 2 segundos, a velocidade nesse instante é de 50 Kbps, mas ode variar dependendo de muitos fatores.

Imprimimos o resultado, e geramos um atraente esquema visual.

 

[helldanger1]

Mostrar Conteúdo de acordo com o país em PHP




O seguinte script para PHP envia o código do país e da linguagem quando o navegador o solicita.
Por Agustin Jareño




Muitas vezes, e sobretudo os webmasters internacionais, encontram com a necessidade de mostrar um conteúdo de acordo com o país e os idiomas.

Neste artigo de PHP veremos um simples código que permitirá conhecer o país do usurário e mostrar uma página diferente para cada caso.

<?php

// muda pagina.php pelo arquivo correto de acordo com o pais

if (isset($pais) && ($pais <> '')) {
$dgo_pais = substr($pais,0,5);
} else {
$dgo_pais = substr($_SERVER["HTTP_ACCEPT_LANGUAGE"],0,5);
}
switch ($dgo_pais) {

case "es-mx":
//se o pais for mexico
include("pagina.php");
break;

case "es-ar":
//se o pais for argentina
include("pagina.php");
break;

case "es-cl":
//se o pais for chile
include("pagina.php");
break;

case "es-ve":
//se o pais for venezuela
include("pagina.php");
break;

case "pt-br":
//se o pais for brasil
include("pagina.php");
break;

case "es-co":

//se o pais for colombia
include("pagina.php");
break;

case "es-ec":

//se o pais for equador
include("pagina.php");
break;

case "es-uy":

//se o pais for uruguay
include("pagina.php");
break;

default:
//se for algum outro pais
include("pagina.php");
break;
}
?>

Lembre de mudar a pagina.php pela página de cada pais, por exemplo, pagina-mexico.php. Pode-se usar este script como página principal, para que seja diferente em função do país.

 

[helldanger1]

Conteúdos em banco de dados com PHP



Como colocar nossos conteúdos em um banco de dados e chamá-lo pela Url.
Por Emmanuel García De Caro




Internet é uma rede de computadores conectados em toda a extensão do Globo Terrestre que oferece diversos serviços a seus usuários como podem ser o correio eletrônico, o chat ou a web. Todos os serviços que oferece a Internet são realizados por milhares de computadores que estão permanentemente ligados e conectados à Internet, esperando que os usuários lhes solicitem os serviços e servindo-os uma vez solicitados. Como dissemos, há servidores para tudo, os que oferecem correio eletrônico, outros tornam possível nossas conversas por chat, outros a transferência de arquivos ou a visita às páginas web e assim até completar a lista de serviços de Internet.

Também existe outro tipo de servidor que são os que se encarregam de prover de acesso à Internet a nossos computadores, são os provedores de acesso, os servidores aos que nos conectamos com nossos módems. Quando fazemos a chamada com o módem aos servidores que provêm o acesso entramos e fazemos parte da Internet e enquanto mantivermos a conexão poderemos acessar a todos os servidores espalhados por todo o mundo e solicitar-lhes seus serviços.

No momento que pedimos um serviço de Internet nos convertemos em clientes do servidor que o oferece. Para solicitar um destes serviços é necessário contar com um programa especial que costuma ser diferente para cada serviço da Internet. Por exemplo, para acessar ao correio eletrônico utilizamos Outlook, para acessar à web utilizamos Firefox ou Internet Explorer ou para entrar no chat utilizamos um programa como Mirc ou Pirch. Todos estes programas que nos dão acesso aos serviços da Internet se denominam clientes, como se pode ver, para ser o cliente de um servidor de Internet necessitamos um programa cliente do serviço ao que tentamos acessar

 

[helldanger1]

Problemas com as datas em timestamp Unix de PHP




Algumas das funções de cálculo de datas de PHP utilizam o timestamp Unix que está restringido a datas compreendidas entre determinados anos. Explicamos a maneira de utilizar uma gama de anos muito maior.
Por Miguel Angel Alvarez - Tradução de JML





Existem em PHP uma série de funções muito úteis para realizar cálculos de datas, como por exemplo, saber se uma data é válida, obter um dado concreto de uma data, como o dia, a hora ou o dia do mês ou a semana.

Teoricamente, qualquer cálculo com datas básico pode-se realizar com as funções que provém a linguagem, que podem ser observadas na documentação de PHP, mais especificamente na URL PHP: Date/Time Functions - Manual

O problema do Timestamp Unix

Muitas funções de PHP se baseiam no Timestamp de Unix que é o número de segundos transcorridos desde as 00:00:00 do dia 1 de janeiro de 1970 GMT. Por exemplo, a utilíssima função date(), que recebe um string com o formato que se deseja para a data e um timestamp de Unix para introduzir a data que se pretende formatar.

O problema que se encontrará com os cálculos de data é que o timestamp começa a contar desde 1970. O que acontece com as datas anteriores? Além disso, o timestamp, como estrutura de dados, tem um tamanho fixo, ou seja, uma capacidade limitada até o ano 2038. Na verdade suporta os seguintes intervalos de anos:

Windows: desde 1970 até 2038
Unix: desde 1901 até 2038

Este artigo pretende tornar conhecido um mecanismo para poder trabalhar com datas fora deste intervalo.

Biblioteca adodb_date_time_library

Existem vários métodos de solver este problema, porém nós vamos falar de um muito simples e fácil de utilizar. Trata-se da biblioteca adodb_date_time, que pode ser baixada e utilizada gratuitamente em nossas aplicações.

Esta biblioteca suporta datas desde o ano 100 D.C. até bilhões de anos no futuro.

Pode-se fazer o download em ADOdb Date Time Library | PHP Everywhere

Para utiliza-la, simplesmente devemos substituir algumas das funções típicas de datas de PHP pelas que implementa a biblioteca.

getdate() substituir por adodb_getdate()
date() substituir por adodb_date()
gmdate() substituir por adodb_gmdate()
mktime() substituir por adodb_mktime()
gmmktime()substituir por adodb_gmmktime()

Nós já provamos a biblioteca com sucesso em alguma criação nossa, portanto a recomendamos quando suponhamos que as datas com as que vamos trabalhar saem do intervalo do timestamp Unix.

Para ampliar esta informação será imprescindível acessar à página de início da biblioteca e nos informarmos de todos os detalhes sobre seu uso.

ADOdb Date Time Library | PHP Everywhere

 

[helldanger1]

Contar o número de linhas e caracteres em arquivo PHP



Script que abre um arquivo de texto e realiza uma conta do número de linhas e de caracteres que tem.
Por Miguel Angel Alvarez - Tradução de JML





Veremos um simples script para realizar uma conta do número de linhas e de caracteres de um arquivo de texto. É um script que pode ser muito útil, pelo menos para praticar um pouco com as funções de manejo de arquivos em PHP.
Como dissemos, trata-se de fazer uma conta do número de linhas de um arquivo e ademais o número de caracteres que tem. Para realizar esta conta devemos ler o arquivo de texto linha a linha, acumular um por cada linha em uma variável, assim como acumular em outra variável o número de caracteres de cada linha.

O código seria o seguinte:

<?
//abro o arquivo para leitura
$arquivo = fopen ("meuarquivo.txt", "r");

//inicio uma variavel para levar a conta das linhas e dos caracteres
$num_linhas = 0;
$caracteres = 0;

//faco um loop para percorrer o arquivo linha a linha ate o final do arquivo
while (!feof ($arquivo)) {
//se extraio uma linha do arquivo e nao eh false
if ($linha = fgets($arquivo)){
//acumulo uma na variavel número de linhas
$num_linhas++;
//acumulo o número de caracteres desta linha
$caracteres += strlen($linha);
}
}
fclose ($arquivo);
echo "
Linhas: " . $num_linhas;
echo "
Caracteres: " . $caracteres;
?>

O script está comentado, mas daremos algumas explicações adicionais.

Primeiro, abrimos o arquivo para leitura. O arquivo se chama "meuarquivo.txt" e se supõe que está no mesmo diretório que este script PHP.

Logo criamos dois variáveis para levar a conta das linhas e dos caracteres.

Em seguida, fazemos um loop para percorrer o arquivo. O loop repetirá enquanto não chegar no final do arquivo. Em cada repetição do loop extraio uma linha, ao mesmo tempo que comprovo que o extraio é válido (Con fgets() extrai uma linha de texto e se houver um erro a função devolve false). Se se extrai corretamente a linha de texto se acumula 1 na variável que conta o número de linhas e se acumula o número de caracteres que tiver na variável que conta os caracteres do arquivo.

Uma vez finalizado o loop, porque chegou ao final do arquivo, serão mostrados os conteúdos das variáveis com o número das linhas e dos caracteres.

 

[helldanger1]

Transformação Doc, Odt ou Rtf para PDF



Uma necessidade que está surgindo é a criação de arquivos doc, odt ou rtf para pdf. Veremos como faze-lo.
Por Patrick Espake



Uma necessidade que está surgindo é a criação de arquivos doc, odt (formato de texto do Open Office - Writer) ou rtf para pdf. O Php não possui nenhuma engine que realiza essa transformação, desta forma é necessário usar alguns métodos para realizar essa tarefa.
O processo descrito aqui funciona para servidores Windows rodando o Apache e o PHP, até gostaria de pedir ajuda para transpor esse código para servidores Linux, mas no final do artigo conversamos mais a respeito do Linux.

------------------------------------------------------------------

INSTALANDO O OPENOFFICE.ORG

Como o PHP não possui engines para transformação de documentos de texto para pdf é necessário instalar o OpenOffice.org, pois através dele que iremos realizar a criação dos arquivos de texto em pdf. O primeiro passo é instalar o OpenOffice.org, para isso basta acessar: OpenOffice.org - The Free and Open Productivity Suite e fazer o download do Open Office, nesse artigo usei o Open Office versão 2.2. Após fazer o download do Open Office realize a sua instalação, se quiser basta instalar somente o Writer e o Calc (em um próximo artigo explicarei como converter arquivos xls ou ods para PDF).

--------------------------------------------------------------

CRIANDO A CLASSE DOC2PDF

Agora vamos criar um arquivo novo em PHP, esse arquivo será a nossa classe de criação de arquivos Doc, Odt ou Rtf para Pdf. Digite o texto o abaixo e salve o arquivo como: doc2pdf.class.php.

<?php
/****************************************************************/
/* CLASSE RESPONSÁVEL PELA CRIAÇÃO DE ARQUIVOS TEMPLATES EM PDF */
/* CRIADO POR: PATRICK ESPAKE ***********************************/
/* E-mail: patrickespake@gmail.com ******************************/
/****************************************************************/
class Doc2Pdf
{
// Atributos.
private $template_file;
private $doc_file;
private $pdf_file_name;
private $pdf_file;
private $dir_files;

// Métodos sets e gets.
function setTemplateFile($template_file) { $this->template_file = $template_file; }
function getTemplateFile() { return $this->template_file; }

function setDocFile($doc_file) { $this->doc_file = $doc_file; }
function getDocFile() { return $this->doc_file; }

function setPdfFileName($pdf_file_name) { $this->pdf_file_name = $pdf_file_name; }
function getPdfFileName() { return $this->pdf_file_name; }

function setPdfFile($pdf_file) { $this->pdf_file = $pdf_file; }
function getPdfFile() { return $this->pdf_file; }

function setDirFiles($dir_files) { $this->dir_files = $dir_files; }
function getDirFiles() { return $this->dir_files; }

// Método construtor.
function Doc2Pdf()
{
set_time_limit(0);
}

// Método de criação do arquivo pdf.
function makePdf()
{
if(file_exists($this->getDirFiles() . $this->getTemplateFile()))
{
$doc_file = "file:///" . $this->getDirFiles() . $this->getTemplateFile();
$pdf_file = "file:///" . $this->getDirFiles() . $this->getPdfFileName();
$this->setDocFile($doc_file);
$this->setPdfFile($pdf_file);
if($this->word2pdf())
return array($this->getPdfFileName(), $this->getDirFiles(), $this->getTemplateFile());
else
die("Não foi possível gerar o arquivo pdf, tente novamente.");
}
else
die("O arquivo de template especificado não existe.");
}

// Método de criação das propriedades do OpenOffice.org
function makePropertyValue($name, $value, $osm)
{
$oStruct = $osm->Bridge_GetStruct("com.sun.star.beans.PropertyValue");
$oStruct->Name = $name;
$oStruct->Value = $value;
return $oStruct;
}

// Método de transformação do arquivo doc, odt ou rtf para arquivo pdf.
function word2pdf()
{
$doc_url = $this->getDocFile();
$output_url = $this->getPdfFile();
$osm = new COM("com.sun.star.ServiceManager") or die("O OpenOffice.org não está instalado.");
$args = array($this->makePropertyValue("Hidden", true, $osm));
$oDesktop = $osm->createInstance("com.sun.star.frame.Desktop");
$oWriterDoc = $oDesktop->loadComponentFromURL($doc_url, "_blank", 0, $args);
$export_args = array($this->makePropertyValue("FilterName", "writer_pdf_Export", $osm));
$oWriterDoc->storeToURL($output_url,$export_args);
$oWriterDoc->close(true);
return true;
}
}
?>

--------------------------------------------------------------

GERANDO O PDF

Agora vamos criar um arquivo PHP chamando criar_pdf.php, esse arquivo deverá ter o seguinte conteúdo:

<?php
// Inclui o arquivo da classe.
include("doc2pdf.class.php");

// Cria o objeto.
$doc2pdf = new Doc2Pdf();

// Nome do arquivo do doc, odt ou rtf.
$doc2pdf->setTemplateFile("meu_arquivo.doc");

// Nome do arquivo do pdf que será gerado.
$doc2pdf->setPdfFileName("meu_pdf.pdf");

// Diretório onde os arquivos estão localizados, é necessário usar o caminho completo.
$doc2pdf->setDirFiles("C:/apache/www/pdf/");

// Cria o arquivo pdf.
$doc2pdf->makePdf();
?>

Para gerar o pdf é só rodar o arquivo criar_pdf.php e o PDF será gerado na pasta definida no $doc2pdf->setDirFiles("C:/apache/www/pdf/"), no nosso caso na pasta C:\apache\www\pdf\.

A linha $doc2pdf->makePdf() retorna um array com as informações do nome do PDF, o diretório e o nome do arquivo de template. Essas informações podem ser usadas depois para redirecionar o browser para mostrar o PDF, após ser gerado.

Como foi comentado no começo desse artigo, esse código roda perfeitamente no ambiente Windows, no ambiente Linux não consegui descobrir uma solução, caso alguém saiba como fazer, favor avisar. Como a maioria dos servidores roda Linux, a solução em Linux vai ser bem mais interessante.

Espero que possa ter ajudado.

 

[helldanger1]

Preencher um arquivo RTF e gerar o PDF



Explicaremos como preencher dinamicamente um arquivo rtf e gerar o seu PDF.
Por Patrick Espake





Uma necessidade bastante interessante é de criar arquivos pdf's a partir de arquivos RTF. Nesse artigo explicarei como preencher dinamicamente um arquivo rtf e gerar o seu PDF.

O PHP não possui nenhuma engine para realizar a transformação direta em PDF, para realizar essa conversão estou usando o OpenOffice.org que possui diversas API's que permitem a integração dos seus recursos com diversas linguagens de programação, para mais informações sobre as API's você pode visitar o link: udk: Uno Development Kit Project.

O primeiro passo é realizar a instalação do OpenOffice.org, acesse: OpenOffice.org - The Free and Open Productivity Suite faça o download da última versão do OpenOffice.org, após fazer o download instale o OpenOffice.org, se você quiser basta apenas instalar o Writer. Os outros recursos não iremos usar agora.

Esse script funciona somente em ambiente Windows. Em breve publicarei a solução para ambiente Linux.

Crie um arquivo chamando rtf2pdf.class.php e insira o conteúdo abaixo:

‹?php
/****************************/
/* CLASSE RESPONSÁVEL PELO PREENCHIMENTO DE ARQUIVOS RTF E GERAÇÃO DE PDF */
/* CRIADO EM: 18/05/2007 | 10h22min *****************/
/* AUTOR: Patrick Espake *************************/
/* SITE: Patrick Espake ************/
/* E-MAIL: patrickespake@gmail.com ***********************/
/***********************/

class Rtf2Pdf
{
// Atributos.
private $template_file;
private $rtf_file_name;
private $rtf_file;
private $pdf_file_name;
private $pdf_file;
private $dir_files;
private $content_file;
private $vars_and_attributes;

// Métodos sets e gets.
function setTemplateFile($template_file) { $this->template_file = $template_file; }
function getTemplateFile() { return $this->template_file; }

function setRtfFileName($rtf_file_name) { $this->rtf_file_name = $rtf_file_name; }
function getRtfFileName() { return $this->rtf_file_name; }

function setRtfFile($rtf_file) { $this->rtf_file = $rtf_file; }
function getRtfFile() { return $this->rtf_file; }

function setPdfFileName($pdf_file_name) { $this->pdf_file_name = $pdf_file_name; }
function getPdfFileName() { return $this->pdf_file_name; }

function setPdfFile($pdf_file) { $this->pdf_file = $pdf_file; }
function getPdfFile() { return $this->pdf_file; }

function setDirFiles($dir_files) { $this->dir_files = $dir_files; }
function getDirFiles() { return $this->dir_files; }

function setContentFile($content_file) { $this->content_file = $content_file; }
function getContentFile() { return $this->content_file; }

function setVarsAndAttributes($var, $attribute) { $this->vars_and_attributes[] = array($var, $attribute); }
function getVarsAndAttributes() { return $this->vars_and_attributes; }

// Método construtor.
function Rtf2Pdf()
{
// set_time_limit(0) reinicia o contador do limite do tempo de execução do script a partir de zero.
set_time_limit(0);
}

// Método de criação do arquivo pdf.
function makePdf()
{
// Verifica se o arquivo de template existe no diretório.
if(file_exists($this->getDirFiles() . $this->getTemplateFile()))
{
// Abre o arquivo de template e obtém o seu conteúdo.
$fp = fopen($this->getDirFiles() . $this->getTemplateFile(), "r");
$this->setContentFile(fread($fp, filesize($this->getDirFiles() . $this->getTemplateFile())));
fclose($fp);

// $this->makeRtf() cria um arquivo temporário rtf com os dados preenchidos, seguindo o modelo do template. Retorna true.
if($this->makeRtf())
{
// Obtém o nome do arquivo rtf temporário.
$this->setRtfFileName($this->getRtfFile());
// Define os caminhos dos arquivos rtf e pdf.
$rtf_file = "file:///" . $this->getDirFiles() . $this->getRtfFile();
$pdf_file = "file:///" . $this->getDirFiles() . $this->getPdfFileName();
$this->setRtfFile($rtf_file);
$this->setPdfFile($pdf_file);

// Cria o arquivo PDF. Retorna true.
if($this->createPdf())
{
// Apaga o arquivo rtf temporário gerado.
$this->deleteRtfTmp();
// Retona o nome do PDF, o nome do arquivo rtf, diretório dos arquivos e nome do arquivo rtf template.
return array($this->getPdfFileName(), $this->getRtfFileName(), $this->getDirFiles(), $this->getTemplateFile());
}
else
die("Não foi possível geral o arquivo pdf, tente novamente.");
}
}
else
die("O arquivo de template especificado não existe.");
}

// Método de criação do arquivo rtf.
function makeRtf()
{

$contentFile = $this->getContentFile();
$varsAndAtrributes = $this->getVarsAndAttributes();

// Substitui os valores no arquivo de template.
for($i = 0; $i< count($varsAndAtrributes); $i++)
{
$contentFile = str_replace($varsAndAtrributes[$i][0], $varsAndAtrributes[$i][1], $contentFile);
}

// Cria o arquivo rtf temporário com as informações preenchidas, seguindo o modelo do template.
$this->setContentFile($contentFile);
$this->setRtfFile(md5(date("Yms")) . ".rtf");
$fp = fopen($this->getDirFiles() . $this->getRtfFile(), "w+");
fwrite($fp, $this->getContentFile());
fclose($fp);
return true;
}

// Método de criação das propriedades do OpenOffice.org
function makePropertyValue($name, $value, $osm)
{
$oStruct = $osm->Bridge_GetStruct("com.sun.star.beans.PropertyValue");
$oStruct->Name = $name;
$oStruct->Value = $value;
return $oStruct;
}

// Método de transformação do arquivo rtf para arquivo pdf.
function createPdf()
{
// Obtém os caminhos do arquivo rtf e o caminho para criação do arquivo pdf.
$rtf_url = $this->getRtfFile();
$output_url = $this->getPdfFile();

// COM (Component Object Model) estabelece a interação em o PHP e o OpenOffice.org.
$osm = new COM("com.sun.star.ServiceManager") or die("O OpenOffice.org não está instalado.");

// Carrega o OpenOffice.org em modo invisível.
$args = array($this->makePropertyValue("Hidden", true, $osm));

// Carrega o objeto Desktop das API's do OpenOffice.org.
$oDesktop = $osm->createInstance("com.sun.star.frame.Desktop");

// Abre o arquivo rtf temporário no OpenOffice.org.
$oWriterRtf = $oDesktop->loadComponentFromURL($rtf_url, "_blank", 0, $args);

// Transforma o arquivo rtf temporário em PDF.
$export_args = array($this->makePropertyValue("FilterName", "writer_pdf_Export", $osm));

// Grava o arquivo PDF.
$oWriterRtf->storeToURL($output_url,$export_args);

// Fecha o arquivo temporário rtf, mas o OpenOffice.org continua carregado na memória.
$oWriterRtf->close(true);
return true;
}

// Método que apaga o arquivo temporário rtf.
function deleteRtfTmp()
{
if(unlink($this->getDirFiles() . $this->getRtfFileName()))
return true;
else
echo "Não foi possível excluir o arquivo rtf temporário.";
}
}
?›

Crie um arquivo chamando preencher_rtf_gerar_pdf.php e insira o conteúdo abaixo:

‹?php
/*************************/
/* CRIADO EM: 18/05/2007 | 10h49min */
/* AUTOR: Patrick Espake ************/
/* SITE: Patrick Espake ******/
/* E-MAIL: patrickespake@gmail.com **/
/***********************/

// Inclui a classe.
include("rtf2pdf.class.php");

// Instância o objeto.
$rtf2pdf = new Rtf2Pdf();

// Define o nome do arquivo de template.
$rtf2pdf->setTemplateFile("template.rtf");

// Define o diretório onde está o template.rtf e onde vai ser gerado o arquivo PDF.
$rtf2pdf->setDirFiles("C:/digite_aqui_o_diretorio_onde_estao_os_arquivos/");

// Onde existir no template.rtf<< data >>,<< nome >>,<< texto >>,<< endereco >>,<< bairro >> e<< cidade >>, será substituido pelo segundo parâmetro valor nas declarações abaixo.
$rtf2pdf->setVarsAndAttributes("<< data >>", "Curitiba, 18 de maio de 2007");
$rtf2pdf->setVarsAndAttributes("<< nome >>", "Patrick Espake");
$rtf2pdf->setVarsAndAttributes("<< texto >>", "O conhecimento é o processo de acumular dados; a sabedoria reside na sua simplificação.");
$rtf2pdf->setVarsAndAttributes("<< endereco >>", "Rua XV de Novembro, 78");
$rtf2pdf->setVarsAndAttributes("<< bairro >>", "Centro");
$rtf2pdf->setVarsAndAttributes("<< cidade >>", "Curitiba");

// Nome do arquivo pdf que vai ser criado.
$rtf2pdf->setPdfFileName("nome_do_meu_arquivo.pdf");

// Preenche o template e cria o PDF com os dados preenchidos. Retona o nome do PDF, o nome do arquivo rtf, diretório dos arquivos e nome do arquivo rtf template.
$rtf2pdf->makePdf();
?›

O arquivo rtf2pdf.class.php é a classe, nesse script estão as funções que preenchem o arquivo rtf e geram o pdf.

O arquivo preencher_rtf_gerar_pdf.php é o script que define o arquivo template, os valores que devem ser substituídos no arquivo template, define o nome do arquivo pdf que irá ser gerado e chama a função que cria o arquivo pdf.

Você deve criar um arquivo de template com o formato rtf, nesse arquivo você deve definir os lugares que virão os dados do php, crie uma espécie de variável no texto, digitando por exemplo:<< nome >>,<< endereco>,<< cidade >> ou qualquer nome que você queira, mas sempre deixando entre os sinais de maior ou menor. Você deve ter percebido que no arquivo preencher_rtf_gerar_pdf.php existe algumas linhas desse tipo: $rtf2pdf->setVarsAndAttributes("<< nome >>", "Patrick Espake"); essa linha diz que onde no arquivo template estiver<< nome >> para substituir por "Patrick Espake", você pode criar quantas variáveis quiser no arquivo de template e depois setar o seu valor no arquivo php.

O script php abre o template rtf e preenche com os dados informados, gerando um arquivo temporário em rtf, a partir desse arquivo temporário é criado o pdf, e por final o arquivo temporário rtf é apagado automaticamente.

Não me preocupei em explicar todo código fonte, pois já deixei tudo bem comentado.

Você pode baixar o arquivo php e um exemplo de template clicando aqui.

Espero que possa ter ajudado.

 

[helldanger1]

Converter arquivos ods ou xls para pdf


Veremos agora como transformar um arquivo ods ou xls em pdf.
Por Patrick Espake



Nos artigos passados ensinei como transformar arquivos doc, odt e rtf em pdf. Muitas pessoas ficaram interessadas em saber como transformar um arquivo ods ou xls em pdf, desta forma decidi escrever esse artigo. Da mesma forma como nos artigos anteriores é necessário realizar a instalação do OpenOffice.org, para esse artigo é necessário que o Calc do OpenOffice.org esteja instalando, estou utilizando a versão 2.2 nesse artigo, para fazer o download do OpenOffice.org acesse esse endereço: OpenOffice.org - The Free and Open Productivity Suite .

Esse script funciona graças as API´s que o OpenOffice.org possui e esse exemplo funciona apenas em servidores Windows.

Vamos fazer a coisa acontecer, crie um arquivo chamado: xls2pdf.class.php , esse será o arquivo da classe, que realizará toda transformação do arquivo em pdf, adicione o seguinte conteúdo ao arquivo:

<?php
/****************************************************************/
/* CLASSE RESPONSÁVEL PELA CRIAÇÃO DE ARQUIVOS XLS E ODS EM PDF */
/* CRIADO EM: 05/06/2007 | 12h16min *****************************/
/* CRIADO POR: Patrick Espake *********************************/
/* E-MAIL: patrickespake@gmail.com ******************************/
/* SITE: Patrick Espake **********************************/
/****************************************************************/

class Xls2Pdf
{
// Atributos.
private $template_file;
private $xls_file_tmp;
private $xls_tmp;
private $pdf_file_name;
private $dir_files;
private $value_col_row;

// Métodos sets e gets.
function setTemplateFile($template_file) { $this->template_file = $template_file; }
function getTemplateFile() { return $this->template_file; }

function setPdfFileName($pdf_file_name) { $this->pdf_file_name = $pdf_file_name; }
function getPdfFileName() { return $this->pdf_file_name; }

function setDirFiles($dir_files) { $this->dir_files = $dir_files; }
function getDirFiles() { return $this->dir_files; }

// Método construtor.
function Xls2Pdf()
{
set_time_limit(0);
}

// Método de criação das propriedades do OpenOffice.org.
function makePropertyValue($name, $value, $osm)
{
$oStruct = $osm->Bridge_GetStruct("com.sun.star.beans.PropertyValue");
$oStruct->Name = $name;
$oStruct->Value = $value;
return $oStruct;
}

// Método de criação do arquivo pdf.
function makePdf()
{
if(file_exists($this->getDirFiles() . $this->getTemplateFile()))
{
// Conecta com o OpenOffice.org
$objServiceManager = new COM("com.sun.star.ServiceManager") or die("O OpenOffice.org não está instalado.");
// Cria a instância para trabalhar com as API´s do OpenOffice.org
$objDesktop = $objServiceManager->createInstance("com.sun.star.frame.Desktop");
// Carrega o OpenOffice.org na memória em modo invisível
$args = array($this->makePropertyValue("Hidden", true, $objServiceManager));
// Carrega o arquivo de template para dentro OpenOffice.org
$objDocument = $objDesktop->loadComponentFromURL("file:///" . $this->getDirFiles() . $this->getTemplateFile(), "_black", 0, $args);
// Seleciona a primeira planilha do documento
$activeSheet = $objDocument->getSheets->getByIndex(0);
// Define o filtro calc_pdf_Export, esse filtro que converte o arquivo template em pdf
$export_args = array($this->makePropertyValue("FilterName", "calc_pdf_Export", $objServiceManager));
// Define o local onde será gravado o arquivo pdf gerado no computador
$objDocument->storeToURL("file:///" . $this->getDirFiles() . $this->getPdfFileName(), $export_args);
// Descarrega o OpenOffice.org e fecha a conexão com as API´s
$objDocument->dispose();
$objDocument->close(true);
// Retorna um vetor com o nome do pdf, o diretório dos arquivos e o nome do template
return array($this->getPdfFileName(), $this->getDirFiles(), $this->getTemplateFile());
}
else
{
// Exibe uma mensagem de erro caso não exista o arquivo
die("O arquivo de template especificado não existe.");
}
}
}
?>

Acabamos de montar o arquivo da classe, agora precisamos criar um arquivo que irá definir o nome do arquivo template, o diretório dos arquivos e o nome do arquivo pdf que você deseja que seja gerado.

Crie um arquivo chamado: criar_pdf.php, e insira o seguinte conteúdo:

<?php
/****************************************************************/
/* CRIADO POR: Patrick Espake *********************************/
/* CRIADO EM: 05/06/2007 | 13h11min *****************************/
/* E-MAIL: patrickespake@gmail.com ******************************/
/* SITE: Patrick Espake **********************************/
/****************************************************************/

// Insere o arquivo da classe
include("xls2pdf.class.php");

// Instância a classe
$xls2pdf = new Xls2Pdf();

// Seta o nome do arquivo de template
$xls2pdf->setTemplateFile("exemplo.ods");

// Seta o diretório onde está o arquivo de template
$xls2pdf->setDirFiles("C:/VertrigoServ/www/test/xls/");

// Seta o nome do arquivo pdf que deve ser gerado
$xls2pdf->setPdfFileName("meu_pdf.pdf");

// Converte o arquivo template em pdf
$result = $xls2pdf->makePdf();

// Exibe a mensagem de sucesso
echo $result[0] . " criado com sucesso em " . $result[1] . ".";
?>

O arquivo criar_pdf.php irá instanciar a classe e passar todos os parâmetros para ela, retornando uma mensagem de sucesso quando o arquivo pdf for gerado. Na primeira execução o script pode demorar um pouco, pois o OpenOffice.org está sendo carregado na memória, nas chamadas seguintes do arquivo criar_pdf.php vai ser mais rápido, pois o OpenOffice.org já irá estar carregado na memória do servidor.

A idéia desse script e você criar um arquivo de template ou qualquer documento e transformar ele em um pdf.

No código existe comentários em cada ponto, que explicam como funciona cada parte do código.

Você pode fazer o download desse script nesse endereço: www.patrickespake.com/pe_scripts/xls2pdf.zip

Espero que esse script facilite a vida de muita gente.

"O conhecimento só pode evoluir quando é compartilhado."

 

[helldanger1]

PHP isam, ferramenta Web para Arquivos Planos



Neste capítulo fazemos uma descrição de como fazer transferências de dados usando o modelo de Arquivos Planos, para aquelas aplicações que necessitem seu processamento.
Por Serafin Vazquez




Os Arquivos Planos parecem esquecidos faz tempo, embora em muitas instalações continuam se usando e têm que se converter para outras aplicações, por exemplo, um Banco de Dados, para poder obter resultados aceitáveis. Esta operação altera a estrutura dos dados ficando fora do nosso alcance a não ser que voltemos a fazer uma conversão depois de ter manipulado.

Para evitar estes contratempos e sem abandonar a estrutura de nossos Arquivos Planos, temos um planejamento que não é novo e é digno de ter em conta, trata-se de conservar a estrutura dos dados e montar isolados deles os recursos para sua exploração, desta forma conservamos a informação em seu formato original, e podemos acessa-la sem depender de nenhum software em concreto, é mais, podemos fazer nossos próprios programas porque continuamos tendo acesso aos nossos dados.

Cabe perguntar se vale a pena investir tempo neste assunto, sobretudo aquelas instalações que entregam seus dados em Arquivos Planos, por exemplo, ao fazer Pedidos a um Provedor que para a entrada a seu sistema com mySQL ou similar exige no transferência de dados uma determinada estrutura de Arquivos Planos, com o qual teremos que transformar nossos dados para enviar Pedidos e outra vez, mas ao contrário de quando recebemos Recibos e Faturas do Provedor em questão. Seria cômodo trabalhar diretamente com os arquivos Planos, por exemplo, com uma Aplicação que nos permitisse ter a Gestão de nossos Clientes e ao mesmo tempo comunicarmos sem nenhum problema com nosso Provedor, tendo um controle sobre nossos dados e software sem tanta diversidade de Ferramentas.

A idéia não é difícil de levar na prática, podemos começar criando uma tabela que faça de MAPA para o manejo de Arquivos com seu Nome, Campos, longitude e características, para o qual necessitamos uns programas para mantê-la e umas funções para manejar os Arquivos segundo estas especificações, funções que usaremos para reduzir consideravelmente nossos programas evitando erros e tempo de depuração.

Agora necessitaremos apresentar estes Arquivos na Web, para o qual ampliamos nosso MAPA incluindo Rede de apresentação indicando seu nome e o do Arquivo que vamos ver com seus Campos e algum parâmetro mais, com base nisto faremos outra série de funções para explorar esta estrutura, e continuando, podemos desenhar a apresentação de Formulários de forma que invocando seu nome e número de registro possamos ver e modificar em tela os dados que quisermos.

Com isto, dispomos de um artefato que nos facilita a programação, porém nos falta algo tão importante como é o manejo em si dos dados, isto é, sua ordenação e seleção. Para isto, contamos com o ISAM estabelecendo os Índices que necessitarmos para nossos Arquivos Planos isolados deles em um Arquivo a parte. O manejo de dados com ISAM é cômodo e rápido, e como o programa de ISAM foi feito à nossa medida, terá além disso, os clássicos comandos de Busca, Inserção, Eliminação, etc, e outros acordes mais a nossas necessidades como a Seleção de listas que nos devolve os registros que cumpram determinadas condições, por exemplo, que tenham uma parte inicial da Chave igual ao argumento de busca como nas linhas de um Pedido que levarão todas o Número de Pedido ao que pertencem.

Está claro que este trabalho PHPisam não aporta um Banco de dados, porém as prestações obtidas permitem trabalhar com uma soltura parecida, ademais o enfoque principal é a apresentação de dados na Web permitindo a seleção de dados e o envio à Web em Formulários de ficha e Rede de linhas de registros usando as funções pertinentes, com o qual podemos fazer programas muito pequenos e de bastante utilidade como meu próprio site desenvolvido com esta ferramenta, onde e-comerce e seu Administrador constam de 20 programas e só 2 excedem de 40 linhas de código.

 

[helldanger1]

Undefined variable ou Undefined index




O que significa a mensagem do PHP "Notice: Undefined variable ou Undefined index" e como evitar esse tipo de erro.
Por Patrick Espake





Nesse artigo irei explicar o que significa a mensagem do PHP "Notice: Undefined variable ou Undefined index" e como evitar esse tipo de erro.

Para entender esse tipo de mensagem, observe o exemplo abaixo:

<?php
$x = $y + 10;
?>

Executando esse script, que valor deve conter a variável $x?
Você deve responder, impossível dizer, não sei qual é o valor da variável $y. Para o PHP a resposta é a mesma, para ele está sendo feito a seguinte operação internamente:

<?php
$x = valor indefinido + 10;
?>

A maneira correta e fazer a seguinte operação:

<?php
$y = 5;
$x = $y + 10;
?>

ou

<?php
$y = 0;
$x = $y + 10;
?>

Toda vez que é feita uma operação com uma variável "valor indefinido" o PHP exibe a mensagem Notice: Undefined variable.

Muitas vezes os nossos problemas de programação são mais complexos, pois estamos trabalhando com variáveis passadas por SESSION, GET, POST e outros métodos, para trabalhar dessa forma e necessário avaliar a condição da variável, por exemplo:

<?php
if(!isset($y))
$y = 0;
?>

Esse script verifica se a variável existe, se a variável não existir é atribuído zero.

Pode ocorrer o mesmo erro quanto estamos trabalhando com arrays e tentamos acessar uma posição que não existe, por exemplo:

<?php
$info_funcionario = array("nome" => "Patrick Espake", "profissao" => "Programador");
echo $info_funcionario["email"];
?>

No script acima estou tentando acessar o índice "email" no array, esse índice não existe e o PHP exibe a mensagem Notice: Undefined index email.

Você pode fazer a seguinte afirmação: "Já programei assim em PHP e nunca apareceu esse erro!".

O que acontece é que essas notificações de erros podem ser configuradas no PHP.INI, muitos programadores em ambiente de desenvolvimento deixam configurado para exibir todos os erros e em ambiente de produção deixam configurado para não exibir os erros de notificação.

Para configurar o PHP.INI para mostrar todos os erros, você deve deixar a cláusula error_reporting da seguinte forma:

error_reporting = E_ALL

Para configurar o PHP.INI para não exibir as mensagens de notificação você deve deixar da seguinte forma:

error_reporting = E_ALL & ~E_NOTICE

Em outras linguagens de programação uma variável não inicializada pode conter qualquer coisa, no PHP é considerado como nulo ou como 0 em uma operação aritmética.

Além disso, é mais rápido escrever:

<?php
echo $_GET['id'];
?>

do que

<?php
if isset($_GET['id'])) echo $_GET['id'];
?>

Em casos extremos você pode usar o @ para ocultar as mensagens de notificação.

<?php
echo @$_GET['id'];
?>

Eu considero esse método muito rigoroso, então é melhor fazer o que você acha melhor. Essas notificações podem ajudar durante o desenvolvimento, para detectar determinados erros.

 

[helldanger1]

Agregar carinhas ao sistema




O código necessário para agregar expressões ou carinhas ao nosso sistema.
Por Jorge De Freitas





Mostraremos como agregar carinhas ou expressões em nosso sistema, (fórum, tagboard, chat, comentários ou seja, qualquer script que quisermos que tenha uma(s) carinha(s) ou expressão(ões).

Começaremos:

Vamos usar a função str_replace() de PHP: esta função substitui tal por tal2 exemplo:str_replace("carinha_louca","<img src=carinha_louca.gif>") ou seja, mudamos qualquer aparecimento do texto "carinha_louca" por uma imagem da carinha louca. Só é um exemplo.

Vejamos como funciona:

Digamos que temos um sistema seja mysql ou puro .txt, é indiferente, o importante é mudar as expressões de texto por imagens, certo. Bem, esta é a função:

<?php
function expressoes($mensagem) {
$mensagem = str_replace("","<img src= feliz.gif>", $mensagem);
$mensagem = str_replace("","<img src=triste.gif>", $mensagem);
$mensagem = str_replace("","<img src=lingua.gif>", $mensagem);
return $mensagem;
}
?>

Sendo assim, só esta função não faz nada:

Para que mostre as carinhas filtramos o resultado da variável $mensagem assim: $mensagem = expressoes($mensagem); Isto diz ao sistema que se dentro da variável encontrar $mensagem encontra ( exemplo: , , , ) que mude pela imagem correspondente.

Até o momento quando o usuário colocar em nosso campo name="mensagem": * ola * mudará o pela carinha correspondente

Porém, vamos mais longe:

Lembramos que "$mensagem" é o nome do campo onde colocaremos o texto que o sistema mudará pelas carinhas e o texto grande ou idéia ou o que for que estivermos escrevendo. Então, temos o exemplo de um formulário:

<form name="meu_formulario" action="processar.php" method="post">
Nome: <input type="text" name="nome" size="26">
Mensagem <textarea name="mensagem" cols="58" rows="14" wrap="virtual"><?echo $mensagem;?></textarea>
<input type="submit" name="Submit" value="Publicar">
</form>

Agora nós queremos que ao clicar em um botão ou em uma carinha saia no campo name="mensagem" teremos que fazer isto:

Antes do formulário colocamos isto:

<script language="JavaScript">
<!--
function carinhas(Which){
document.meu_formulario.mensagem.value = document.meu_formulario.mensagem.value + Which;
}
// -->
</script>

Logo no formulário, atenção com isto: mi_formulario é o nome do formulário e mensagem é o campo onde irão as expressões em texto das carinhas.

Este é o link que vai fazer aparecer as carinhas no textarea:
<a href="javascript:carinhas('')"><img src=triste.gif></a>

Agora será a vez de vocês inventarem as carinhas!

 

[helldanger1]

Paginator, script para paginação com PHP e MySQL



Comentamos as características de um script para realizar paginação de resultados com PHP e MySQL, e que ainda é gratuito.
Por Jorge Pinedo





Paginator é um script de paginação desenvolvido em PHP para dividir resultados de consultas extensas a um banco de dados MySql, em grupos de "n" registros por página. Gera além disso, uma "barra de navegação" que contém os links às diferentes páginas (<<anterior 1 2 3 4 seguinte>>).

Nota: Como exemplo de paginação podemos ver a página de google, onde se diz que há 13,235 resultados, porém aparecem divididos em várias páginas de 20 resultados cada uma.

A característica principal deste script é sua fácil utilização, já que a forma de paginar é muito conhecida e utilizada. Por isso, não é necessário entende-lo, nem editá-lo, basta simplesmente incluí-lo depois de definir ao menos uma variável. Não obstante, todas as linhas estão comentadas devidamente, para que seja simples continuar a seqüência e saber o que faz o script em cada linha. E o melhor de tudo é que o programa ainda é gratuito.

Utilização do script

A utilização é extremamente simples. Devemos Conectar com o Banco de dados, definir uma sentença sql válida para MySql e armazenar na variável $_pagi_sql. Esta sentença SQL não deve conter a cláusula "LIMIT", pois será agregada automaticamente pelo script.

A definição desta variável é obrigatória. Pode-se criar outras variáveis para personalizar o sistema de paginação em detalhes como o número de resultados por página ou o número de links a outras páginas de resultados que aparecerão.

Logo, inclui-se o script de paginação, e se geram outras variáveis que podemos utilizar para fazer a página de resultados. $_pagi_result é o id de resultado da consulta, que podemos utilizar com alguma função tipo mysql_fetch_array(). $_pagi_navegacao que contém a barra de navegação com links às distintas páginas e $_pagi_info que armazena a informação de registros visualizados e o número de páginas, algo assim como "desde o 16 até o 30 de um total de 123".

Vamos ver um código simples que utiliza Paginator para gerenciar a paginação de resultados.

//Conexão ao banco de dados
$con = mysql_connect("localhost","seu_username","seu_password") or die (mysql_error());
mysql_select_db("tu_base",$con) or die (mysql_error());

//Sentença sql (sem limit)
$_pagi_sql = "SELECT * FROM clientes WHERE sexo='m' ORDER BY idade";

//quantidade de resultados por página (opcional, por padrão 20)
$_pagi_quantos = 10;

//Incluímos o script de paginação. Este já executa a consulta automaticamente
include("paginator.inc.php");

//Lemos e escrevemos os registros da página atual
while($row = mysql_fetch_array($_pagi_result)){
echo $row['nome']."<br />";
}

//Incluimos a barra de navegação
echo"<p>".$_pagi_navegação."</p>";

Como podemos ver, não há maior trabalho adicional, com respeito ao que se realizara em um código sem paginar. Cabe esclarecer que o nome das variáveis que utiliza o script (internas e externas) começam todas pelo prefixo $_pagi_ para evitar conflitos por coincidências com os nomes de outras variáveis que estejam sendo utilizadas.

Para acessar a uma descrição detalhada de Paginator e baixar o script de maneira gratuita, pode-se ver sua página de início: Paginator - Paginacion con PHP y MySql

Referência: Se quiser aprender a paginar resultados por sua própria conta, em CriarWeb.com temos publicado um artigo interessante que pode ser de grande ajuda: Paginação de resultados com PHP e MySQL.

 

[helldanger1]

Executar scripts PHP automaticamente através do cron com CURL




Como podemos executar uma página PHP como uma tarefa programada utilizando CURL.
Por Alfredo Anaya




Frequentemente, apresentamos a necessidade de ter que programar alguma tarefa diária, semanal etc...como um envio massivo de e-mail, ou umas consultas pesadas ao nosso banco de dados, e fazê-lo além disso, nas horas de menor atividade de nosso servidor.

Para muitos de nós é fácil programar um script com php que realize estas tarefas, porém, para a maioria dos servidores tem somente o módulo de php instalado, o qual não nos permite executar estes scripts através da linha de comandos diretamente.

A solução a este problema consiste em utilizar CURL. Este pacote vem incorporado na maioria das distribuições Linux, e em caso contrário, pode ser baixado através deste endereço cURL and libcurl.

CURL é uma ferramenta para transferência de arquivos com sintaxe URL, que envia a saída padrão à tela. Podemos fazer a seguinte prova:

# curl Google

Também podemos re-enviar a saída e salvá-la em um arquivo

# curl Google > google.htm

CURL suporta diferentes protocolos FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE, LDAP e alguns mais que poderão consultar em sua web. Ademais, instala-se uma biblioteca com um conjunto de funções que podem ser usadas desde php, mas isto é outra história.

Continuando com nosso caso, podemos executar agora um script php desde a linha de comandos, simplesmente escrevendo isto:

# curl http://localhost/meuscript.php

Suponhamos que vamos executar um script que envia os e-mails de nosso boletim de correio chamado boletim.php, porém este se encontra hospedado em uma pasta protegida de nosso servidor web. Neste caso executamos o script passando-lhe o usuário e senha para acessar ao diretório protegido.

#curl -u usernameassword http://localhost/protegido/boletim.php

Para programar no cron de nosso linux esta tarefa e que seja executada automaticamente de forma periódica, devemos conhecer a rota completa onde está instalado o curl que habitualmente costuma ser em /usr/bin.

Agora, editaremos nosso arquivo de tarefas de cron (por exemplo, com o comando crontab -e), e adicionamos esta linha:

30 4 * * * /usr/bin/curl -u usernameassword http://localhost/protegido/boletim.php

Isto fará com que todos os dias às 4:30 da madrugada se execute o script boletim.php de maneira automática. Se desejar conhecer mais informações sobre a programação de tarefas consulte a ajuda (man crontab).

Artigo cedido por ADR Formación

 

[helldanger1]

Uso do FTP com PHP



Explicamos as funções para realizar transferência de arquivo, utilizando o protocolo FTP, através de páginas PHP. Exemplo de código para aprender a transferir arquivos ao servidor.
Por William Wong Garay




Constantemente nos encontramos baixando arquivos de Internet: Um programinha que alguém nos recomenda, a foto da modelo de moda ou os clásicos MP3's . Sem nos dar conta de um modo ou outro fazemos uso do protocolo FTP (File Transfer Prococol) para baixar arquivos desde um Servidor. Baixamos mais do que transferimos... em outras palavras "Tomamos mais do que damos". Este artigo pretende explicar como transferir ou permitir que seus usuários transfiram (colaborem) - arquivos ao Servidor usando as funções FTP incluídas no PHP. Lembrem do velho ditado que diz: "Mais vale dar que receber".
O QUE É O FTP?

Siglas de File Transfer Protocol ou Protocolo de Transferência de Arquivos. Como seu próprio nome o indica, é um protocolo (que pertence a TCP/IP) que se encarrega da transferência de arquivos entre computadores conectados em rede. Ao se basear na arquitetura Cliente / Servidor, o FTP faz uso de dois componentes básicos:

•Um cliente FTP. O qual se encarrega de se conectar a um servidor FTP para baixar ou transferir arquivos.
•Um servidor FTP. Encarrega-se processar as petições dos clientes FTP, permitido-lhes baixar ou transferir arquivos através dele.
Para nos conectarmos a um servidor FTP, e assim, poder realizar consultas nele, necessitaremos dos seguintes dados:

•Nome do Servidor. É a IP ou Nome do Servidor FTP ao qual temos que nos conectar, tal como: 65.134.10.5 ou ftp.billysite.net
•Porto. Número do porto do servidor. Por padrão é 21.
•Conta de Usuário. É o nome da conta de usuário que temos atribuído. Há que certificar-se que conta com as permissões necessárias para transferir ou baixar arquivos. Se não tiver uma conta de usuário se pode acessar como usuário anônimo utilizando o nome de usuário anonymous.
•Chave de acesso. É nossa senha de conta de usuário. Se acessarmos como usuário anônimo colocaremos como chave nosso correio-e a maneira de cortesia.
Uma vez conectados ao servidor FTP poderemos fazer uso de seus comandos para realizar as tarefas que melhor acharmos conveniente. Este artigo não pretende esboçar em grande medida o tema de FTP, por não ser este o objetivo fundamental do mesmo. Para mais informações sobre sobre este aspecto lhe recomendo revisar o artigo de Michael Calore: "El ABC de la transferencia de archivos por Internet", disponível no web site de WebMonkey.

FUNÇÕES FTP EM PHP.

PHP faz uso de funções FTP para acessar a um servidor web, a maneira de cliente. A seguir mostraremos as funções básicas a usar no script, assim como uma breve descrição das mesmas. Se quiser maior detalhe destas e outras funções FTP lhe aconselho consultar a documentação oficial do PHP, disponível em: PHP: Documentation.

Função Sintaxe Descrição
ftp_connect int ftp_connect ( string host [, int port])
host: Nome ou IP de Servidor FTP.
port: Porto, padrão 21. Estabelece uma conexião FTP ao host especificado.
ftp_login int ftp_login( int ftp_stream, string username, string password)
ftp_stream: Manejador FTP obtido com ftp_connect.
username: Nome de usuário.
password: senha de usuário. Começa a sessão em uma conexão FTP.

ftp_pasv int ftp_pasv ( int ftp_stream, int pasv)
ftp_stream: Manejador FTP obtido com ftp_connect.
pasv: Se for TRUE ativa o modo passivo, se for FALSE ou desativa. Ativa ou desativa o modo passivo. Em modo passivo, as conexões de daos são iniciadas pelo cliente, ao invés de serem iniciadas pelo servidor.
ftp_pwd int ftp_pwd ( int ftp_stream)
ftp_stream: Manejador FTP obtido com ftp_connect. Devolve o nome do diretório atual.
ftp_put int ftp_put ( int ftp_stream, string remote_file, string local_file, int mode)
ftp_stream: Manejador FTP obtido com ftp_connect.
remote_file: Nome com o qual se salvará o arquivo no Servidor FTP.
local_file: Arquivo local que se encontra na máquina cliente.
mode: Modo de transferência, pode ser FTP_ASCII ou FTP_BINARY. Transfere uma arquivo ao Servidor FTP.
ftp_nlist int ftp_nlist ( int ftp_stream, string directory)
ftp_stream: Manejador FTP obtido com ftp_connect.
directory: Rota do diretório a listar. Devolve uma lista de arquivos do diretório dado.

ftp_size int ftp_size ( int ftp_stream, string remote_file)
ftp_stream: Manejador FTP obtido com ftp_connect.
remote_file: Nome do arquivo no Servidor FTP. Devolve o tamanho do arquivo especificado. Nem todos os servidores suportam esta característica.
ftp_mdtm int ftp_mdtm ( int ftp_stream, string remote_file)
ftp_stream: Manejador FTP obtido com ftp_connect.
remote_file: Nome do arquivo no Servidor FTP. Devolve a data da última modificação do arquivo especificado. Nem todos os servidores suportam esta característica
ftp_quit int ftp_quit ( int ftp_stream)
ftp_stream: Manejador FTP obtido com ftp_connect. Fecha uma conexão FTP


Nota: Deve-se certificar que se encontrem habilitadas as funções ftp na configuração da versão de PHP que possui e de ter as permissões necessários em sua conta FTP para transferir e baixar arquivos.


CODIGO FONTE.

/inc/ftpfunc.php.
Script que conterá as constantes e funções a usar em index.php. Neste script deverá modificar os valores das constantes para ajusta-lo a suas necesidades. A função ConectarFTP lhe permitirá se conectar ao Servidor FTP; a função TransferirArquivo tem a tarefa de transferir um arquivo ao Servidor; e finalmente, a função ObterRota lhe outorgará a rota do diretório atual no qual está trabalhando o Servidor.

<?
# FUNÇÕES FTP
# CONSTANTES
# Mude estes dados pelos de seu Servidor FTP
define("SERVER","localhost"); //IP o Nome do Servidor
define("PORT",21); //Porto
define("USER","willy"); //Nome de Usuário
define("PASSWORD","12345"); //Senha de acesso
define("PASV",true); //Ativa modo passivo

# FUNÇÕES

function ConectarFTP(){
//Permite se conectar ao Servidor FTP
$id_ftp=ftp_connect(SERVER,PORT); //Obtem um manejador do Servidor FTP
ftp_login($id_ftp,USER,PASSWORD); //Loguea-se ao Servidor FTP
ftp_pasv($id_ftp,MODO); //Estabelece o modo de conexão
return $id_ftp; //Devolve o manejador à função
}

function TransferiArquivo($arquivo_local,$arquivo_remoto){
//Transfere arquivo da máquina Cliente ao Servidor (Comando PUT)
$id_ftp=ConectarFTP(); //Obtem um manejador e se conecta ao Servidor FTP
ftp_put($id_ftp,$arquivo_remoto,$arquivo_local,FTP_BINARY);
//Transfere um arquivo ao Servidor FTP em modo Binário
ftp_quit($id_ftp); //Fecha a conexão FTP
}

function ObterRota(){
//Obtén rota do diretório do Servidor FTP (Comando PWD)
$id_ftp=ConectarFTP(); //Obtém um manejador e se conecta ao Servidor FTP
$Diretorio=ftp_pwd($id_ftp); //Devolve rota atual p.e. "/home/willy"
ftp_quit($id_ftp); //Fecha a conexão FTP
return $Diretorio; //Devolve a rota à função
}
?>


index.php.
Script que contém um formulário (form_ftp) que nos permite buscar um arquivo e transferi-lo ao Servidor FTP, ademais nos mostra uma lista dos diretórios e arquivos do mesmo.

<?php echo "<?xml versao="1.0" encoding="iso-8859-1"?".">"; ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>::..Funções FTP..::</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<p align="center"><font size="5" face="Verdana, Tahoma, Arial"><strong><em>
Funcoes FTP
</em></strong></font></p>
<p><font face="Verdana, Tahoma, Arial">

<?
include('inc/ftpfunc.php'); //Inclui o arquivo de funções
if(!empty($_POST["arquivo"])){ //Comprova se a variável "arquivo" foi definida
TransferirArquivo($_POST["arquivo"],basename($_POST["arquivo"]));
//basename obtén o nome de arquivo sem a rota
unset($_POST["arquivo"]); //Destrói a variável "arquivo"
}
?>
<strong><font color="#000000" size="3">Subir Arquivo</font></strong></font></p>
<hr />

<!--Formulario para escolher o arquivo a transferir -->
<form action="" method="post" name="form_ftp" id="form_ftp">
<p><font size="2" face="Verdana, Tahoma, Arial"> Escolher arquivo:
<input name="arquivo" type="file" id="arquivo" />
<input name="Submit" type="submit" value="Transferir Arquivo" />
</font><font size="2" face="Verdana, Tahoma, Arial"> </font> </p>
</form>

<hr />
<p><font face="Verdana, Tahoma, Arial"><strong><font color="#000000" size="3">
Lista de Arquivos
</font></strong></font></p>
<table width="69%" border="1" cellspacing="0" cellpadding="0">
<tr>
<td width="48%"><div align="center"><font size="2" face="Verdana, Tahoma, Arial"><strong>Nombre</strong></font></div></td>
<td width="22%"><div align="center"><font size="2" face="Verdana, Tahoma, Arial"><strong>Tamaño</strong></font></div></td>
<td width="30%"><div align="center"><font size="2" face="Verdana, Tahoma, Arial"><strong>Fec.
Modificação</strong></font></div></td>
</tr>
<?
$id_ftp=ConectarFTP(); //Obtiene un manejador y se conecta al Servidor FTP
$ruta=ObterRota(); //Obtem a rota atual no Servidor FTP
echo "<b>O diretorio atual é: </b> ".$rota;
$lista=ftp_nlist($id_ftp,$rota); //Devolve um array com os nomes de arquivos
$lista=array_reverse($lista); //Inverte ordem do array (ordena array)
while ($item=array_pop($lista)) //Lê todos os arquivos e diretorios do diretorio
{
$tamanho=number_format(((ftp_size($id_ftp,$item))/1024),2)." Kb";
//Obtem tamanho de arquivo e o passa a KB
if($tamanho=="-0.00 Kb") // Se for -0.00 Kb se refere a um diretorio
{
$item="<i>".$item."</i>";
$tamanho=" ";
$data=" ";
}else{
$data=date("d/m/y h:i:s", ftp_mdtm($id_ftp,$item));
//Filemtime obtem a data de modificação do arquivo; e date lhe dá o formato de saída
}
?>

<tr>
<td><font size="2" face="Verdana, Tahoma, Arial"><? echo $item ?></font></td>
<td align="right"><font size="2" face="Verdana, Tahoma, Arial"><? echo $tamanho ?></font></td>
<td align="right"><font size="2" face="Verdana, Tahoma, Arial"><? echo $data ?></font></td>
</tr>
<? } ?>
</table>
</body>
</html>

 

[helldanger1]

Instalação de One or Zero PHP Helpdesk




Detalhe passo a passo da instalação e configuração do sistema PHP para Helpdesk e planificação de tarefas de One or Zero.
Por Angel Deblás




One or Zero Helpdesk and Task Management System é um programa de código aberto muito potente e leve. Está desenvolvido em PHP e utiliza o banco de dados MySQL e Sqlite. É rápido, personalizável e se pode executar em qualquer plataforma. Trata-se de um produto gratuito, tanto para uso pessoal como comercial.

Este artigo cobre a versão 1.4 do programa. Assumo que o serviço técnico tem acesso telnet (ou ssh) ao servidor e que tem conhecimentos básicos de Linux.

Mesmo assim, tentarei dar explicações alternativas no caso da instalação se realizar sem conexão ssh/telnet.

Onde obtê-lo e o que contém

Pode-se baixar a última versão de Open Source, Free and Supported Help Desk, Knowledgebase, Reporting and Time and Task Management Software by OneOrZero - AIMS Action and Information Management System

Apesar da página oficial ter links para baixar um kit de idioma, este não é necessário, já que vem incluído no documento .zip

Os conteúdos desta versão se organizam em pastas:
•admin: Páginas de administração. Com ele podemos instalar muito facilmente o programa
•common: Contém arquivos comuns, entre eles "config.php"
•images: Obviamente, as imagens do site
•kbase: Arquivos de configuração
•supporter: Páginas do técnico que dará suporte aos usuários
•lang: Arquivos de linguagem
•docs: Arquivos txt em inglês com o agreement, instruções de instalação...etc
Requerimentos mínimos
•Sistema operacional Windows ou Linux.
•Apache
•PHP 4.0 (ou versão superior)
•MySQL
•SSL (para transações seguras)
•Software de fóruns (opcional) Recomenda-se XMB Forum (XMB eXtreme Message Board - PHP Forum Software)
Nota: Eu provei em um php 4.1.2 e funciona muito bem.

Instalação do software

Primeiros passos:
Entre no servidor remoto
Acesse ao diretório do usuário que solicitou a instalação
Crie uma pasta "helpdesk" (mkdir helpdesk)
Entre na pasta helpdesk (cd helpdesk)
Transfira o arquivo "ozhv14f.zip" à pasta usando FTP.
Descompacte o arquivo (unzip ozhv14f.zip) -> No caso em que a distro não tiver o pacote unzip instalado, você sempre poderá descompactá-lo em um pc com Windows e transferir a pasta.

Eliminando o que não queremos:
Apaga o arquivo comprimido (rm -rf ozhv14f.zip)

Permissões:
Para que o usuário possa, em um futuro administrar o helpdesk, não se esqueça de mudar de proprietário a pasta phpnuke (chown usuario:grupousuario ./phpnuke)

Configuração: Edita o arquivo "common/config.php"

$db_host Nome do host onde está o banco de dados --> Deixar em "localhost"
$db_user Usuario (do hosting, que coincide com o do bd)
$db_pwd Senha (do hosting, que coincide com a do bd)
$db_name Nome do bd

Os demais campos não é necessário tocá-los.

Não coloquem a versão de php em um campo que vem um pouco mais abaixo, a não ser que usem uma versão maior ou igual à 4.2.0

Adicionar as tabelas do banco de dados e configurar o administrador

Isto também podemos deixar ao cliente, porém ocasionará problemas com os menos experimentados.

Entramos via web a http://dominiodocliente.com/helpdesk/install.php

Só precisa preencher os campos que pede (login, passwd, etc), e como se pode ver, a instalação é muito simples. Ele mesmo gera sozinho as tabelas do bd.

Depois vá ao painel de controle e mude o "default languaje" por "Portuguese". Mesmo que você não veja a mudança nesse momento, saia e entre novamente e verá que já sairá em português.

Notas finais

Já terminamos a instalação. As páginas onde ficou a aplicação são http://www.dominio.com/helpdesk para o Helpdesk.

http://www.dominio.com/helpdesk/admin/control.php para a administração.

Mais informação e downloads em Open Source, Free and Supported Help Desk, Knowledgebase, Reporting and Time and Task Management Software by OneOrZero - AIMS Action and Information Management System.

 

[helldanger1]

Portal PHP Nuke



Todo o necessário para a criação de um portal PHP Nuke, desde a instalação de Apache e PHP, até a do próprio sistema web-portal.
Por Raúl Avilés





Para a criação de um portal PHP Nuke é necessário saber antes, com o que vamos nos encontrar. O sistema de gerenciamento de portais PHP Nuke se executa sob um servidor Apache, utiliza a linguagem de programação PHP e necessita de um banco de dados MySQL. Estas três aplicações se instalariam separadamente e depois teríamos que configurá-las para que funcionassem entre si. Porém, aqui vamos utilizar um programa que nos instala de uma só vez estas três aplicações, podemos fazer seu download através deste link.

Instalação de Apache, PHP e MySQL

Agora siga estas instruções para instalar este programa, que coordena Apache, PHP e MySQL:


1.Clique em "next" até que lhe peça para introduzir o "server name" e "administrator's email adress".
2.Em "server name" ponha "localhost". Em "administrator's email adress" ponha seu e-mail. E o porto não o modifique (80 por padrão).
3.Clique em "next". Agora lhe pedirá que introduza o "user name" e o "password". Ponha o que você quiser, isto serve para acessar ao nosso banco de dados.
4.Clique em "next". Agora acabará a instalação.
5.Clique em "Close". Aparecerá uma janela de ms-2, pode fechá-la.
Para comprovar seu correto funcionamento abra seu navegador ( Internet Explorer, Mozilla...) e introduza este endereço (seu endereço local) "http://localhost" . Se aparecer uma página onde coloca "The AppServ Open Project..." é porque está tudo correto.

Agora o programa criou em seu disco rígido uma pasta chamada AppServ, a qual por sua vez contém: "Apache", "PHP", "MySQL" e "www". A pasta "www" é onde pode colocar qualquer arquivo php para que seja executado.

Normalmente todo o anterior se realiza, para preparar a web antes de transferi-la ao servidor, porém se você vai trabalhar diretamente no servidor web, pode continuar lendo no seguinte ponto. (Certifique-se de que seu servidor corre sob Apache, PHP e tem banco de dados MySQL: um exemplo deste tipo de servidor é Lycos Tripod - Tripod).

Instalação de um Portal PHP Nuke

Primeiro há que baixar os arquivos que o compõem: pode baixá-lo deste link diretamente. Uma vez baixado, extraia (está em zip) os arquivos à anteriormente mencionada pasta "www" dentro de "AppServ" em seu disco rígido. Agora explicarei a configuração dos arquivos:


1.Abra seu navegador web e introduza este endereço "http://localhost/phpMyAdmin".
2.Corrija os erros que aparecem em vermelho, para isso, copie as mensagens de erro no " Google" e rapidamente dará com a solução. Aqui explico os mais usuais. O erro que sempre sai à princípio é o da diretiva $cfg. Para solucioná-lo abra com o bloco de notas o arquivo seguinte: seu_disco_rigido/AppServ/www/phpMyAdmin/congif.inc.php
3.Busque (Ctrl+B) a seguinte linha: $cfg['PmaAbsoluteUri'] = ''; e introduza isto entre as aspas http://localhost/phpMyAdmin de tal maneira que fique assim $cfg['PmaAbsoluteUri'] = 'http://localhost/phpMyAdmin'; . Já está solucionado o erro. Agora falta outro, o que diz que o root não tem senha.
4.Volte à página "http://localhost/phpMyAdmin" (observe que se atualizar a página já não sai o primeiro erro), clique em privilégios e logo clique em editar (à direita das filas root e localhost) . Agora no ponto "Mudo de senha" clique na opção "senha" e introduza uma senha, escreva novamente e clique em "continue".
5.Sairá um erro, a tela aparece meio em branco, devemos configurar mais outro arquivo. Abra de novo (com o bloco de notas) o arquivo "congif.inc.php" e busque (Ctrl+B) isto: $cfg['Servers'][$i]['host'], lhe levará à seção onde especificar os dados pelos quais dava o erro. Entre as aspas da fila password introduza a password que introduziu antes nos privilégios do phpMyAdmin. Salve e feche o arquivo.
6.Vá à página do phpMyAdmin (pode comprovar que tudo funciona corretamente, sem erros), escreva nuke (por exemplo) no campo "criar um novo banco de dados" e clique em "criar".
7.Abra com o bloco de notas o arquivo "seu_disco_rigido/AppServ/www/sql/nuke.sql" e selecione tudo, copie-o (Ctrl+C).
8.Abra o phpMyAdmin, à esquerda, selecione o banco de dados criado antes (nuke), clique na guia superior "SQL", cole (Ctrl+V) o texto antes copiado e clique "continue".
9.Abra com o bloco de notas o arquivo "seu_disco_rigido/AppServ/www/html/config.php"
10.Preencha os seguintes dados: no "dbpass", à direita, entre as aspas, ponha a password que você pôs inicialmente no phpMyAdmin e em "dbname" ponha 'nuke' (se estiver executando o php-nuke online no "host" ponha seu servidor). Salve e feche o arquivo.
11.Em seu navegador ponha "http://localhost/html/admin.php" e sei aparecer um portal PHP Nuke, você terá feito tudo corretamente.
12.Configure seu superusuario, ponha o usuário, password, e-mail... que quiser. Aqui o único que pode que você não saiba é a página de início, deve por "http://localhost".
Com isso você já tem seu próprio portal PHP Nuke, pode configurá-lo como você quiser. Desfrute-o!

 

[helldanger1]

Gerando feed RSS de notícias em PHP



Como criar um sistema RSS em PHP para publicar a informação das novidades ou notícias de nosso web site ou blog.
Por Alejandro Suazo





Muitas vezes nos perguntamos como gerar feed RSS para nossos blogs ou sistema de notícias. Assim como muitos, eu pensava que era tarefa mais complicada, porém com observação e um pouco de engenho tudo se pode. A seguir explicarei uma das formas de gerar RSS para nossos sistemas. Necessitaremos que nossas notícias sejam recolhidas de um banco de dados.

O XML às vezes é complexo de entender, para mim ainda é, porém como disse: Com engenho tudo é possível. O primeiro é saber: Que etiquetas ocupam as diferentes versões de RSS?, pois fácil, vamos a algum site que gere tais RSS, por exemplo, um Blog e olhamos o código fonte do tal RSS. Já temos aproximadamente 90% do "trabalho" feito, só falta o código de nosso documento em PHP. Há que ter claro que o XML permite que criemos nossas próprias etiquetas, as que veremos a seguir, podemos tomá-las como padrão para os feeds.

Para o exemplo se utilizará RSS 2.0:

<?
header('Content-Type: text/xml'); //Indicamos ao navegador que é um documento em XML
//Versão e jogo de caracteres de nosso documento
echo <?xml versao="1.0" encoding="iso-88859-1"?>;
//Aqui a conexão ou arquivo de conexão ao banco de dados
//Fazemos a consulta e a ordenamos por post para mostrar sempre o último
$resultado=mysql_query("select * from noticias order by id_post Desc",$link);
$row=mysql_fetch_array($resultado);
//"Cortaremos" o artigo em 300 caracteres para nossa descrição
$descricao=substr($row[artigo],0,300)."...";
// E geramos nosso documento
echo '<rss versao="2.0">
<channel>
<title>Nome de nosso blog ou web</title>
<link>http://www.minhaurl.com/</link>
<language>es-CL</language>
<description>Descrição de nosso blog ou web</description>
<generator>Autor del RSS</generator>
<item>
<title>'.$row[titulo].'</title>
<link>http://www.minhaurl.com/noticias.php?id='.$row[id_post].'</link>
<comments>http://www.minhaurl.com/comentarios.php?id='.$row[id_post].'
</comments>
<pubDate>'.$row[data].'</pubDate>
<category>'.$row[categoria].'</category>
<guid>http://www.miurl.com/comentarios.php?id='.$row[id_post].'</guid>
<description><![CDATA['.$descripcion.']]></description>
<content:encoded><![CDATA['.$row[artigo].']]></content:encoded>
</item></channel></rss>';
?>

Podemos ver que a estrutura do documento é simples e até repetitiva. Basicamente, podemos dividi-lo em dois: <channel> e <item> em onde <channel> contem a <item>. O primeiro bloco antes de <item> se enche com os dados de nosso blog ou web, logo sob a etiqueta mencionada vão os dados do post ou notícia a mostrar

Uma prática recomendada é utilizar a etiqueta <content:encoded>, para proporcionar a informação que contem nosso artigo completo ao invés de <description> por que?, porque os sistemas de recopilação de feeds ou leitura destes, lêem a etiqueta <description> para dar ao leitor um resumo do que trata o post. Mencionamos, porque há sistemas de blog que usam <description> para gerar a informação do artigo completo e não dão a opção de ver se queremos ou não seguir lendo o que nos oferecem, a parte de ocupar espaço. Para estas duas etiquetas usamos a seção XML<![CDATA]]>(character data), basicamente para que o XML não interprete certos caracteres como próprios de sua linguagem e trate de executá-los.

Por último, nos cabe dizer que devem fechar bem todas as etiquetas do documento ou notícia a qual se fará feed, ou senão dará um charmoso erro.

Quanto ao script,, pode-se dar mais opções (embora isto seja o mais básico), como por exemplo: Fazer um while logo de <item> e mostrar todas as notícias, ou a quantidade que quiser, usando limit na chamada ao banco.