<?php
$sql = 'INSERT INTO `artigos` (`id`, `titulo`, `corpo`) 
VALUES (NULL, \'php 6\', \'PHP 6 promote grandes novidades \'),

1. GtkMenuBar
2. GtkMenu
3. GtkMenuItem

a programação de aplicativos Web usando o PHP terá mais sucesso do que teve o Java

1. É uma camada de abstracção rápida e simples de utilizar
2. suporte à portabilidade
3. fácil de aprender a nível de programação
4. tecnologia madura e robusta , com uma enorme comunidade de utilizadores
5. é uma tecnologia livre de usar e compilar


Posta a apresentação, vamos passar à prática.
Mas antes , entenda-se porque é importante usar uma camada de abstracção. Imaginemos que escrevemos a nossa aplicação e que a gestão de dados por entre milhares de linhas de código que utilizámos foi o ODBC, em Windows. Agora, passado uns tempos, alguém que usa um sistema UNIX , deseja utilizar a aplicação, mas o sistema operativo não lhe dá suporte ao ODBC e deseja utilizar MySQL, seja qual for a razão. Pois é, o problema está identificado! Agora é necessário no meio de milhares de linhas de código alterar tudo , de forma a usar-se apenas MySQL. Eis o principal factor porque se deve utilizar uma camada de abstracção em aplicações consideráveis.
Vamos então começar por fazer o download em ADOdb onde poderá ler mais informação sobre este assunto.
No download tenha atenção à versão do PHP que utiliza, pois são disponibilizadas versões para PHP5 ou ambas (PHP4 e PHP5).
A distribuição é bastante pequena (cerca de 600Kb). Após fazer o download, descompacte (na pasta adodb5 por exemplo) do seu servidor local, de forma a podermos fazer os testes que vou apresentar ao longo deste artigo.
Agora sempre que quisermos utilizar a camada de abstracção utilizaremos o seguinte código php.

<?php
//inclusão da camada de abstracção

require_once("adodb5/adodb.inc.php");
//credenciais ao servidor
$host   = "localhost";
$user   = "root";
$pass   = "";
$table  = "membros";
$db     = "revistaphp_net";
$conn   = "mysql";  // driver de dados selecionado

$DBmySQL =& NewADOConnection($conn);
$DBmySQL->Connect($host,$user,$pass,$db);
$DBmySQL->debug=true;//activa do debug 

// vammos criar uma tabela temporaria
$sqlT = "CREATE TEMPORARY TABLE `$table` (
                `id` int(10) unsigned NOT NULL auto_increment,
                `nome` varchar(100) NOT NULL default '',
                `email` varchar(100) NOT NULL default '',
                 PRIMARY KEY  (`id`)) ENGINE=MyISAM;";
    
$DBmySQL->Execute($sqlT);             
                 


  //agora é fácil entender a seguinte claúsla de inserção dos dados
$sql = "INSERT INTO {$table} (nome, email) VALUES('Revista PHP', 'revistaphp@gmail.com')";
        $DBmySQL->Execute($sql);
    

//executa a claúsula SQL
$rs1     = $DBmySQL->Execute("SELECT * FROM {$table}");
  
  if(!$rs1){  //obtém eventuais erros
    $DBmySQL->ErrorMsg();
    exit;
   }
   
       //obtendo os resultados
      $Thtml  = "<table bgcolor=\"#999999\" border=\"1\">\n";
      while (!$rs1->EOF) {
      
      $Thtml .="<tr>\n"; 
      $Thtml .="<td> Nome: </td><td>" .$rs1->fields[1]."</td>\n";
      $Thtml .= "</tr>\n<tr>\n";
      $Thtml .="<td> Email: </td><td>".$rs1->fields[2]."</td>\n";
      $Thtml .= "</tr>\n";
      //obtém a próxima linha
      $rs1-> MoveNext(); 
      }
      
      $Thtml .="</table>\n";
       echo  $Thtml; 

?>

]]> http://www.revista-php.net/artigos.php?pagina=33 aquí , e logo no momento dos testes fiquei convencido, embora já tivesse estudado um processo similar ,no site da IBM , com queries em dados XML.

No LINQ , a sintaxe utilizada nas consultas (queries) , é muito parecida ao SQL. E ao que parece a afirmação de Maarten é mesmo verdade “se começarmos a usar esta forma de aceder aos dados, não vamos querer mudar mais” - o que na minha opinião é perigoso e já vão saber porquê. Baseado nos exemplos que este autor apresenta decidi criar alguns scripts por minha autoria e fazer os meus testes. O conceito é muito simples.
Primeiro vamos criar listas onde a informação é armazenada. No primeiro exemplo vamos usar uma lista simples.

<?php 

// algumas cidades portuguesas 
$cidades = array("Guarda","Viseu", 
                 "Covilhã","Castelo Branco", 
                 "Meda","Braga"); 

/************************************************* 
 Imagine-se que desejamos obter a cidades cujo  
 tamaho de caracteres e inferior ou igual  a 4 
 Rapidamente identificamos que é Meda 
 Em PHP stardard teriamos 
 *************************************************/ 
foreach($cidades as $cidade){ 
        if(strlen($cidade)<=4){ 
           echo $cidade."<br />"; 
           } 
        } 
         
/**************************************************** 
 Imaginemos agora que desejamos verificar se existe um  
 elemento repetido no array (a olho vemos que não) , 
 mas em listas carregadas de forma dinâmica no sistema  
 esse conceito de visualização não se aplica), então 
 vamos adicinar um elemento já existente 
 *****************************************************/ 

 array_push($cidades,"Guarda"); 

foreach ($cidades as $cidade){ 
  if($cidade=="Guarda"){ 
   $search[] = $cidade; 
   } 
} 

echo "Existem " .sizeof($search). 
" cidades com o mesmo nome no array"; 


/***************************************** 
 ... se quisesse obter as cidades de forma 
  distinta (sem repetição) 
         
 ******************************************/ 
 echo "<pre>"; 
 print_r(array_unique($cidades)); 
 echo "<pre />"; 

/******************************************* 
 Toda esta forma de lidar com arrays podia  
 dar lugar a uma nova função 
*******************************************/ 

 function OperaArray($arr,$str=NULL,$op){  

   switch($op){ 
   case 'unico': 
   return array_unique($arr); 
   break; 
   case 'rep': 
    
    foreach ($arr as $s){ 
           if($s==$str){ 
            $narr[] = $s; 
            } 
      } 
    return $narr;  
    break; 
    case 'eval': 
     foreach($arr as $s){ 
           if(strlen($s) <= $str){ 
           echo $s."<br />"; 
          } 
        } 
    break; 
    default: 
    return false; 
   } 
 } 
 // exemplo de uso 
print_r( OperaArray($cidades,'','unico')); 


?> 


Posto isto vamos utilizar alguns exemplos no LINQ no PHP , usando um array unidimensional

<?php 
/******************************************* 
 Onidesk Labs ::LINQ 4 PHP tests 
 ******************************************/ 

require("PHPLinq.php"); 
$cidades = array(); 
$cidades[] = "Guarda"; 
$cidades[] = "Meda"; 
$cidades[] = "Castelo Branco"; 
$cidades[] = "Viseu"; 



$result = from('$cidade')->in($cidades) 
            ->where('$cidade => substr($cidade,0,1)=="M"') 
            ->select('$cidade');  

             
        #print_r($result); 
             
             
/********************************************** 
O mesmo objectivo com  foreach no PHP  
 *********************************************/ 
 foreach($cidades as $cidade){ 
    if(substr($cidade,-6,1)=="M"){ 
      echo $cidade."<br />"; 
      } 
    } 
             
             
     

?> 


Resultado Array ( [0] => Meda )



O PHPLinq, permite facilmente aceder a objectos instanciados e armazenados num array.

<?php
 require("PHPLinq.php");

 $Cidades = array( 
 new Cidade('Guarda','44 264', '38.694085', '-9.162598', 'Portugal'),
 new Cidade('Meda', '6 239', '40.950863', '-7.261963', 'Portugal'),
 new Cidade ('Castelo Branco','54 574','39.829632','-7.531128','Portugal'),
 new Cidade ('Viseu','98 167','40.653555','-7.921143','Portugal'));
    
                   
    $cidade = "";               
 $result = from('$cidade')->in($Cidades)
    ->where('$cidade => substr($cidade->cidade,0,1) == "G"')
    ->orderBy('$cidade => $cidade->cidade')
    ->thenByDescending('$cidade => $cidade->cidade')
      ->select('$cidade');

    
 //imprimindo os resultados
            echo "<pre>";
            print_r($result);
            echo "</pre>";
                                     

?>

Resultado


Array
(
    [0] => Cidade Object
        (
            [cidade] => Guarda
            [habitantes] => 44 264
            [latitude] => 38.694085
            [longitude] => -9.162598
            [pais] => Portugal
        )

)





Novas funcionalidades

Segundo o autor, na próxima versão do PHPlinq (ainda não lançada), esta contará com a funcionalidade de JOIN.
Segue-se um exemplo , enviado gentilmente pelo autor , propositadamente para este artigo.No exemplo que segue demonstra-se com combinar empregados ($employee) com departamentos ($departments)

<?php
$result = from('$cidade')->in($cidades)
            ->where('$cidade => substr($cidade,-6,1)=="M"')
            ->select('$cidade'); 
            
            print_r($result);
            
            $result = from('$employee')->in($employees)
   ->join('$department')->in($departments)
   ->on('$employee, $department => $employee->DepartmentId == $department->Id')
   ->join('$manager')
   ->in($employees)
   ->on('$employee, $manager => $employee->ManagerId > 0 
   && $employee->ManagerId == $manager->Id')
   ->select('$employee = null, $department = null, $manager = null => new {
       "Name" => $employee->Name,
       "Email" => $employee->Email,
       "Department" => $department,
       "Manager" => $manager
       }');
?>
                    

Observações finais
É certo que o LINQ é extremamente útil e facilita muito o tratamento de dados. Em arrays simples, não fará muito sentido, pois para isso temos as funções nativas do PHP. Em arrays multidimensionais pode constituir uma tarefa interessante, assim como no acesso a Base de Dados como MySQL ou outras Sem querer parecer céptico, penso que este não deve ser trocado pelas cláusulas disponíveis a partir do SQL que conhecemos, embora a facilidade que transparece na utilização do LINQ no PHP, o torne a apetecível. Não só porque é uma tecnologia mais explorada e fiável, para a qual já existe orientada toda uma plataforma de desenvolvimento, mas também porque está acessível a partir de quase todas as linguagens. Além disso como o autor do LINQ para PHP reconhece, o LINQ pode torna-se viciante, e menosprezar a forma correcta (na minha maneira de ver), forma de acessar aos dados. Veja-se que obter os dados dum arrays desta forma exigirá muito mais do sistema, que sim simples foreach nativo. ]]> http://www.revista-php.net/artigos.php?pagina=34 No PHP é possível manipular esses standards, de forma a trocar informações entre as aplicações para que estas se entendam (protocolo), num formato que tem se ser reconhecido por ambas.
Isto verifica-se sempre mesmo que as aplicações tenham sido desenvolvidas em sistemas díspares, como por exemplo Unix e Windows.
De forma muito simplista um Web Service e pode ser visto como página Web (que integra o protocolo HTTP), acessível para qualquer lugar da Internet.
Recebe a informação no formato XML, “interpreta” o pedido solicitado e responde utilizando o mesmo standard de resposta (XML)
Os Web Services , não se intimidam pelo uso de firewalls ou servidores proxy, pois , funcionam mesmo na presença destes.
Como são independentes da plataforma de desenvolvimento, passaram a constituir a forma generalizada das aplicações de comunicarem, cuja interacção não depende de intervenção humana.
Estas características fazem com a integração das aplicações seja muito menos dispendiosa. De forma sintética um Web Service caracteriza-se:
1. fornecer serviços mediante a Internet utilizando o protocolo HTTP
2. o formato usado na descrição é o WSDL
- acedem ao servidor utilizando mensagens SOAP
3. a veiculação da informação usa XML
- o servidor é o repositório onde constam os dados
4. o cliente é visto como a funcionalidade que interroga o servidor
5. A segmentação cliente – servidor complementa o serviço, no utilizador apenas interage com o cliente, visualizando os dados, já formatados.

Pese o facto de o PHP já contar com Web Services de forma nativa a partir da versão PHP5, este artigo não tenciona apresentar essa vertente.
Para desenvolvimento de Web Services PHP,temos à disposição uma distribuição muito conhecida, o NuSOAP , cuja primeira versão foi lançada em Maio de 2004.
À data que escrevia este artigo o NuSOAP conta com a 0.7.1, datada de Julho 2007.

O NuSOAP conta apenas num conjunto de classes escritas em PHP e não tem qualquer dependência das extensões do PHP. Para fazer o download desta funcionalidade aceda aquí
Além da distribuição que contém o NuSoap poderá fazer o download da documentação, que contém a hierarquia das classes, métodos e atributos e respectiva escolaridade. Após fazer o download do NuSOAP , descomprima para o seu directório, e por uma questão de organização organize o seu directório na seguinte estrutura
www\NuSOAP
       /lib
       /samples
A pasta lib , contém o módulo NuSOAP entre outras funcionalidade, e a pasta sample contém alguns exemplos que deve estudar de forma a aprender como utilizar e criar Web Services à posteriori.
Agora que temos os requisitos necessários vamos criar exemplo dum Web Service básico. Isso implica que tenhamos de criar duas aplicações, uma a funcionar como cliente e a outra como servidor.

<?php
/************************************************
 Autor : José Franco
 Data  : 24 Abril 2008
 Distro: NuSOAP Case Study : servidor.php 
 ************************************************/

// carrega o módulo NuSOAP a partir da sua localização
require_once($_SERVER['DOCUMENT_ROOT']."./NuSoap/lib/nusoap.php");
//instância um objecto tipo servidor
$Servidor = new soap_server;
// regista a função de define o serviço
$Servidor->register('MembroValido');


/* função que generaliza o serviço
   Esta função tem como parâmetro uma string 
   que é o nome do membro que deseja aceder 
   ao serviço. Se o nome constar no vector de membros
   (simula a Base de Dados), o serviço é efectuado
   com sucesso. Doutra forma ocorre um erro especifico
   enviado ao cleinte

*/
function MembroValido($nome){
$membros = array("Guto123","Pedro777","Berto003");
$rs = array_search($nome,$membros);
    
if($nome==""){
    return new soap_fault('Erro no cliente','','Indique o nome do membro');
    }
if(is_integer($rs) AND $membros[$rs]==$nome){
    return $membros[$rs];
}if(!is_integer($rs)){
return new soap_fault('Erro no cliente','', 'O membro informado não existe');
}    
   else{
   return new soap_fault('Erro fatal no cliente','', 'Erro desconhecido');
   }
}

// processa a informação e invoca a função 
$Servidor->service($HTTP_RAW_POST_DATA);
?>


Agora vamos criar o ficheiro que funcionará como cliente, programado as funcionalidades necessárias. Neste exemplo de modo a facilitar a abordagem , criei a interface HTML , juntamente integrada no ficheiro que contém o Web Service do lado do cliente.

<?php
/************************************************
 Autor : José Franco
 Data  : 24 Abril 2008
 Distro: NuSOAP Case Study : cliente.php 
 ************************************************/

// permite visdualizar erros ocorridos
error_reporting(E_ALL);

// carrega o módulo NuSOAP a partir da sua localização
require_once($_SERVER['DOCUMENT_ROOT']."./NuSoap/lib/nusoap.php");

// ao requisitar o serviço
if(isset($_POST["enviar"])){

// obtém o nome enviado pelo formulário
$nome = $_REQUEST["nome"];

// define a localização do servidor
$Service = "http://localhost/servidor.php";


// parametros a enviar ao servidor
$parametros = array('nome' => $nome);
// instancia ao objecto do tipo Cliente
$Cliente =& new soapclient($Service);
// activa uma ligação persitente ao servidor
$Cliente->useHTTPPersistentConnection();
// faz a requisção do serviço , identificado
// pela função de chamada e respectivos parâmetros
$rs =  $Cliente->call('MembroValido',$parametros);
     
  // ao ocrrer erro
  if($erro = $Cliente->getError()){
  #print_r($Cliente->request); 
  // obtém a resposta enviada
   echo "<erro> <strong><font color=\"red\">$erro</font></strong><br>";
   echo "<xmp>".$Cliente->response."</xmp>";
   }else{
   // ok .. resultado do serviço
   echo "Benvindo ao sistema <strong>".$rs."</strong>";
   }
// impede que o formulário seja visualizado
exit();
}

?>


<?PHP
 # Template de interação com o utilizador
?>
<html>
<head>
<title>Revista PHP :: NuSoap case study</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>

<body>
<?php 
# PHP_SELF aponta para a página actual após clicar no botão
?>
<form action="<?php $_SERVER['PHP_SELF']?>" method="post">
<label for="nome">Indique o nome de utilizador</label><br>
<input type="text" name="nome" size="40"><br>
<input type="submit" name="enviar" value="Login">
</form>
</body>
</html>


Resultado em caso de erro



Sucesso no Web Service

Benvindo ao sistema Guto123]]> http://www.revista-php.net/artigos.php?pagina=35 Mas antes de passarmos a essa parte vamos a uma breve apresentação.
A PRADO é uma aplicação baseada em componentes e eventos (vulgarmente conhecida por Framework), para criar aplicativos Web a funcionar na plataforma PHP5, de forma a facilitar o processo de criação , aumentando a performance das aplicações recorrendo a técnicas de estrutura de dados avançadas.
O objectivo desta Framework é a utilizar a programação orientada a objectos, assentando no RAD (Rapid Application Development), e no princípio MVC (modelagem, visão e controlo), numa arquitectura de camadas.
Propõe-se a melhorar o desempenho das aplicações Web, nomeadamente em processos complexos, como no acesso a Base de Dados, operações sob ficheiros, e limitações impostas pela largura de banda. Para aumentar este desempenho, a PRADO utiliza uma técnica comum neste tipo de Frameworks, que é o processo de caching , que guarda os templates e os reutiliza, caso estes sejam invocados em fases posteriores. Este processo é permitido pela activação do TTemplateManager, que permite além De outras funcionalidades, permitir carregar a página uma única vez.
Uma das pretensões do criador da PRADO (Qiang Xue), é aproximar a criação de aplicações Web, aproximando o seu desenvolvimento do ASP.NET.
Apesar da Framework ter sido criado com tecnologias e ferramentas pagas, como é o caso do Borland Delphi e ASP.NET, esta é distribuída de forma gratuita (sob licença BSD), em código aberto, numa distribuição com cerca de 17 Mb, que pode baixar aquí
À data em que escrevia este artigo a PRADO está na versão v3.1.2 e conta entre muitas outras as seguintes funcionalidades
Permite usar praticamente todo os conjunto de
Base de Dados
Web Services
Transformações com XML
Ajax
Data Controls (TPanel, TDataGrid, TDataList …)
Componentes para gestão de template (Form, Button, Form, Validation ...)
Gestão automatizada de erros no código

Um dos requisitos necessários é possuir a extensão SimpleXML, que vem de forma nativa juntamente com o PHP5.
Após fazer o download, descomprima o conteúdo na raiz do seu servidor (www no caso do EasyPHP ou htdocs no caso do Apache)
No meu caso optei por criar uma nova pasta “PRADO”, e descomprimi para lá toda a estrutura de directórios:


Este processo de instalação pode ser feito a partir da linha de comandos, por exemplo:
caminho/para/prado-cli.php –c olamundo no directório onde deseja criar o projecto olamundo.
O módulo PRADO (o chamado PRADO core), necessário a ser carregado “prado.php”, encontra-se na pasta Framework. Na pasta demos, existem alguns exemplos que convém editar e estudar.

Surgem na PRADO dois novos conceitos para quem nunca trabalhou com Frameworks, as extensões *.spec e *.tpl O ficheiro com a extensão *.spec define as especificações da aplicação e o ficheiro com a extensão *.tpl (ou ainda *.page) contém o template (parte visual) da aplicação. Nas aplicações criadas com PRADO, é obrigatório criar um ficheiro que conterá as especificações da aplicação, que conterá mencionado o caminho para o ficheiro da aplicação.

Isto pode parecer novo para quem programa apenas com PHP, mas quem desenvolve em ASP.NET, ser-lhe-á muito familiar.
Junto com a distribuição existe uma pasta chamada demos e dentro dessa uma pasta helloworld, comece por analisar estrutura dessa aplicação. Nos projectos que acompanham a distribuição reparará que é comum encontrar algumas pastas com o mesmo nome:
assets – directório onde são guardadas os ficheiros privados para publicação. Este directório deve estar em modo de escrita para processos no servidor.
protected – caminho por defeito onde é guardada a informação da aplicação. Este directório deve ser configurado de modo a ficar inacessível aos utilizadores finais
runtime – pasta onde são guardados os dados de estado da aplicação, como estado, informação em cache… Este directório deve também possuir as permissões de escrita activas pelo servidor.
pages – caminho para as páginas PRADO

Os ficheiros que definem o template da página, pode constituir mais uma novidades para programadores PHP, e aos quais os de ASP.NET já devem estar familiarizados. Esre tipo de ficheiro utiliza um processo de rendering de alguns componentes, pelo que é muito mais rápido criar componentes HTML. Veja por exemplo como criar um formulário standard

<form id="formulario" method="post" enctype="multipart/form-data"></form>



Rendering :: primeiro contacto

Usando rendering em Prado , bastaria
<com:TForm ID="formulario">
</com:TForm>
Em que TForm é o Data Control que generaliza o formulário
Vamos então proceder à criação dum projecto exemplo.
Crie uma pasta "projecto" e dentro dela crie as pastas "assets" e "protected" , dentro desta crie as pastas "pages" e "runtime" Agora observe o seguinte script , que será a página inicial, contudo ainda não está totalmente completo, pois ainda não definimos nada para a aplicação. Guarde o código seguinte e salve como index.php na pasta projecto.

<?php
#caminho para a pasta do projecto
$CaminhoServidor = dirname(__FILE__);

#localização da framework Prado
$caminhoFramework = $CaminhoServidor.'/../../framework/prado.php';

# directório que guarda as páginas privadas publicadas
$PagPublicadas = $CaminhoServidor.'/assets';


# caminho onde são guardados os dados da aplicação e 
# os ficheiros com código privado
$DadosAplicacao = $CaminhoServidor.'/protected/runtime';


#fazendo validações à existência do ficheiro e permissões de escrita

if(!is_file($caminhoFramework)){
die("A framework prado não foi encontrada em ".$caminhoFramework);
}

if(!is_dir($PagPublicadas)){
die("Garanta as permissões de escrita para a pasta ".$PagPublicadas);
}

if(!is_writable($DadosAplicacao)){
die("Garanta as permissões de escrita para a pasta ".$DadosAplicacao);
}
#carrega  a framework
require_once($caminhoFramework);

#instancia a aplicação
$Aplicacao=new TApplication;
# mostra o conteúdo da aplicação
$Aplicacao->run();

?>

Para que possamos correr uma aplicação simples basta-nos definir o template da mesma e correr o script anterior. É isso que vamos fazer a seguir .

O passo seguinte é criar a interface da aplicação, utilizando os seguintes Data Controls
TForm, TLabel, TTextBox, TButton
<com:TForm>
<fieldset>
<legend>Login no sistema</legend>
<div class="campo-utilizador">
<com:TLabel ForControl="login" Text="Utilizador:" />
<com:TTextBox ID="login" />
</div>
<div class="campo-password">
<com:TLabel ForControl="password" Text="Password:" />
<com:TTextBox ID="password" TextMode="Password" />
</div>
<div class="botao-login">
<com:TButton Text="Login" OnClick="fazerLogin" />
</div>
</fieldset>
</com:TForm>
Depois de criarmos a interface, guarda-se na pasta "pages" com e nomeia-se de home.page Se correr o script index.php, reparará que essa interface já pode ser mostrada.


Fazer a ligação do botão

O que me deixou maravilhado nesta framework foi precisamente este facto tão simples e prático de fazer a gestão de eventos. A interface que define o formulário faz parte da classe TPage assim para ligar o botão basta estender essa classe à classe HOME ,criando uma nova classe para fazer o tratamento dos dados que provêm do formulário.
Repare que o botão será ligado se na propriedade OnClick passar o nome da função onde os dados são tratados na nova classe.
Esta classe é guardada na pasta "pages", com o mesmo nome do ficheiro que define a interface neste caso Home.php

<?PHP
# permite aceder às propriedades dos Data Controls
Prado::using('System.Web.UI.ActiveControls.*');

#classe que permite tratar os dados do formulário
class Home extends TPage
{
     #callback do botão login
    public function fazerLogin($sender, $param)
    {       #obtem os dados nos campos do formulário
            $login = $this->login->Text;
            $pass  = $this->password->Text;
        
           # mensagem output
            echo htmlentities("Olá ".$login." , a sua password é ".$pass);
            exit;
    
    }
}
?>

Noutra altura tratarei de ensinar como fazer a gestão dos dados numa Base de Dados e confrontar essas informações com os dados do formulário. ]]> http://www.revista-php.net/artigos.php?pagina=37 Ajax vem de Asynchronous Javascript + XML
O principal componente, o XMLHttpRequest foi desenvolvido pela Microsoft para a versão do Internet Explorer 5 em 1997 , em forma de objecto ActiveX.
Não é uma nova tecnologia, mas corresponde à integração de algumas tecnologias existentes:


1.   Javascript que compreende o XMLHttpRequest + Listener
2.   DHTML e/ou DOM para actualização da interface (User Interface) com o utilizador
3.   XML para formatar os dados enviados


A API XMLHttpRequest, compreende um conjunto de métodos responsáveis por vários métodos na construção de pedidos inerentes ao AJAX


open ()

– estabelece um novo pedido ao servidor


Parâmetros

open (tipo-pedido,url,async, utilizador , password)
O tipo de pedido pode ser usado utilizando os métodos GET, POST …
Por defeito async está activo (true)


send()

envia o pedido ao servidor

Parâmetros

send ( conteúdo-a-enviar) conteúdo-a-enviar – corresponde à informação indicada através do método POST , ou nulo para GET (estes parâmetros são codificados na url) . Aqui pode entrar o Json posteriormente para fazer a descodificação dos dados.
A API comporta um conjunto de propriedades , que se utilizam para detectar o estado da informação a cada momento , visto que este tipo de funcionalidade é extremamente dinâmica.


readyState

– informa o estado actual do pedido . Devolve valores entre 0 (antes do método open())e 4 (completo , a resposta do servidor existe)


onreadestatechange

– especiifca o método de chamada (callback)
O método de callback é chamado sempre que estado pronto do http (correspondente ao pedido), varie.


status

: códigos de estado http (200 significa que correu tudo bem)


responseText

– o servidor responde em formado de texto plano (Plain Text)


responseXML

– o servidor responde em formado XML (objecto)

Em seguida segue-se o esqueleto fundamental para possa utilizar o Ajax nas suas aplicações


var pedido = null;
try {
// habilita o javascript para pedidos HTTP assincronos
 //também cobre versão Firefox, Opera , Safari
  pedido = new XMLHttpRequest();
} catch (trymicrosoft) {
  try {
   // versões novas do IE
    pedido = new ActiveXObject("Msxml2.XMLHTTP");
  } catch (othermicrosoft) {
    try {
    // versões antigas do IE
      pedido = new ActiveXObject("Microsoft.XMLHTTP");
      }catch (falha) {
      pedido = null;
     
    }
  }
}

if (pedido == null)
  alert("Não foi possível criar o objecto !");




No código javascript que escrevermos , eis como temos acesso às propriedades:
//verifica o estado de prontidão
if (pedido.readyState == 4) {
// faz alguma coisa
//verifica o estado da requisição
if (pedido.status == 200) {
// faz alguma coisa ....]]> http://www.revista-php.net/artigos.php?pagina=38 É um protocolo independente do tipo de hardware ou do sistema operativo, e é utilizado para transferência de ficheiros, apenas sujado pelas restrições e propriedades de cada sistema ou aplicação.
Tal como em outras operações que já vimos, como por exemplo os Web Services, a transferência de arquivos também envolve um cliente (o que solicita o pedido de transferência de dados), a par dum servidor (o que recebe o pedido para a transferência). Neste artigo iremos verificar de forma prática a forma de seleccionar e processar o envio de ficheiros via FTP.

Vulgarmente o FTP utiliza o porto 21 como canal de comunicação. Se num dado servidor existirem restrições, é necessários que saibamos as credenciais de acesso, de forma a processar o serviço. O acesso a servidores via FTP pode ser feito de duas formas distintas, ou através de interface (que é o objectivo deste artigo), ou por meio de linha de comandos, que constitui um processo mais complexo de realizar esta tarefa.
Segue-se o código fonte que permite processar o envio de ficheiros via FTP, programado através de funções disponíveis no PHP , para esta tarefa.

<?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : FTP no PHP
    ***************************************/

    // definição do modo passivo
    define("PASV",true);
    // define o tempo de 30 seg para processameto da aplicação
    set_time_limit(0);
    
    $Utilizador = "utilizador";
    $Password   = "password";
    $Servidor   = "ftp.o-seu-site.com";
    $Caminho    = "/httpdocs";
    $Porto      = 21;

if(isset($_POST["upload"])):

    // ligação ao endereço FTP
    $conn = @ftp_connect($Servidor,$Porto) or die("Erro de ligação ao servidor FTP ".$Servidor);
    ftp_pasv($conn,true);
    // processo de login
    ftp_login($conn, $Utilizador, $Password) or die ("Erro a processar  o login no endereço FTP");
    // caminho relativo para o ficheiro a ser envaido
    $ficheiro  = dirname($Caminho.$_FILES['ftp_file']['name']);
    
    // localização do upload  local
    $tmpFich = $_FILES['ftp_file']['tmp_name'];

// processa  o upload via frp
if(@ftp_put($conn,$ficheiro,$tmpFich,FTP_BINARY){
    echo "O ficheiro ".$_FILES['ftp_file']['name']. " foi enviado sem erros";
    }else{
      echo "Erro na tentativa de  envio do ficheiro via FTP";
      }
      // fecha  a ligação ao servidor
    ftp_quit($conn);

?>
<?php
else:
?>
        <form action="<?php $_SERVER['PHP_SELF'];?>" method="post" enctype="multipart/form-data">
        <input type="file" name="ftp_file" size="40">
        <br>
        <hr>
        <input type="submit" name="upload" value="Enviar">
        
        </form>

<?php
endif;
?> ]]> http://www.revista-php.net/artigos.php?pagina=39 date() cuja sintaxe de utilização é :
String date(formato, data_ts)
em que data_ts é um parâmetro opcional e se informado utiliza a data no formato timestamp
Para a conversão da data em português podemos utilizar o seguinte script
 <?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : Datas em português no PHP
    ***************************************/

 // obter o ano
 $ano = date("Y");
 // dia do mês em inglês
 $mes = date("M");
 // numero do dia
 $dia = date("d");
 // dia da semana em inglês               
$ndia = date("D");
 // array  para  a converção dos dias da semana
 $ptDia =array("Mon"  => "Segunda-feira", 
               "Tue"  => "Terça-feira",
               "Wed"  => "Quarta-feira",
               "Thu"  => "Quinta-feira",
               "Fri"  => "Sexta-feira",
               "Sat"  => "Sábado",
               "Sun"  => "Domingo");
 // array  para  a converção dos meses               
 $ptMes = array("Jan"   => "Janeiro",
                 "Feb"   => "Fevereiro",
                "Mar"   => "Março",
                "Apr"   => "Abril",
                "May"   => "Maio",
                "Jun"   => "Junho",
                "Jul"   => "Julho",
                "Aug"   => "Agosto",
                "Sep"   => "Setembro",
                "Oct"   => "Outubro",
                "Nov"   => "Novembro",
                "Dec"   => "Dezembro");               


                
 echo "Hoje é  ".$ptDia[$ndia]." , dia ".$dia." de ".$ptMes[$mes]." de ".$ano;

?> ]]> http://www.revista-php.net/artigos.php?pagina=40 Para isso recorri às funções nativas do PHP, disk_free_space e disk_total_space, com base na diferença entre os dois é então possível obter o espaço usado.

 <?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : Operações com espaço em disco
    ***************************************/
  
  // valor unitario (bytes) de 1 kb
  $kb = 1024;
   // valor unitario (bytes)de 1 Mb
  $mb = pow($kb,2);
  // valor unitario (bytes)de 1 Gb
  $gb = pow($kb,3);
  $Disco = "D:";
  
 $EspOnDisco = disk_free_space($Disco);

 echo "<h4>". ($EspOnDisco < $kb 
?  "Espaço Livre " . $EspOnDisco." Bytes" : ($EspOnDisco < $mb 
?  "Espaço Livre " .round($EspOnDisco/$kb,2)." KBytes" : ($EspOnDisco < $gb
?  "Espaço Livre " .round($EspOnDisco/$mb,2)." MBytes" 
: ("Espaço Livre " .round($EspOnDisco/$gb,2)." GBytes"))))."</h4>";
                         
$TotalOnDisco = disk_total_space($Disco);

 echo "<h4>".($TotalOnDisco < $kb 
?  "Espaço Total em disco " . $TotalOnDisco." Bytes" : ($TotalOnDisco < $mb 
?  "Espaço Total em disco " .round($TotalOnDisco/$kb,2)." KBytes" : ($TotalOnDisco < $gb
?  "Espaço Total em disco " .round($TotalOnDisco/$mb,2)." MBytes" 
: ("Espaço Total em disco " .round($TotalOnDisco/$gb,2)." GBytes"))))."</h4>";                         
                         
$EspacoUsado =     $TotalOnDisco -     $EspOnDisco;

 echo "<h4>".($EspacoUsado < $kb 
?  "Espaço usado em disco " . $EspacoUsado." Bytes" : ($EspacoUsado < $mb 
?  "Espaço usado em disco " .round($EspacoUsado/$kb,2)." KBytes" : ($EspacoUsado < $gb
?  "Espaço usado em disco " .round($EspacoUsado/$mb,2)." MBytes" 
: ("Espaço usado em disco " .round($EspacoUsado/$gb,2)." GBytes"))))."</h4>";            
                      


?>
]]> http://www.revista-php.net/artigos.php?pagina=41 O objectivo deste artigo é complementar a teoria do artigo que escrevi antes

"Compreenda como funciona o Ajax"

disponível aqui , o qual deverá ler com bastante atenção de forma a compreender o que foi aqui feito.
Muitos programadores optam por chamar a livraria Ajax , a partir dum ficheiro *.js. No meu caso como a livraria é muito reduzida optei por por incluí-la na página , onde o pedido é solicitado.
Basicamente o processo é muito simples a página "ajax.php" contém a interface e o processamento