Endereço do novo Blog: http://ziscode.com

Neste post explicarei a solução encontrada para este problema onde será possível carregar os atributos adicionados à classe dentro do array (_data) que encaminha dos dados do Zend Framework para o Flex

Antes de iniciar a explicação gostaria de esclarecer que a solução aqui encontrada foi desenvolvida pelo Professor Carlos Henrique Bughi da UNIVALI, após eu ter terminado o post da integração passei o mesmo para ele e expliquei sobre o problema encontrado durante o processo de integração, dias depois ele concedeu uma solução para o problema que será explicado aqui.

Então gostaria de agradecer ao Professor Carlos pela solução do problema aqui abordado.

Como já sabemos a classe responsável pelas classes de modelo geradas pelo Doctrine é a classe Doctrine_Record, nesta classe existe um método chamado “getInterator()”, este método tem como valor de retorno um objeto da classe Doctrine_Record_Interator, este objeto é a responsável pelo array de atributos das classes de modelo geradas pelo Doctrine portanto será substituída por uma nova classe que contem as alterações necessárias.

Para alterarmos a classe acesse o arquivo Record.php, vá ao diretório onde se encontra o arquivo na raiz da biblioteca do Doctrine (../Doctrine/Record.php) e abra em um editor. Com a classe aberta em um editor procure o método mencionado anteriormente.

Dentro deste método comente a seguinte linha de código.

//return new Doctrine_Record_Iterator($this);

E adicione a seguinte linha ao mesmo.

return new Custom_Record_Iterator($this);

Esta linha retornará o objeto correspondente à classe criada para a solução. Agora dentro do mesmo arquivo ao final da classe Doctrine_Record logo após o fechamento da ultima chave crie uma nova classe chamada Custom_record_Interator, após criar a classe vá até o diretório (../Doctrine/Record/Interator.php)  e abra este arquivo em um editor copie o conteúdo desta classe para dentro da classe criada anteriormente. O código ficará assim:

class Custom_Record_Iterator extends ArrayIterator
{
/**
     * @var Doctrine_Record $record
     */
    private $record;

    /**
     * @var Doctrine_Null $null
     */
    private static $null;

    /**
     * constructor
     *
     * @param Doctrine_Record $record
     */
    public function __construct(Doctrine_Record $record)
    {
        $this->record = $record;
        parent::__construct($record->getData());
    }

    /**
     * initNullObject
     *
     * @param Doctrine_Null $null
     */
    public static function initNullObject(Doctrine_Null $null)
    {
        self::$null = $null;
    }

    /**
     * current
     *
     * @return mixed
     */
    public function current()
    {
        $value = parent::current();

        if ($value === self::$null) {
            return null;
        } else {
            return $value;
        }
    }
}

Uma variável é adicionada “$var” esta variável recebe o array de dados do objeto que está sendo utilizado, em seguida criamos um objeto “ReflectionClass” passando como parâmetro o objeto $record e através desse objeto que se obtem os atributos adicionais da classe modelo criada pelo Doctrine, como parâmetro definimos que queremos apenas os atributos públicos da classe já que os mesmos tem a necessidade de serem reconhecidos entre o lado servidor e lado cliente. Após obter os atributos adicionais da classe o array é percorrido para adicionar o valor do atributo ao array de dados (_data). E por fim passando os valores à classe pai da mesma.

Como pode ser visto não é necessária uma grande alteração para solução do problema apenas alteramos o construtor da classe. Aqui neste caso foi criada uma nova classe para solução, abordei este método para não alterar a classe original da biblioteca do Doctrine, mas nada impede de alterar o construtor da própria classe. O código a seguir é como ficou a classe após a alteração.

class Custom_Record_Iterator extends ArrayIterator
{
    /**
     * @var Doctrine_Record $record
     */
    private $record;

    /**
     * @var Doctrine_Null $null
     */
    private static $null;

    /**
     * constructor
     *
     * @param Doctrine_Record $record
     */
    public function __construct(Doctrine_Record $record)
    {
        $this->record = $record;
        $var = $record->getData();

        //Obtem o nome da classe
        $reflect = new ReflectionClass($record);
        //Retorna array com os atributos publicos da classe
        $props   = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);

        //Adiciona os valores dos atributos adicinais da classe ao array de atributos da classe
        foreach ($props as $prop) {
        	$var[$prop->getName()] = $prop->getValue($record);
        }

        parent::__construct($var);
    }

    /**
     * initNullObject
     *
     * @param Doctrine_Null $null
     */
    public static function initNullObject(Doctrine_Null $null)
    {
        self::$null = $null;
    }

    /**
     * current
     *
     * @return mixed
     */
    public function current()
    {
        $value = parent::current();

        if ($value === self::$null) {
            return null;
        } else {
            return $value;
        }
    }
}

Agora como no caso abordado na integração das ferramentas dois atributos tinham sido atribuídos à classe.

  public $nomHospede
  public $nomHotel

Adicione o método “construct()” à classe e dentro deste método chame os métodos que adicionavam o valor aos atributos ou até mesmo adicione o valor necessário dentro do construtor caso desejar. O código a seguir mostrará como ficará a classe Reserva abordada no post sobre a integração das ferramentas mencionadas.

class Reserva extends Base_Reserva
{

	public $_explicitType = "Reserva";
	public $nomHospede;
	public $nomHotel;

	public function setTableDefinition(){
		parent::setTableDefinition();
		$this->hasColumn('cod_reserva as codReserva');
		$this->hasColumn('cod_hotel_quarto as codHotelQuarto');
		$this->hasColumn('num_quarto as numQuarto');
		$this->hasColumn('cod_hospede as codHospede');
		$this->hasColumn('dat_reserva as datReserva');
		$this->hasColumn('qtd_dias as qtdDias');
		$this->hasColumn('sit_reserva as sitReserva');

	}

	public function construct(){
		$this->setNomHospede();
		$this->setNomeHotel();
	}

	public function setNomHospede($value = null){
		if(is_null($value)){
			$n = HospedeTable::getInstance();
			$value = $n->findOneBy('cod_hospede', $this->codHospede);
			$this->nomHospede = $value->nomHospede;
		}else{
			$this->nomHospede = $value;
		}

	}

	public function getNomHospede(){
		return $this->nomHospede;
	}

	public function setNomeHotel($value = null){
		if(is_null($value)){
			$q = Doctrine_Query::create()
			->select('q.nom_hotel, h.cod_hotel_quarto')
			->from('Hotel q')
			->leftJoin('q.HotelQuarto h on h.cod_hotel = q.cod_hotel')
			->where('h.cod_hotel_quarto = '.$this->codHotelQuarto);
			$result = $q->execute();
			$v = $result->getData();
			$this->nomHotel = $v[0]->nomHotel;
		}else{
			$this->nomHotel = $value;
		}
	}

	public function getNomHotel(){
		return $this->nomHotel;
	}
}

Como pode ser observado após a alteração necessária basta apenas aplicar a classe com atributos extras o método “construct()” para adicionar os valores desejados ao atributo assim não será mais necessário chamar um método para atribuir os valores cada vez que a classe for utilizada no projeto.

Bem espero que esta informação seja útil para quem desenvolve projetos utilizando as ferramentas aqui abordadas. Dúvidas ou sugestões deixem um recado aqui ou enviem um e-mail para ziscode@gmail.com.

Até a próxima.

Bem vou aplicar o exemplo encontrado e que adotei na aplicação que estava desenvolvendo. Deixo bem claro que esta abordagem é apenas para sistema desenvolvidos em Flex 3, pois na versão atual da ferramenta não há a necessidade de fazer isto pois existe os Skins para auxiliar.

Para adicionarmos um novo componente à borda superior do Panel crie uma nova classe, que chamei aqui de “CustomPanel”, e estenda a classe Panel. Em seguida será necessário sobrescrever dois métodos da classe, o método “createChildren” e o método “updateDisplayList”, o primeiro método é sobrescrito para poder adicionar o componente a borda do Panel. Pode-se adicionar vários componentes, o que será abordado no exemplo é o LinkButton, código a seguir.

<strong>
override protected function createChildren():void {

    super.createChildren();

    //Criando um novo botão com o icone de uma lupa.
    linkButtonSearch = new LinkButton();
    linkButtonSearch.height =  borderMetrics.top -6;
    linkButtonSearch.width =  borderMetrics.top -6;
    linkButtonSearch.setStyle('icon', iconSearch);
    linkButtonSearch.setStyle("themeColor", 0x666666);
    rawChildren.addChild(linkButtonSearch);

    //Criando um novo botão com o icone para fechar a janela.
    linkButtonClose = new LinkButton();
    linkButtonClose.height =  borderMetrics.top -6;
    linkButtonClose.width =  borderMetrics.top -6;
    linkButtonClose.setStyle('icon', iconClose);
    linkButtonClose.setStyle("themeColor", 0x666666);
    //Adicionado evento para fechar a janela adicionada à um popup.
    linkButtonClose.addEventListener(MouseEvent.CLICK, close);
    rawChildren.addChild(linkButtonClose);
}

O segundo método a ser sobrescrito é utilizado por vários componentes no Flex para atualizar o componente quando o mesmo é alterado, ou seja, cada vez que o componente sofre uma alteração este método é chamado.  Código abaixo.

override protected function updateDisplayList (unscaledWidth:Number, unscaledHeight:Number):void {

    super.updateDisplayList(unscaledWidth, unscaledHeight);
    //Obtendo tamanho da borda do Panel e realizando cálculos para posicionar o componente.
    var y:int = borderMetrics.top/2 - linkButtonSearch.width/2;
    var x:int = this.width - linkButtonSearch.width - borderMetrics.right;

    //Posicionando o botão.
    linkButtonSearch.move((x-50), y);
    y = borderMetrics.top/2 - linkButtonClose.width/2;
    x = this.width - linkButtonClose.width - borderMetrics.right;
    linkButtonClose.move((x-5), y);
}

Foi adicionado ao código da classe outro método apenas para utilizar o evento para fechar o Panel quando o mesmo for adicionado a um PopUpManeger.

Abaixo o código da classe criada e o código para testarmos o componente criado.

package
{
	import flash.events.MouseEvent;

	import mx.containers.Panel;
	import mx.controls.LinkButton;
	import mx.managers.PopUpManager;

	public class CustomPanel extends Panel
	{

		[Embed(source="assets/open_search.png")]
		private static var iconSearch:Class;

		[Embed(source="assets/close_window.png")]
		private static var iconClose:Class

		private var linkButtonSearch:LinkButton;
		private var linkButtonClose:LinkButton;

		public function CustomPanel()
		{
			super();
		}

		/**
		 * Método para criar componentes que serão filhos deste painel.
		 * */
		override protected function createChildren() : void{

			super.createChildren();

			//Criando um novo botão com o icone de uma lupa.
			linkButtonSearch =  new LinkButton();
			linkButtonSearch.height =  borderMetrics.top -6;
			linkButtonSearch.width =  borderMetrics.top -6;
			linkButtonSearch.setStyle('icon', iconSearch);
			linkButtonSearch.setStyle("themeColor", 0x666666);
			rawChildren.addChild(linkButtonSearch);

			//Criando um novo botão com o icone para fechar a janela.
			linkButtonClose =  new LinkButton();
			linkButtonClose.height =  borderMetrics.top -6;
			linkButtonClose.width =  borderMetrics.top -6;
			linkButtonClose.setStyle('icon', iconClose);
			linkButtonClose.setStyle("themeColor", 0x666666);
			//Adicionado evento para fechar a janela adicionada à um popup.
			linkButtonClose.addEventListener(MouseEvent.CLICK, close);
			rawChildren.addChild(linkButtonClose);

		}

		/**
		 * Atualiza o componente quando o mesmo sofre uma alteração em seu formato.
		 * */
		override protected function updateDisplayList (unscaledWidth:Number, unscaledHeight:Number):void{

			super.updateDisplayList(unscaledWidth, unscaledHeight);

			//Obtendo tamanho da borda do Panel e realizando cálculos para posicionar o componente.
			var y:int = borderMetrics.top/2 - linkButtonSearch.width/2;
			var x:int = this.width - linkButtonSearch.width - borderMetrics.right;

			//Posicionando o botão.
			linkButtonSearch.move((x-50), y);

			y = borderMetrics.top/2 - linkButtonClose.width/2;
			x = this.width - linkButtonClose.width - borderMetrics.right;
			linkButtonClose.move((x-5), y);
		}

		/**
		 * Método para fechar o Panel quando adicionado em um PopUpManager.
		 * */
		private function close(e:MouseEvent):void {
			PopUpManager.removePopUp(this);
		}
	}
}

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
	<mx:Script>
		<![CDATA[
			import mx.managers.PopUpManager;

			public function addPanel():void {
				var panel:CustomPanel = new CustomPanel();
				panel.width = 200;
				panel.height = 100;
				panel.title = "CustomPanel";
				PopUpManager.addPopUp(panel, this);
				PopUpManager.centerPopUp(panel);
			}
		]]>
	</mx:Script>
	<mx:Button x="86" y="41" label="Add Panel" click="addPanel()"/>
</mx:Application>

Link para download dos fontes: http://www.megaupload.com/?d=SMKKF4LP

Espero que tenham gostado. Dúvidas ou sugestões deixem um recado ou enviem um e-mail para ziscode@gmail.com.

Acho importante que, para quem ainda não utiliza o Flex, conhecer o funcionamento desta integração sem a utilização de frameworks, pois isto facilita muito o processo de aprendizado, algo que não ocorreu comigo, que ao utilizar a ferramenta de desenvolvimento Flex trabalhei já com o framework Symfony e após um tempo é que apliquei em estudos e testes a integração utilizando somente o Amfphp.

Aproveitem o tutorial.

As ferramentas utilizadas para este tutorial são:

Adobe Flash Builder 4: ferramenta de desenvolvimento distribuído pela Adobe em forma Trial para 60 dias e também a empresa cede licença para estudantes apenas para desenvolver aplicações que não podem ser comercializadas. Link para download: http://www.adobe.com/br/products/flashbuilder/?sdid=GWQOF.

NetBeans 6.9.1: IDE gratuita utilizada para desenvolver a parte do projeto no lado PHP, esta ferramenta tem suporte a várias outras linguagens de programação como o Java que é o carro chefe da IDE, C++, Ruby, etc. Link para download: http://netbeans.org/downloads/.

Amfphp 1.9: Esta será a ferramenta que realizará a comunicação entre o Flex e o PHP através da serialização e desrealização das informações trocadas entre as ferramentas. Apesar do projeto desta ferramenta ter sido descontinuada pelo seu criador, ainda é possível baixar e utilizar a mesma. Outras versões desta ferramenta estão sendo mantidas pela Zend e foi integrada ao framework da empresa chamado de ZendFramework. Link para download do Amfphp: http://sourceforge.net/projects/amfphp/files/#files. Link do site oficial: http://amfphp.sourceforge.net/.

PostgreSQL 8.4: Este é o banco de dados que geralmente uso para desenvolver as aplicações em que trabalho, pois é um banco de dados robusto e de fácil utilização, pois pode ser baixado já com a ferramenta para gerenciamento que se chama PgAdmin. Link para download: http://www.postgresql.org/download/.

Apenas quero destacar aqui que não é necessário utilizar exatamente as ferramentas descritas aqui existem outra IDEs para programação PHP e desenvolvimento da parte Flex do tutorial, bem como outros bancos de dados fica a sua escolha qual ferramenta utilizar.

O que é o Amfphp?

Amfphp é uma ferramenta open-source que promove a comunicação entre aplicações da parte cliente desenvolvidas em Flash, Flex e AIR com o PHP, que é uma linguagem de programação utilizada no lado servidor. Esta comunicação ocorre através da serialização de tipos nativos e objetos da linguagem actionscript enviadas para o lado do servidor utilizando o protocolo de comunicação AMF.

Explicando de forma mais clara o a aplicação do lado cliente, que pode ser uma aplicação Flex envia a informação serializada para o servidor, ao receber a informação o Amfphp realiza a desrealização da informação e converte para o tipo que o PHP entende, com a informação já tratada, utiliza-se a mesma conforme for necessário enquanto o lado cliente da aplicação espera uma resposta do servidor. A resposta retornada pode ser uma nova informação serializada, uma mensagem, um determinado valor ou até mesmo um erro casso ocorra algum durante a requisição.

E todo esse processo de comunicação entre as duas interfaces é gerenciado pelo Amfphp.

O padrão de arquitetura MVC.

Para quem ainda não conhece, MVC é um padrão de arquitetura de projetos que visa separar a lógica de um projeto de sua visão. O significado de MVC é model, view e control. O model ou modelo tem como objetivo definir o domínio da aplicação é aqui neste componente que desenvolvemos as classes de domínio da aplicação. O view ou visão é onde ficam os componentes que são visualizados pelo cliente, neste caso a aplicação do lado Flex representa este componente da arquitetura. Já o control ou controle comporta a parte de lógica do negocio da aplicação como, por exemplo, as consultas no banco de dados, tratamento das informações, etc.

Iniciando o projeto.

Para dar inicio ao projeto crie um diretório no diretório root do servidor (localhost), neste diretório serão alocados os arquivos do projeto. Agora para seguir o modelo de padrão arquitetural MVC dentro da pasta que será criado o projeto crie os diretórios model, view e controller. E para finalizar crie um diretório e nomeie o mesmo de lib. O diretório lib é o local onde serão adicionados os arquivos do amfphp.

Após realizar o download do Amfphp extraia o arquivo para o diretório lib do projeto, deixe o arquivo extraído com o nome amfphp. O diretório do amfphp esta dividido da seguinte forma.

Diretório browser, dentro deste diretório se encontra uma ferramenta muito útil na hora que se está desenvolvendo, ali contêm uma ferramenta desenvolvida em Flex onde podem ser configurados os services do projeto que está sendo criado e testar se o mesmo está cumprindo com as tarefas à que foi designado. Porem não será abordado à utilização desta ferramenta neste tutorial.

No diretório core é onde ficam alocados os arquivos que fazem o Amfphp funcionar, ou seja, é neste diretório que se encontra a parte funcional da ferramenta.

O diretório service será o local onde serão criadas as classes services do sistema, as classes services são designadas para receber a informação enviada do cliente, ou seja, do Flex para o sistema na parte servidor que neste caso é o PHP. Nestas classes determinamos métodos para realizar as tarefas necessárias e através destes métodos que a informação retorna novamente para o lado cliente da aplicação.

Os outros dois arquivos relevantes para a aplicação é o gateway.php e o globals.php. O arquivo gateway é o responsável por receber a requisição enviada pelo lado cliente e encaminhar para o service requisitado e o método solicitado para realizar a tarefa, e é através do mesmo que a informação retorna para o cliente. O arquivo globals é responsável pela configuração do diretório onde se encontram alocado os services, e as classes que representam os objetos transmitidos entre os dois lados da aplicação. Sobre estas classes explicarei mais a frente.

Agora para configurar a ferramenta Amfphp coloque o diretório service no diretório principal do projeto junto dos diretórios da arquitetura MVC e do diretório lib. Apenas deixarei claro que a escolha do local dos diretórios fica a sua escolha, estou optando por colocar o diretório service neste local apenas para deixar o projeto de forma organizada separando a aplicação de forma que fique fácil de gerenciar.

Agora para que o Amfphp encontre a pasta service é necessário configurar a localização do diretório. Abra o arquivo globals.php no editor de sua escolha, neste arquivo existem duas linhas de código que representam o caminho dos diretórios service e vo.

$servicesPath = “services/”;

$voPath = “services/vo/”;

O diretório service já foi explicado. Mas para que serve o diretório “vo”?

No diretório “vo” ficam alocados as classes PHP que representam os objetos utilizados nas transações entre o lado cliente e o lado servidor. Porem estas classes será representado pelas classes de modelo do sistema, e estas classes serão alocadas no diretório model do projeto. Abaixo como ficarão as linhas de código após a configuração.

$servicesPath = dirname(dirname(dirname(__FILE__))).DIRECTORY_SEPARATOR. “services” .DIRECTORY_SEPARATOR;

$voPath = dirname(dirname(dirname(__FILE__))).DIRECTORY_SEPARATOR. “model” .DIRECTORY_SEPARATOR;

Explicando a configuração da constante __FILE__ representa o caminho para o diretório onde se encontra o arquivo de configuração e cada dirname representa o retorno de um nível da hierarquia dos diretórios, desta forma os diretórios estão configurados para serem reconhecidos quando forem solicitados pelo Amfphp.

Com as configurações do Amfphp realizadas já pode ser criado o banco de dados da aplicação, o caso abordado aqui vai utilizar duas tabelas para que se possa visualizar o relacionamento dos objetos. A primeira tabela é a tabela ‘pessoa’ que contêm os campos id, nome e email, a segunda tabela que foi nomeada de ‘informacoes’ contêm os campos id_pessoa, telefone_1, telefone_2 e email_adicional. Esta segunda tabela serve como dados adicionais à pessoa e sua chave primária é também uma chave estrangeira da tabela pessoa.

CREATE TABLE pessoa (
 id integer NOT NULL,
 nome character varying(255) NOT NULL,
 email character varying(255) NOT NULL
);
ALTER SEQUENCE pessoa_id_seq OWNED BY pessoa.id;
ALTER TABLE ONLY pessoa ADD CONSTRAINT pk_id PRIMARY KEY (id);

CREATE TABLE informacoes (
 id_pessoa bigint NOT NULL,
 telefone_1 character varying(50),
 telefone_2 character varying(50),
 email_adicional character varying(255)
);
ALTER TABLE ONLY informacoes ADD CONSTRAINT pk_id_pessoa PRIMARY KEY (id_pessoa);
ALTER TABLE ONLY informacoes ADD CONSTRAINT fk_id_pessoa FOREIGN KEY (id_pessoa) REFERENCES pessoa(id);

Para realizar a conexão com o banco de dados é interessante que seja criado uma classe no PHP para realizar esta função. Então crie uma classe com o nome que desejar, a classe que eu criei foi nomeada de Db. Nesta classe eu criei métodos estáticos para realizar as funções de conexão e consultas no banco de dados, o método abordado para esta classe também fica a sua escolha. A seguir o código da classe de conexão com o banco de dados.

class Db {

 public static $conection;

 function Db(){
 }

 public static function dbConect(){
   try{
     Db::$conection = pg_connect("host=localhost user=postgres password=ragnarok dbname=db_amfphp");
   }catch (Exception $ex){
     echo $ex->getMessage();
   }
 }

 public static function dbInserts($sql){
   try{
     $result = pg_query(Db::$conection, $sql);

     if($result){
       return true;
     }

   }catch (Exception $ex){
     echo $ex->getMessage();
   }
 }

 public static function dbConsult($sql){
   try{
     $result = pg_query(Db::$conection, $sql);
     if($result){
       return  pg_fetch_all($result);
     }
   }catch (Exception $ex){
     echo $ex->getMessage();
   }
 }

 public static function dbConsultOneObject($sql){
   try{
     $result = pg_query(Db::$conection, $sql);
     if($result){
       return  pg_fetch_object($result);
     }
   }catch (Exception $ex){
     echo $ex->getMessage();
   }
 }

 public static function dbClose(){
   pg_close();
 }
}

Explicando esta classe, o método dbConect() contêm a string de conexão para o banco de dados, o método dbInserts($sql) é utilizado para realizar as consultas de inserção, alteração e exclusão no banco de dados e recebe como parâmetro o SQL que será executado, o método dbConsult($sql) será utilizado para realizar as consultas que retornam uma lista de registro no banco de dados e que posteriormente se tornará uma lista de objetos que retornará para a aplicação do lado cliente, o método dbConsultOneObject($sql) retorna da consulta apenas um objeto que pode ser utilizado em momentos que se quer obter apenas um registro do banco de dados, porem o retorno vem em forma de objeto padrão do PHP e por ultimo o método dbClose() utilizado para encerrar a conexão com o banco de dados.

Lembrando que os métodos de consulta ao banco de dados aqui abordado se refere ao banco de dados Postgre para outros bancos de dados consulte a documentação do PHP no link: http://www.php.net/.

Com as tabelas do banco de dados já criadas será necessário criar as classes do domínio do sistema. As classes de domínio ou como conhecida por algumas pessoas como classes de modelo, serão as criadas tanto para representar os campos das tabelas no banco de dados como para ser utilizadas nas transações de objetos entre a aplicação do lado cliente, ou seja, o Flex e a aplicação parte servidor neste caso o PHP.

Crie uma classe chamada Pessoa e outra chamada Informacoes adicione os atributos que representam as tabelas no banco de dados e os métodos set e get de cada atributo.

A seguir como ficarão as classes criadas.

class Pessoa {

 public $id;
 public $nome;
 public $email;

 public $_explicitType = "Pessoa";

 public function setId($value){
   $this->id = $value;
 }

 public function getId(){
   return $this->id;
 }

 public function setNome($value){
   $this->nome = $value;
 }

 public function getNome(){
   return $this->nome;
 }

 public function setEmail($value){
   $this->email = $value;
 }

 public function getEmail(){
   return $this->email;
 }
}

require_once 'Pessoa.php';

class Informacoes {

 public $idPessoa;
 public $telefone1;
 public $telefone2;
 public $emailAdicional;
 public $pessoa;

 function Informacoes(){
   $this->pessoa = new Pessoa();
 }

 public $_explicitType = "Informacoes";

 public function setIdPessoa($value){
   $this->idPessoa = $value;
 }

 public function getIdPessoa(){
   return $this->idPessoa;
 }

 public function setTelefone1($value){
   $this->telefone1 = $value;
 }

 public function getTelefone1(){
   return $this->telefone1;
 }

 public function setTelefone2($value){
   $this->telefone2 = $value;
 }

 public function getTelefone2(){
   return $this->telefone2;
 }

 public function setEmailAdicional($value){
   $this->emailAdicional = $value;
 }

 public function getEmailAdicional(){
   return $this->emailAdicional;
 }

 public function setPessoa(Pessoa $value){
   $this->pessoa = $value;
 }

 public function getPessoa(){
   return $this->pessoa;
 }
}

Como pode ser observado nas classes existe um atributo adicional, o $_explicitType, este atributo adicional que recebe como valor uma string com o mesmo nome da classe em que se encontra, este atributo será utilizado pelo AMF para reconhecer qual classe no lado cliente da aplicação lado Flex representa a classe no lado PHP. Não é necessário que as classes tenham o mesmo nome em ambos os lados apenas abordo este método porque acho melhor de controlar a aplicação. Mas fica aqui um detalhe os atributos em ambas as classes têm que ter o mesmo nome para que o objeto criado seja reconhecido em ambos os lados durante as transações da aplicação.

A classe de controle do projeto fará a gerencia do mesmo, nesta classe contêm os métodos que realizarão as consultas no banco de dados e retornarão os resultados quando for necessário e também será utilizada pela classe service. Aqui nesta classe foi utilizado um padrão de projeto que é comum abordar para facilitar o uso da classe, este padrão se chama singleton, não abordarei sobre este padrão aqui, mas existe muito conteúdo na web sobre padrões de projeto inclusive este descrito aqui que melhor explicarão sobre o assunto. Abaixo a classe de controle criada para o projeto

require_once '../config/Db.php';
require_once '../model/Informacoes.php';

class DadosController {

 static private $instance;

 static public function getInstance(){
   if(!isset (self::$instance)){
     $ins = __CLASS__;
     self::$instance = new $ins;
   }
   return self::$instance;
 }

 public function create(Informacoes $object){
   Db::dbConect();
   $object->getPessoa()->setId((int)Db::dbConsultOneObject("select nextval('pessoa_id_seq')")->nextval);
   Db::dbInserts("INSERT INTO pessoa (id, nome, email) VALUES (".$object->getPessoa()->id.",'".$object->getPessoa()->nome."','".$object->getPessoa()->email."')");
   Db::dbInserts("INSERT INTO informacoes (id_pessoa, telefone_1, telefone_2, email_adicional) VALUES (".$object->getPessoa()->id.",'".$object->getTelefone1()."','".$object->getTelefone2()."','".$object->getEmailAdicional()."')");
   Db::dbClose();
   return $object;
 }

 public function update(Informacoes $object){
   Db::dbConect();
   Db::dbInserts("UPDATE pessoa SET id = ".$object->getPessoa()->id.", nome = '".$object->getPessoa()->nome."', email = '".$object->getPessoa()->email."' WHERE id = ".$object->getPessoa()->id);
   Db::dbInserts("UPDATE informacoes SET id_pessoa = ".$object->getPessoa()->id.", telefone_1 = '".$object->getTelefone1()."', telefone_2 = '".$object->getTelefone2()."', email_adicional = '".$object->getEmailAdicional()."' WHERE id_pessoa = ".$object->getPessoa()->id);
   Db::dbClose();
 }

 public function delete(Informacoes $object){
   Db::dbConect();
   Db::dbInserts("DELETE FROM informacoes WHERE id_pessoa = ".$object->getPessoa()->id);
   Db::dbInserts("DELETE FROM pessoa WHERE id = ".$object->getPessoa()->id);
   Db::dbClose();
 }

 public function _list(){
   $array = array();
   $retorno = array();
   Db::dbConect();
   $array = Db::dbConsult('select * from pessoa left join informacoes on (id_pessoa = id)');
   Db::dbClose();

   foreach($array as $item){
     $infromacoes  = new Informacoes();
     $infromacoes->getPessoa()->setId($item['id']);
     $infromacoes->getPessoa()->setNome($item['nome']);
     $infromacoes->getPessoa()->setEmail($item['email']);
     $infromacoes->setIdPessoa($item['id']);
     $infromacoes->setTelefone1($item['telefone_1']);
     $infromacoes->setTelefone2($item['telefone_2']);
     $infromacoes->setEmailAdicional($item['email_adicional']);

     $retorno[] = $infromacoes;
   }

   return $retorno;
 }
}

Existem quatro métodos importantes desta classe, método create(Informacoes $object) realiza as consultas que inserem no banco de dados os valores  cadastrados no lado cliente da aplicação, o método update(Informacoes $object) responsável pela consulta que altera os valores de um registro específico selecionado pelo usuário no lado cliente, o método delete(Informacoes $object) realiza a exclusão dos registros de que foi escolhido pelo usuário e o método _list() responsável por buscar a lista de registros no banco de dados para montar a lista de objetos que retorna para a aplicação do lado cliente e finalmente sendo utilizado para popular o componente DataGrid da aplicação.

Crie uma classe dentro do diretório service do projeto com o nome que desejar, apenas após o nome identifique a classe com a palavra Service para destacar a mesma no projeto, como por exemplo, o nome que coloquei ao criar a classe para este tutorial: DadosService.

Estas classes contêm praticamente os mesmos métodos da classe de controle do projeto, mas daí você se pergunta, por que não utilizar a classe service como controle da aplicação? Nada impede de ser utilizada, mas temos que ter em mente que esta classe é responsável em receber as requisições enviadas pelo cliente, então é melhor que o projeto fique de forma organizada e de melhor manutenção por isso este método de construção da aplicação foi abordado.

A classe service tem como objetivo executar o método solicitado pela requisição na parte cliente e retornar uma resposta para o cliente, parâmetros podem ou não ser passado para os métodos da classe, mas é bom que sempre tenha um retorno nos mesmos, apesar de não ser obrigatório.

include_once '../model/Informacoes.php';
include_once '../controller/DadosController.php';

class DadosService {

 public function create(Informacoes $object){
   return DadosController::getInstance()->create($object);
 }

 public function update(Informacoes $object){
   DadosController::getInstance()->update($object);
   return  $object;
 }

 public function delete(Informacoes $object){
   DadosController::getInstance()->delete($object);
   return true;
 }

 public function lista(){
   return DadosController::getInstance()->_list();
 }
}

Criando o projeto Flex.

Para criar um novo projeto Flex, na ferramenta Flash Builder acesse no menu o campo File->New->Flex Project uma janela abrirá.

Nesta janela será definido o nome do projeto no campo Project name e o diretório onde ficará alocado o projeto definido pelo campo Folder. Escolha o diretório view do projeto na parte do servidor e crie um novo diretório e coloque o nome que desejar, dentro deste novo diretório ficará a aplicação do lado cliente. Clique em Next.

Na próxima janela é definido o local que será criado os arquivos SWF do projeto. Os arquivos SWF são arquivos com extensão Flash que rodam na ferramenta Flash Player e cada vez que a ferramenta Flash Builder compila o projeto gera o arquivo com as alterações ou com o que for criado de novo no projeto.

Por padrão o Flex cria um diretório dentro do projeto chamado de bin-debug, mas neste projeto eu criei um novo diretório chamado índex no diretório view, assim os arquivos compilados pela ferramenta serão alocados neste diretório e no mesmo é que será acessado no browser quando utilizarmos o projeto. Clique em next novamente.

A ultima tela de configuração do projeto é utilizado para incluir bibliotecas ao projeto, configurar o diretório padrão do projeto, o nome do arquivo principal do projeto e a URL de saída do projeto.

No projeto aqui abordado não é necessário incluir nenhuma biblioteca e nem mesmo mudar o diretório padrão do projeto. Apenas decidi trocar o nome do arquivo principal para index.mxml e adicionei a URL onde ficará o arquivo SWF principal do projeto.

Como havia explicado anteriormente para realizar a transação de objetos iguais entre o cliente e o servidor é necessário ter a classe que representa a classe PHP também no projeto do lado Cliente, portanto crie um novo diretório no projeto Flex com o nome model. Dentro deste diretório as classes que representam as classes do PHP e acrescente os mesmos atributos existente na classe PHP. A seguir como ficarão as classes.

package model
{
  public class Pessoa
  {
    public var id:int;
    public var nome:String;
    public var email:String;
  }
}

package model
{
  public class Informacoes
  {
    public var idPessoa:int;
    public var telefone1:String;
    public var telefone2:String;
    public var emailAdicional:String;

    public var pessoa:Pessoa = new Pessoa();
  }
}

Nestas classes também será necessário criar um método para reconhecer a classe PHP da mesma forma que no PHP utilizou um método de reconhecimento da classe no lado cliente. Para isso é necessário adicionar a seguinte declaração à classe [RemoteClass(alias=”Nome_classe_PHP”)]. Abaixo um exemplo da classe pessoa com a declaração. Realize o mesmo para a classe Informacoes.

package model
{
  [Bindable]
  [RemoteClass(alias="Pessoa")]

  public class Pessoa
  {
    public var id:int;
    public var nome:String;
    public var email:String;
  }
}

Neste tutorial não vou abordar a criação de telas separadas para listar as informações e outra para cadastro, portanto estes campos serão criados no arquivo principal do projeto. Com o arquivo principal aberto no Flex Builder clique em Design e adicione os campos necessários para o cadastro, o botão para salvar, uma tabela para mostrar as informações salvas e um botão para excluir um item e outro alterá-lo. A imagem a seguir mostra como ficará a tela e na seqüência o código gerado.

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600">
  <fx:Declarations>
   <!-- Place non-visual elements (e.g., services, value objects) here -->
  </fx:Declarations>
  <s:Label x="67" y="66" text="Nome:"/>
  <s:Label x="64" y="96" text="E-mail:"/>
  <s:Label x="41" y="126" text="Telefone 1:"/>
  <s:Label x="41" y="156" text="Telefone 2:"/>
  <s:Label x="10" y="186" text="E-mail Adicional:"/>
  <s:TextInput x="111" y="56" width="280"/>
  <s:TextInput x="111" y="86" width="280"/>
  <s:TextInput x="111" y="116" width="280"/>
  <s:TextInput x="111" y="146" width="280"/>
  <s:TextInput x="111" y="176" width="280"/>
  <mx:DataGrid x="10" y="261" width="506" height="206">
   <mx:columns>
     <mx:DataGridColumn headerText="Id Pessoa" dataField="col1"/>
     <mx:DataGridColumn headerText="Nome" dataField="col2"/>
     <mx:DataGridColumn headerText="E-mail" dataField="col3"/>
   </mx:columns>
  </mx:DataGrid>
  <s:Button x="321" y="206" label="Salvar"/>
  <s:Button x="188" y="475" label="Excluir"/>
  <s:Button x="266" y="475" label="Alterar"/>
</s:Application>

Agora que as classes e a tela do sistema foram criadas, será necessário configurar um XML para definir o end point do lado do servidor que receberá as requisições enviadas pelo Flex. No diretório principal do projeto Flex crie um arquivo XML com o nome de services-config.xml. E coloque o código mostrado a seguir.

<?xml version="1.0" encoding="UTF-8"?>
  <services-config>
    <services>
      <service id="flextest-service" messageTypes="flex.messaging.messages.RemotingMessage">
        <destination id="flexamf">
          <channels>
            <channel ref="my-flexamf"/>
          </channels>
          <properties>
            <source>*</source>
          </properties>
        </destination>
      </service>
    </services>
    <channels>
      <channel-definition id="my-flexamf">
        <endpoint uri="http://localhost/flex_amfphp/lib/amfphp/gateway.php"/>
      </channel-definition>
    </channels>
  </services-config>

Como pode ser visto no código existe uma tag no XML que identifica a url do end point no projeto na parte PHP, portanto coloque ali a url com o local onde se encontra o arquivo gateway.php que é o end point do projeto e o arquivo que recebe as requisições do flex.

Após criar e configurar este arquivo é necessário adicionar ao compilador do Flex um novo parâmetro para reconhecer esta configuração recém criada. Então clique no projeto com o botão direito do mouse e o menu de opções do projeto se abrirá vá até propriedades e clique novamente. A janela de propriedades do projeto se abrirá, vá ate a opção Flex Compiler e no campo Additional compiler arguments adicione o seguinte: -services “services-config.xml”. Em seguida clique em OK para finalizar a configuração.

Agora o próximo passo é desenvolvermos uma classe para enviar as requisições do Flex para o PHP chamando os métodos da classe service que já foi criada. Mas antes será criada uma classe responsável por realizar estas requisições. Só para explicar rapidamente o Flex realiza as requisições através de uma classe chamada RemoteObject, onde é necessário informar o canal de comunicação com o PHP que neste caso é o caminho configurado no arquivo services-config.xml, o método de resposta da requisição, o método que receberá a resposta de erro caso ocorra algum durante a requisição, o service no lado PHP que será requisitado, o método do service requisitado que será executado e os parâmetros do método caso tenha algum.

Então para facilitar esse processo primeiramente crie um novo diretório no projeto do lado Flex e nomeio como quiser no meu caso coloquei como controller, em seguida dentro do mesmo diretório crie uma classe com o nome que desejar. Esta classe deve estender a classe RemoteObject, em seguida configure a classe conforme mostrado a seguir no código.

package controller
{

  import mx.controls.Alert;
  import mx.rpc.events.FaultEvent;
  import mx.rpc.events.ResultEvent;
  import mx.rpc.remoting.mxml.RemoteObject;

  public class RemoteObj extends RemoteObject
  {
    public function RemoteObj(userSource:String=null, userResult:Function=null)
    {
       super("flexamf");
       super.showBusyCursor = true;
       super.addEventListener(FaultEvent.FAULT, onFault);
       if (userSource is String){
         super.source = userSource;
       }
       if (userResult is Function){
         super.addEventListener(ResultEvent.RESULT, userResult);
       }
    }

    private function onFault(e:FaultEvent):void{
      Alert.show(e.fault.faultString+"\n"+e.fault.faultDetail, e.fault.faultCode.toString());
    }
  }
}

Ao terminar a configuração crie outra classe que será responsável por requisitar os métodos da classe service no PHP, esta classe também pode ser nomeada como desejar. Nesta classe crie um atributo constate chamado SERVICE_NAME esse atributo receberá como valor o nome do service que será solicitado durante as requisições. Crie também os métodos para criar, alterar, excluir e listar os dados.

package controller
{
  import model.Informacoes;

  public class ProjectController
  {
    private const SERVICE_NAME:String = "DadosService";

    public function ProjectController()
    {
    }

    public function create(onResult:Function, object:Informacoes):void{
      var remote:RemoteObj = new RemoteObj(this.SERVICE_NAME, onResult);
      remote.getOperation("create").send(object);
    }

    public function update(onResult:Function, object:Informacoes):void{
      var remote:RemoteObj = new RemoteObj(this.SERVICE_NAME, onResult);
      remote.getOperation("update").send(object);
    }

    public function _delete(onResult:Function, object:Informacoes):void{
      var remote:RemoteObj = new RemoteObj(this.SERVICE_NAME, onResult);
      remote.getOperation("delete").send(object);
    }

    public function list(onResult:Function):void{
      var remote:RemoteObj = new RemoteObj(this.SERVICE_NAME, onResult);
      remote.getOperation("lista").send();
    }
  }
}

Dentro de cada método desta classe foi criado uma instancia do objeto que requisitará o service no lado PHP, e como parâmetro do construtor o nome do service que será solicitado e a função de resposta caso ocorra tudo certo durante a requisição com o servidor, em seguida é chamado o método da classe getOperation passando como parâmetro o método do service que será executado e finalmente realizando a requisição com o método send passando quando for necessário algum parâmetro.

Agora é necessário criar as funcionalidades do projeto. No arquivo principal do projeto no lado cliente, ou seja, no lado Flex é necessário criar algumas funções responsáveis pela aplicação, verifique o código a seguir com as alterações realizadas e em seguida explicarei as alterações.

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
 xmlns:s="library://ns.adobe.com/flex/spark"
 xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600" creationComplete="list()">
  <fx:Style source="index_2.css"/>
  <fx:Script>
  <![CDATA[
    import controller.ProjectController;
    import model.Informacoes;
    import mx.controls.Alert;
    import mx.rpc.events.ResultEvent;

    private var projectController:ProjectController = new ProjectController();
    private var informacoes:Informacoes;

    public function save():void{
      var execute:Boolean = true;
      var message:String = "";

      if(informacoes == null){
        this.informacoes = new Informacoes();
      }

      if(nome_pessoa.text == ""){
        message += "O campo 'Nome' é obrigatório.\n";
        execute = false;
      }

      if(email_pessoa.text == ""){
        message += "O campo 'E-mail' é obrigatório.\n";
        execute = false;
      }

      if(execute){
        this.informacoes.pessoa.nome = nome_pessoa.text;
        this.informacoes.pessoa.email = email_pessoa.text;
        this.informacoes.telefone1 = telefone_1.text;
        this.informacoes.telefone2 = telefone_2.text;
        this.informacoes.emailAdicional = email_adicional.text;

        if(informacoes.idPessoa != 0){
          this.projectController.update(resultSave, this.informacoes);
        }else{
          this.projectController.create(resultSave, this.    informacoes);
        }
      }else{
      Alert.show(message);
     }
   }

   public function deleteObject():void{
     if(table.selectedItem != null){
       this.projectController._delete(resultDelete, (table.selectedItem as Informacoes));
     }else{
       Alert.show("Selecione um item da tablea para excluir.");
     }
   }

   public function setDataToEdit():void{
     if(table.selectedItem != null){
       informacoes = table.selectedItem as Informacoes;

       nome_pessoa.text = informacoes.pessoa.nome;
       email_pessoa.text = informacoes.pessoa.email;
       telefone_1.text = informacoes.telefone1;
       telefone_2.text = informacoes.telefone2;
       email_adicional.text = informacoes.emailAdicional;
     }else{
       Alert.show("Selecione um item da tablea para alterar.");
     }
   }

   public function list():void{
     this.projectController.list(resultList);
   }

   public function resultList(event:ResultEvent):void{
     table.dataProvider = event.result as Array;
   }

   public function resultSave(event:ResultEvent):void{
     Alert.show("Item salvo com sucesso.");
     list();
     clear();
   }

   public function resultDelete(event:ResultEvent):void{
     Alert.show("Item excluído com sucesso.");
     list();
   }

   public function clear():void{
     nome_pessoa.text = "";
     email_pessoa.text = "";
     telefone_1.text = "";
     telefone_2.text = "";
     email_adicional.text = "";

     informacoes = null;
   }
 ]]>
 </fx:Script>
 <fx:Declarations>
 <!-- Place non-visual elements (e.g., services, value objects) here -->
 </fx:Declarations>

  <s:Label x="64" y="96" text="E-mail:"/>
  <s:Label x="41" y="126" text="Telefone 1:"/>
  <s:Label x="41" y="156" text="Telefone 2:"/>
  <s:Label x="10" y="186" text="E-mail Adicional:"/>
  <s:TextInput id="nome_pessoa" x="118" y="56" width="280" maxChars="255"/>
  <s:TextInput id="email_pessoa" x="118" y="86" width="280" maxChars="255"/>
  <s:TextInput id="telefone_1" x="118" y="116" width="280" maxChars="50"/>
  <s:TextInput id="telefone_2" x="118" y="146" width="280" maxChars="50"/>
  <s:TextInput id="email_adicional" x="118" y="176" width="280" maxChars="255"/>
  <mx:DataGrid id="table" x="10" y="261" width="506" height="206">
    <mx:columns>
      <mx:DataGridColumn headerText="Id Pessoa" dataField="pessoa.id"/>
      <mx:DataGridColumn headerText="Nome" dataField="pessoa.nome"/>
      <mx:DataGridColumn headerText="E-mail" dataField="pessoa.email"/>
    </mx:columns>
  </mx:DataGrid>
  <s:Button x="321" y="206" label="Salvar" click="save()"/>
  <s:Button x="188" y="475" label="Excluir" click="deleteObject()"/>
  <s:Button x="266" y="475" label="Alterar" click="setDataToEdit()"/>
  <s:Label x="65" y="66" text="Nome:"/>
  <s:Label x="111" y="64" text="*" fontSize="16" fontFamily="Arial" fontWeight="bold" color="#FF0000"/>
  <s:Label x="111" y="95" text="*" fontSize="16" fontFamily="Arial" fontWeight="bold" color="#FF0000"/>
</s:Application>

No inicio do arquivo é declarado uma tag MXML de script esta tag representa o código de script da aplicação. Em seguida dois objetos são criados o primeiro é referente à classe que realiza as requisições ao PHP e a segunda representa o objeto que contêm os atributos referentes aos atributos das classes de referencia no lado PHP do projeto.

Descrevendo os métodos criados aqui:

Método save: Realiza a verificação se os campos nome e email foram preenchidos, pois são campos obrigatórios na tabela do banco de dados, portanto não podem ser vazios. Neste tutorial eu não abordo a validação de campos como, por exemplo, o campo E-mail, mas existem métodos para realizar estas validações no Flex, e abordarei estes métodos em outra ocasião.

Método deleteObject: este método é responsável por enviar para o PHP o objeto que deverá ser excluído do banco de dados.

Método setDataToEdit: criei este método para adicionar os valores nos campos do formulário quando o usuário selecionar um valor da tabela e clicar no botão alterar.

Método list: requisita ao PHP a lista de objetos para popular o componente DataGrid no lado cliente.

Métodos resultList, resultSave e resultDelete: estes métodos são responsáveis por receber a resposta do servidor quando requisitam algo para o mesmo. Estes métodos de retorno são informados quando é realizada alguma operação que requisitará algo para o PHP, por exemplo, no método list(), é utilizado a seguinte operação, this.projectController.list(resultList); esta operação que utiliza o objeto que é referencia da classe que realiza as requisições ao PHP solicita a listagem de objetos e como parâmetro passa o método que receberá a resposta da requisição.

Método clear: limpa os campos do formulário após realizar uma operação de salvar ou alterar um objeto.

Outros detalhes que podemos destacar sobre a alteração deste arquivo são:

No topo do documento na tag Application foi adicionada uma função chamada creationComplete passando como valor a função list. Esta função será chamada assim que o documento carregar requisitando a lista de objetos para o PHP que irão popular o DataGrid ao iniciar a aplicação.

Foram adicionados labels com asteriscos para representar campos obrigatórios do formulário, bem como no DataGrid ou tabela do sistema foram adicionados as colunas da mesma os valores que deverão aparecer no campo dataField, sempre que um valor é necessário ser visualizado na coluna da tabela é este campo que deve ser preenchido. Como pode ser visto o valor aqui abordado são os atributos do objeto pessoa.

Explicarei melhor como funciona. Ao adicionar uma lista de objetos ao DataGrid através do método dataPovider, como é abordado no método deste arquivo o resultList, o componente faz a tarefa de listar os objetos e quando ele realiza a leitura dos atributos deste objeto verifica então se os mesmos batem com o atributo declarado em algum campo dataField das colunas da tabela assim mostrando o valor solicitado.

Portanto ao realizar este processo o mesmo encontra no objeto Informacao a declaração de referencia ao objeto pessoa e assim tem acesso aos atributos do objeto e estes atributos serão mostrados na tabela quando for preenchida.

Desta forma utilizamos o relacionamento entre as classes manipulando o objeto Informacao e Pessoa ao mesmo tempo.

E por fim nas tags Button foram adicionadas a função click com o método referente ao botão para realizar as funções necessárias à aplicação.

Ao terminar esse processo de desenvolvimento já pode ser testada a aplicação, se tudo ocorreu corretamente é possível salvar, alterar, excluir dados no banco de dados bem como listá-los.

Acesse o navegador e verifique como ficou a aplicação. A imagem a seguir mostra o resultado deste tutorial.

Agradeço por ler este tutorial e espero que tenha gostado do conteúdo aqui proposto, espero poder abordar mais sobre essa área de desenvolvimento de sistemas com Flex e PHP já que tem tomado maior parte do meu tempo a prática de desenvolvimento com estas ferramentas e também estou estudando outros métodos de utilizar as mesmas no desenvolvimento de software.

Novamente muito obrigado por acompanhar o tutorial e segue o link para download da aplicação deste tutorial.

Link para download do código do tutorial: http://www.megaupload.com/?d=65EPBJC9

Neste post para finalizar o sistema que estamos desenvolvendo, será explicado como aplicar a comunicação entre o Flex e o Zend Framework, como realizar as quatro operações básicas de um sistema, ou seja, a criação de um CRUD usando Doctrine e também serão explicados alguns detalhes referentes ao projeto que necessitam de um pouco de atenção ao realizar o desenvolvimento com estas ferramentas.

Para quem não acompanhou os post anteriores a seguir está os links referentes à parte 1 e 2 do tutorial. Então vamos lá mãos à obra.

Primeira parte do tutorial:  http://tiagozis.wordpress.com/2010/07/12/flex-zend-framework-doctrine/

Segunda parte do tutorial: http://tiagozis.wordpress.com/2010/08/24/integracao-flex-zend-framework-doctrine-parte-2/

Primeiramente vou explicar o que foi criado no projeto na parte Flex que não foi implementado anteriormente, no código a seguir pode ser visto que algumas functions foram adicionadas ao projeto explicarei na seqüência cada uma delas.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" creationComplete="init()">
  <mx:Script>
   <![CDATA[
     import mx.controls.HorizontalList;
     import models.Reserva;
     import models.HotelQuarto;
     import mx.collections.IList;
     import models.Hospede;
     import mx.collections.ArrayCollection;
     import models.Hotel;
     import mx.controls.Alert;
     import mx.rpc.events.ResultEvent;
     import controller.RemoteObjectController;

     private var reserva:Reserva;
     private var hotelQuarto:HotelQuarto;
     [Bindable]
     private var arrayQuartos:Array;

     public function init():void{
       listAll();
     }

     public function resultListHotel(e:ResultEvent):void{
       var array:Array = new Array("Selecione");
       var ht:Array = e.result as Array;
       var index:int = 0;

       for each(var hotel:Hotel in ht){
         if(hotelQuarto != null && hotelQuarto.codHotel == hotel.codHotel){
           index = ht.indexOf(hotel)+1;
         }
         array.push(hotel);
       }
       comboHotel.dataProvider =  array;
       comboHotel.selectedIndex = index;
     }

     public function resultListHospede(e:ResultEvent):void{
       var array:Array = new Array("Selecione");
       var ho:Array = e.result as Array;
       var index:int = 0;

       for each(var hospede:Hospede in ho){
         if(reserva != null && reserva.codHospede == hospede.codHospede){
           index =  ho.indexOf(hospede)+1;
         }
         array.push(hospede);
       }

       comboHospede.dataProvider =  array;
       comboHospede.selectedIndex = index;
     }

     public function resultListHotelQuarto(e:ResultEvent = null):void{
       var array:Array = new Array("Selecione");
       var index:int = 0;
       if(e != null){
         var quartos:Array = e.result as Array;
         for each(var hotelQuarto:HotelQuarto in quartos){
           if(!hotelQuarto.sitQuarto){
             array.push(hotelQuarto);
           }
           if(reserva != null && reserva.numQuarto == hotelQuarto.numQuarto){
             index = quartos.indexOf(hotelQuarto)+1;
           }
         }
       }
       comboQuarto.dataProvider = array;
       comboQuarto.selectedIndex = index;
     }

     public function resultRetrieveHotelQuarto(e:ResultEvent):void{
       hotelQuarto = e.result as HotelQuarto;
       var remote:RemoteObjectController = new RemoteObjectController("HotelService");
       remote.setResultFunction(resultListHotel);
       remote.getOperation("executeList").send();

       var remote1:RemoteObjectController = new RemoteObjectController("HospedeService");
       remote1.setResultFunction(resultListHospede);
       remote1.getOperation("executeList").send();

       var remote3:RemoteObjectController = new RemoteObjectController("HotelQuartoService");
       remote3.setResultFunction(resultListHotelQuarto);
       remote3.getOperation("executeList").send(hotelQuarto.codHotel);
     }

     public function resultListReserva(e:ResultEvent):void{
       tableReserva.dataProvider = e.result as Array;
     }

     public function getQuartos():void{
       if(comboHotel.selectedIndex > 0){
         var hotel:Hotel = comboHotel.selectedItem as Hotel;
         var remote:RemoteObjectController = new RemoteObjectController("HotelQuartoService");
         remote.setResultFunction(resultListHotelQuarto);
         remote.getOperation("executeList").send(hotel);
       }else{
         comboQuarto.dataProvider = "Selecione";
       }
     }

     public function save():void{
        var go:Boolean = true;

        if(comboHospede.selectedIndex <= 0){
          comboHospede.errorString = "Campo obrigatório";
          go = false;
        }else{
          comboHospede.errorString = "";
        }

        if(comboQuarto.selectedIndex <= 0){
          comboQuarto.errorString = "Campo obrigatório";
          go = false;
        }else{
          comboQuarto.errorString = "";
        }

        if(comboHotel.selectedIndex <= 0){
          comboHotel.errorString = "Campo obrigatório";
          go = false;
        }else{
          comboHotel.errorString = "";
        }

        if(data.text == ""){
          data.errorString = "Campo obrigatório";
          go = false;
        }else{
          data.errorString = "";
        }

        if(dias.text == ""){
          dias.errorString = "Campo obrigatório";
          go = false;
        }else{
          dias.errorString = "";
        }

        if(go){
          if(reserva == null){
            var remote:RemoteObjectController = new RemoteObjectController("ReservaService");
            remote.setResultFunction(resultSave);
            remote.getOperation("executeSave").send(getData());
          }else{
            this.edit();
          }
        }
      }

      public function edit():void{
        if(tableReserva.selectedItem != null){
          var remote:RemoteObjectController = new RemoteObjectController("ReservaService");
          remote.setResultFunction(resultEdit);
          remote.getOperation("executeUpdate").send(getData(reserva));
        }else{
          Alert.show("Selecione um item da tabela para excluir");
        }
      }

      public function _delete():void{
        if(tableReserva.selectedItem != null){
          var remote:RemoteObjectController = new RemoteObjectController("ReservaService");
          remote.setResultFunction(resultDelete);
          remote.getOperation("executeDelete").send(tableReserva.selectedItem as Reserva);
        }else{
          Alert.show("Selecione um item da tabela para excluir");
        }
      }

      public function getData(r:Reserva = null):Reserva{
        if(r == null){
          r = new Reserva();
        }

        r.codHospede = (comboHospede.selectedItem as Hospede).codHospede;
        var c:HotelQuarto =  comboQuarto.selectedItem as HotelQuarto;
        r.codHotelQuarto = c.codHotelQuarto;
        r.numQuarto = (comboQuarto.selectedItem as HotelQuarto).numQuarto;
        r.datReserva = data.text;
        r.qtdDias = parseInt(dias.text);
        r.sitReserva = true;
        return r;
      }

      public function resultDelete(e:ResultEvent):void{
        if(e.result){
          Alert.show("Reserva excluído com sucesso.");
          listAll();
        }
      }

      public function resultEdit(e:ResultEvent):void{
        if(e.result){
          Alert.show("Reserva alterada com sucesso.");
          listAll();
        }else{
          Alert.show("Ocorreu um erro ao realizar a operação.");
        }
      }

      public function resultSave(e:ResultEvent):void{
        if(e.result != null){
          Alert.show("Reserva salva com sucesso.");
          listAll();
        }
      }

      public function listAll():void{

        data.text = "";
        dias.text = "";
        reserva = null;
        hotelQuarto = null;

        var remote:RemoteObjectController = new RemoteObjectController("HotelService");
        remote.setResultFunction(resultListHotel);
        remote.getOperation("executeList").send();

        var remote1:RemoteObjectController = new RemoteObjectController("HospedeService");
        remote1.setResultFunction(resultListHospede);
        remote1.getOperation("executeList").send();

        var remote2:RemoteObjectController = new RemoteObjectController("ReservaService");
        remote2.setResultFunction(resultListReserva);
        remote2.getOperation("executeList").send();

        resultListHotelQuarto();
      }

      public function setDataToEdit():void{
        if(tableReserva.selectedItem != null){
          reserva = tableReserva.selectedItem as Reserva;
          var remote2:RemoteObjectController = new RemoteObjectController("HotelQuartoService");
          remote2.setResultFunction(resultRetrieveHotelQuarto);
          remote2.getOperation("executeRetrieve").send(reserva.codHotelQuarto);

          data.text = reserva.datReserva;
          dias.text = reserva.qtdDias.toString();
        }else{
          Alert.show("Selecione um item da tabela para excluir");
        }
      }
 ]]>
 </mx:Script>
   <mx:DataGrid x="10" y="210" width="669" height="145" id="tableReserva">
     <mx:columns>
       <mx:DataGridColumn headerText="Nome Hospede" dataField="nomHospede"/>
       <mx:DataGridColumn headerText="Data Reserva" dataField="datReserva"/>
       <mx:DataGridColumn headerText="Quantidade de dias" dataField="qtdDias"/>
       <mx:DataGridColumn headerText="Hotel" dataField="nomHotel"/>
       <mx:DataGridColumn headerText="Nº Quarto" dataField="numQuarto"/>
     </mx:columns>
   </mx:DataGrid>
   <mx:Label x="10" y="12" text="Hotel:"/>
   <mx:ComboBox x="138" y="10" width="230" id="comboHotel" labelField="nomHotel" change="getQuartos()"></mx:ComboBox>

   <mx:Label x="10" y="42" text="Quarto:"/>
   <mx:ComboBox x="138" y="40" width="230" id="comboQuarto" labelField="numQuarto"></mx:ComboBox>

   <mx:Label x="10" y="72" text="Hospede:"/>
   <mx:ComboBox x="138" y="70" width="230" id="comboHospede" labelField="nomHospede"></mx:ComboBox>

   <mx:Label x="10" y="102" text="Data Reserva:"/>
   <mx:DateField x="138" y="100" width="230" id="data" formatString="DD/MM/YYYY"/>

   <mx:Label x="10" y="132" text="Quantidade de dias:"/>
   <mx:TextInput x="138" y="130" width="230" restrict="[0-9]" id="dias"/>

   <mx:Button x="296" y="160" label="Salvar" width="72" click="save()"/>
   <mx:Button x="255" y="363" label="Alterar" width="72" click="setDataToEdit()"/>
   <mx:Button x="335" y="363" label="Excluir" width="72" click="_delete()"/>
</mx:Application>

Abaixo a descrição de cada “function” do projeto.

1 – Função ( init ), será chamada quando o sistema for carregado. Dentro desta função encontra-se a chamada para outra função que realiza as listagens para o sistema.

2 – Função ( resultListHotel ), esta função recebe o resultado que retorna do service apos ser requisitado a listagem de hotéis, seu retorno que neste caso é o parâmetro entre os parênteses contêm um array com os hotéis que foram listados. O laço criado na função serve para verificar se o código do hotel da listagem é igual ao código do hotel da reserva, este caso é abordado quando for necessário realizar a alteração dos dados da reserva, colocando assim o nome do hotel no index correto do combobox.

3 – Função ( resultListHospede ), realiza as mesmas funcionalidades da função anterior só que agora para os dados referentes ao hospede.

4 – Função ( resultListHotelQuarto ), este realiza as mesmas funcionalidades das anteriores, porem existe uma verificação à mais no seu laço que verifica qual a condição do quarto, se está reservado ou não, caso o quarto esteja reservado não o adiciona no combobox.

5 – Função ( resultRetrieveHotelQuarto ), recebe o valor retornado da chamada ao service que retorna o objeto “HotelQuarto”, este objeto é solicitado pelo sistema quando é necessário alterar a reserva. Apos receber o objeto é realizado a chamada das listagens novamente, e com os dados referentes à reserva será posicionada o valor correspondente nos campos para que seja realizada a alteração.

6 – Função ( resultListReserva ), apenas recebe um array que retorna do service, este array contêm todas as reservas cadastradas no banco de dados. Apos receber os valores adiciona os mesmos ao “dataprovider” da tabela.

7 – Função ( getQuartos ), cada vez que o usuário escolher um hotel no combobox do sistema esta ação é acionada e requisita ao service uma lista de quartos cadastrados para aquele hotel selecionado.

8 – Função ( save ), ao clicar no botão para salvar esta função é chamada e então é realizado anteriormente uma verificação se todos os campos foram preenchidos corretamente. Caso todos os campos estiverem de acordo com o necessário então é requisitada a funcionalidade para salvar o objeto no banco, enviando os dados para o service correspondente que realiza esta funcionalidade. Outra informação que podemos destacar desta função é que antes mesmo de enviar um objeto para ser salvo é verificado se o mesmo é nulo, caso seja então um novo objeto é criado e salvo, caso contrário o objeto tem a necessidade de ser editado então outra função é acionada para realizar esta tarefa.

9 – Função ( edit ), quando o usuário salvar um objeto editado será esta função chamada para realizar a tarefa.

10 – Função ( _delete ), esta função é acionada quando o usuário seleciona uma reserva que está listada na tabela e clica no botão para excluir o objeto.

11 – Função ( getData ), função chamada ao salvar ou alterar uma reserva, adiciona ao objeto reserva os dados dos campos de cadastro, apos adicionar todos os dados referentes à reserva retorna o objeto para realizar a operação de salvar ou alterar.

12 – Função ( resultDelete ), recebe o resultado de exclusão do objeto e mostra a mensagem de sucesso.

13 – Função ( resultEdit ), recebe o resultado da alteração do objeto e mostra a mensagem de sucesso.

14 – Função ( resultSave ), recebe o resultado da criação do objeto e mostra a mensagem de sucesso.

15 – Função ( listAll ), funcionalidade do sistema que requisita aos services na parte Zend do projeto todas as listagens necessárias, listagem de hotéis, hospedes e reserva.

16 – Função ( setDataToEdit ), quando o usuário seleciona uma reserva na tabela e clica no botão para alterar esta reserva, esta função é acionada adicionando os dados da reserva nos campos para que possa ser realizada a alteração dos mesmos.

Aqui está detalhado cara funcionalidade do sistema na parte Flex do projeto mas ainda existe um detalhe importante para ser explicado. Qual é o método que faz as chamadas aos services para realizar as tarefas de listar, salvar, alterar e excluir?

Conforme explicado na segunda parte deste tutorial foi criado uma classe que extende a classe ( RemoteObject ), e é esta classe que realiza a função de chamar o servidor e realizar a função desejada. Mas como isto é feito?

Verifique o código a seguir.

 var remote:RemoteObjectController = new RemoteObjectController("HotelService");
 remote.setResultFunction(resultListHotel);
 remote.getOperation("executeList").send();

Uma instancia da classe de requisições criada para o projeto é declarada, passando como valor inicial de seu construtor o service que será chamado quando a requisição for enviada. Em seguida com o objeto já criado é necessário setar para o mesmo qual a função ou método receberá o retorno da requisição, no caso do exemplo descrito o retorno é a função que recebe a lista de hotéis. Por ultimo é chamado a operação que envia a requisição para o servidor passando qual método do service deve ser chamado para realizar a operação desejada, podemos verificar que o método ( send ) desta parte do código está vazio, isto acontece pois não é necessário passar nenhum parâmetro para realizar esta operação, no entanto caso o service declarado lá no Zend tenha algum parâmetro declarado então o parâmetro deve ser adicionado ao ( send ) para que o mesmo seja enviado junto da requisição.

Esta desta forma que as operações da parte Flex do projeto são realizadas, lógico que existem outras metodologias para realizar esta tarefa, porem eu abordei esta forma para que não fique tão complicado o entendimento desta funcionalidade do projeto.

Antes de passar para a explicação das alterações realizadas no Zend Framework gostaria de mostrar uma alteração que realizei em uma das classes que representam a classe do lado Zend, verifique o código a seguir.

package models
{
  [Bindable]
  [RemoteClass(alias="Reserva")]

  public class Reserva
  {

    public var codReserva:int;
    public var codHotelQuarto:int;
    public var numQuarto:int;
    public var codHospede:int;
    public var datReserva:String;
    public var qtdDias:int;
    public var sitReserva:Boolean;

    public var nomHospede:String;
    public var nomHotel:String;
  }
}

Conforme explicado no post anterior é necessário que os atributos das classes que representam o objeto tanto no php quanto no actionscript tem a necessidade de ter os mesmos atributos. Então eu adicionei dois atributos novos à classe “Reserva”, estes dois atributos adicionais serão utilizados para que possa visualizar o nome do hospede e do hotel na tabela de listagem de reservas. Na programação orientada a objetos não seria melhor método a aplicar, pois instancias dos objetos hospedes e hotel deveriam ser aplicados a esta classe.

Mas explicando o motivo desta abordagem. Em casos como o abordado aqui poderia ser utilizado a instancia de objetos na classe, mas em casos onde se trabalha com uma grande quantidade de dados, criar instancias tantos objetos pode se tornar um esforço computacional desnecessário, inclusive neste caso onde era necessário apenas os nomes para mostrar na tabela. Por este motivo abordei este método para o projeto, a forma correta de aplicar fica a sua escolha.

Agora vamos ver como realizar as tarefas do projeto no Zend Framework, até agora foi abordado como montar a tela do projeto no Flex, como requisitar os serviços para o servidor e como utilizar o retorno dos mesmos. Veremos como fica o código que realiza as tarefas solicitadas, como por exemplo, criar uma listagem, salvar um objeto, excluir um objeto, obter apenas um objeto em especifico e até alterá-lo.

No post anterior quando foi criado um service para cada classe de modelo gerada pelo Doctrine foi mostrado três métodos básicos para o mesmo, estes métodos não serão utilizados por todos os services, pois não estou abordando todo o projeto, porem fica como sugestão caso queira implementar todo o projeto em seu treinamento a seguir mostrarei apenas os métodos utilizados dos services que são requisitados e abordarei mais o service referente a reserva que é o objetivo principal deste tutorial.

Services “HospedeService” e “HotelService”. Nestes dois services o único método implementado foi o “executeList”.

 public function executeList(){
   $list = HospedeTable::getInstance();
   return $list->findAll()->getData();
 }

Como pode ser visto anteriormente três classes de modelo foram criadas ao gerar o comando de criação com o Doctrine, a primeira é a classe base que contêm os atributos referentes às tabelas do banco de dados, a segunda a classe a ser utilizada no projeto e que deve ser instanciada quando necessário esta classe estende a classe base e por ultimo a classe table. As classes table como a “HospedeTable” estendem a classe “Doctrine_Table”, esta classe é responsável por realizar algumas consultas sql, como por exemplo o código anterior.

No código pode ser verificado que uma instancia da classe “HospedeTable” é adicionado, e ao chamarmos o método da classe instanciada, ( findAll() ) o Doctrine solicitará ao banco de dados todos os registros da tabela hospede, é como realizar um comando de Sql no banco de dados “SELECT * FROM hospede”, mas com a vantagem de ter as informações já em forma de objetos e não apenas registros em um array. Porem é necessário deixar claro que este método retorna um objeto da classe “HospedeTable” e não os objetos “Hospede” como desejamos. Por isso é chamado outro método da classe, o ( getData() ), este método retorna um array que contêm todos os registros da tabela hospede em forma de objetos “Hospede”, e assim podendo retornar a requisição para o Flex com uma lista de todos os objetos.

Para realizar a listagem de hotéis o mesmo método pode ser utilizado apenas deve-se instanciar o objeto “HotelTable”.

Service “HotelQuartoService”. Este service é provido de um método de listagem diferente do descrito anteriormente a diferença fica no parâmetro passado pelo Flex ao requisitar o método deste service e o método de listagem de objetos realiza a busca comparando um determinado valor.

 public function executeList($hotel){
   $cod = 0;
   if($hotel instanceof Hotel){
     $cod = $hotel->codHotel;
   }else{
     $cod = $hotel;
   }

   $list = HotelQuartoTable::getInstance();
   return $list->findBy('cod_hotel', $cod)->getData();
 }

Um parâmetro é passado para este método porem sem definição alguma, então dentro do método é realizado a verificação se o valor recebido é uma instancia do objeto Hotel, caso seja adiciona o código do hotel ao atributo “$cod” do método caso contrário o valor passado é apenas o código mesmo. Este atributo que recebe o código do hotel será utilizado como parâmetro de comparação para realizar a consulta de listagem da tabela “hotel_quarto”. Apos instanciar a classe referente à tabela desejada o método utilizado é o ( findBy() ), este método busca as informações necessárias adicionando um valor de comparação à consulta que neste caso é o código do hotel, seria o mesmo que realizar o seguinte comando Sql “SELECT * FROM hotel_quarto WHERE cod_hotel = 1″. Desta forma todos os registros da tabela “hotel_quarto” que o código do hotel é igual a 1 é obtido. E da mesma forma que as listagens anteriores utiliza-se do método ( getData() ) para obter apenas os objetos referentes a tabela aqui citada.

Outro método utilizado deste service é o ( executeRetrieve ), este método ao ser solicitado retorna apena um registro da tabela “hotel_quarto”, e recebe como parâmetro o código do registro que se deseja buscar.

 public function executeRetrieve($cod_hotel_quarto){
   $hq = HotelQuartoTable::getInstance();
   return $hq->findOneBy('cod_hotel_quarto', $cod_hotel_quarto);
 }

Aqui o método utilizado da classe “HotelQuartoTable” é o ( findOneBy () ), este método quando chamado obtêm o primeiro registro encontrado aplicando a clausula passada como parâmetro. Com este método encontramos o registro que necessário conforme a regra no projeto.

Service “QuartoService”. Neste service nenhuma ação foi aplicada, portanto não há a necessidade de abordarmos aqui.

Service “ReservaService”. Este service é o solicitado para realizar a maioria das funcionalidades referentes ao projeto abordado. Neste service é realizada a listagem, alteração, exclusão e criação de reservas. Vejam o código a seguir.

class ReservaService {

  public function executeSave(Reserva $object){
    $itemToSave = new Reserva();

    $itemToSave->codHotelQuarto = $object->codHotelQuarto;
    $itemToSave->numQuarto = $object->numQuarto;
    $itemToSave->codHospede = $object->codHospede;
    $itemToSave->datReserva = $object->datReserva;
    $itemToSave->qtdDias = $object->qtdDias;
    $itemToSave->sitReserva = $object->sitReserva;
    $itemToSave->save();

    return $itemToSave;
  }

  public function executeDelete(Reserva $object){
    $q = Doctrine_Query::create()->delete('Reserva')->whereIn('cod_reserva', $object->codReserva);
    $delete = $q->execute();

    if($delete > 0){
      return  true;
    }else{
      return  false;
    }
  }

  public function executeList(){
    $reservas =  ReservaTable::getInstance();
    $list = $reservas->findAll()->GetData();
    $l = array();
    foreach($list as $reserva){
      $reserva->datReserva = $this->dataDbToSystem($reserva->datReserva);
      $reserva->addData();
      $l[] = $reserva;
    }
    return  $l;
  }

  public function executeUpdate(Reserva $reserva){
    try {
      $q = Doctrine_Query::create()->update('Reserva')
        ->set('cod_hotel_quarto', $reserva->codHotelQuarto)
        ->set('num_quarto', $reserva->numQuarto)
        ->set('cod_hospede', $reserva->codHospede)
        ->set('dat_reserva ', '?', $reserva->datReserva)
        ->set('qtd_dias', $reserva->qtdDias)
        ->set('sit_reserva', $reserva->sitReserva == 1 ? 'true' : 'false')
        ->where('cod_reserva = '.$reserva->codReserva);

      $q->execute();
    } catch (Exception $e) {
       return false;
    }

    return true;
  }

  public function dataSystemToDb($data){
    $dt = spliti("/", $data);
    return $dt[2]."-".$dt[1]."-".$dt[0];
  }

  public function dataDbToSystem($data){
    $t = spliti(" ", $data);
    $dt = spliti("-", $t[0]);
    return $dt[2]."/".$dt[1]."/".$dt[0];
  }
}

Explicarei cada método desta classe.

Método “executeSave”, este método salva um novo objeto no banco de dados na tabela “reserva”. Recebe como parâmetro um objeto do tipo “Reserva” enviado pelo Flex ao realizar a requisição. Em seguida cria-se um novo objeto para receber os dados que serão salvos e finalmente executa a operação para salvar o objeto chamando o método ( save() ) da classe reserva. Uma observação aqui deve ser avaliada.

Por que não salvar direto o objeto passado por parâmetro?

Diferente do php os atributos do actionscript são tipados e quando um objeto é enviado ao service o mesmo chegará com todos os atributos com algum valor, o objeto reserva tem um atributo que é o código da reserva e este atributo é do tipo integer, portanto não tem como salvar com valor zero que é o valor default para atributos do tipo int no Flex, o objeto que vem por parâmetro no método já vem com o atributo “codReserva” atribuído o valor zero, isto por ser um tipo primitivo no actionscript que obriga ter um valor atribuído nem que este valor seja o zero. Em outros atributos como o tipo “string” o valor seria “null” e não haveria problema algum, claro isso dependendo da regra criada para o campo no banco de dados.

Por este motivo é criado um novo objeto e adicionado ao mesmo os valores correspondentes e em seguida é chamado o método ( save() ) deste objeto que realizará a tarefa de inserir os valores na tabela “reserva” no banco de dados.

Método “executeDelete”, realiza a exclusão do objeto na tabela “reserva” no banco de dados. O método que foi abordado aqui para excluir um objeto é meio primitivo, ele parece muito com um Sql normal pois a instancia do objeto cria uma conexão com o banco de dados e através de métodos parecidos com comandos de Sql geram o comando para realizar a exclusão do objeto. No Doctrine é possível também excluir um objeto com o próprio método ( delete() ) da classe do mesmo, por exemplo, “$object->delete()”, porem não consegui aplicar esta abordagem aqui, pois simplesmente este método não funcionou e não encontrei solução pelo menos até o momento que escrevo este post.

Método “executeList”, este método tem a mesma funcionalidade dos métodos de listagem já explicados anteriormente, apenas com uma pequena diferença, apos receber a lista de reserva percorro todo o array de objetos formatando a data que vem do banco de dados para o formato utilizado no sistema, para esta atividade criei uma função que realiza esta conversão ( dataDbToSystem ) passando como parâmetro o valor da data do banco de dados. E no mesmo laço chamo um método que criei para a classe “Reserva” ( addData() ), este método que explicarei a sua funcionalidade mais adiante adiciona dois valores á mais no objeto “Reserva”.

Método “executeUpdate”, tem como finalidade alterar o objeto no banco de dados, como no método “executeSave” ele recebe como parâmetro um objeto “Reserva”, enviado pelo Flex com os dados para serem alterados, e neste também abordei um método primitivo para realizar esta operação bem como aconteceu na no método de exclusão. E pelo mesmo motivo o método da classe que deveria realizar esta tarefa não funcionou, apenas para esclarecer o método que realiza a função de alterar o objeto é o mesmo utilizado para criar, ( save() ), este método consegue diferenciar quando é necessário salvar ou alterar um objeto através do “id” do mesmo. Neste caso o código da reserva, explico, quando o método é chamado se o objeto tiver o “id”, ou seja, o código da reserva nula o mesmo identifica que é necessário criar um  novo registro na tabela reserva no banco de dados, caso o código tenha algum valor atribuído como por exemplo 2 ele identifica que é necessário alterar o registro da tabela quando o código for igual a 2. Porem como disse não conseguiu fazer com que esta funcionalidade funcionasse no caso aqui abordado.

E por fim os outros dois métodos “dateSystemToDb” e “dateDbToSystem” foram usados para converter a data do banco para o sistema e do sistema para o banco de dados.

Anteriormente falei sobre a adição de dois atributos na classe “Reserva” do lado Flex da aplicação, como já devem saber para ter acesso aos atributos é necessário adicionar os mesmos para a classe representante do lado do php neste caso do Zend, então os dois atributos serão adicionados à classe.

  public $nomHospede;
  public $nomHotel;

Também como citado anteriormente um método novo foi adicionado para esta classe.

Existe um motivo interessante para adicionar este método à classe. Como já explicado neste tutorial a comunicação entre as o Flex e o Zend Framework ocorre através do ZendAmf e o mesmo converte os dados de um para o outro através dos atributos declarados nas classes que aqui chamou-se de classes de modelo. Porem no caso aqui abordado devido a abstração dos objetos criados pela ferramenta Doctrine quando chamamos uma classe como a “Reserva” a mesma não contêm apenas os atributos que representam a tabela do banco de dados e sim toda uma classe com as funcionalidades necessárias para realizar diversas tarefas. Com esta abstração os dados dos atributos ficam encapsulados em um array chamado “$_data” e somente os dados que estão dentro deste array é que serão enviados do Zend para o Flex e recebidos do Flex pelo Zend. Por este motivo os atributos adicionais não serão reconhecidos quando a requisição retornar para o Flex e os dados retornados para os mesmos serão nulos. Por isso criei o método ( addData() ), que insere dentro do array de dados os atributos adicionais “$nomHospede” e “$nomHotel”, para que os mesmos sejam reconhecidos como atributos da classe na parte Flex do projeto. A seguir como ficou a criação deste método.

 public function addData(){
   $this->setNomHospede();
   $this->setNomeHotel();
   $this->_data['nomHospede'] = $this->getNomHospede();
   $this->_data['nomHotel'] = $this->getNomHotel();
 }

Este método que abordei aqui talvez não seja o correto a ser aplicado, apesar das pesquisas que realizei sobre este problema como podemos chamá-lo, não encontrei outra solução para o “problema” se é que pode ser considerado como sendo realmente um problema. Mas agora adotando este método não será necessário nos preocuparmos se terá ou não acesso aos dados adicionais do projeto.

Alem de adicionar o método que insere os novos atributos no array ( $_data ), foi criado os métodos set e get dos atributos adicionais, no método set de cada atributo foi adicionado uma verificação, caso não seja passado nenhum valor por parâmetro é realizado uma consulta para obter o valor do atributo correspondente. A classe com os novos métodos que foram adicionados pode ser visualizada no código abaixo.

<?php

/**
 * Reserva
 *
 * This class has been auto-generated by the Doctrine ORM Framework
 *
 * @property integer $codReserva
 * @property integer $codHotelQuarto
 * @property integer $numQuarto
 * @property integer $codHospede
 * @property timestamp $datReserva
 * @property integer $qtdDias
 * @property boolean $sitReserva
 *
 * @package    ##PACKAGE##
 * @subpackage ##SUBPACKAGE##
 * @author     ##NAME## <##EMAIL##>
 * @version    SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
 */
class Reserva extends Base_Reserva
{

  public $_explicitType = "Reserva";
  public $nomHospede;
  public $nomHotel;

  public function setTableDefinition(){
    parent::setTableDefinition();
    $this->hasColumn('cod_reserva as codReserva');
    $this->hasColumn('cod_hotel_quarto as codHotelQuarto');
    $this->hasColumn('num_quarto as numQuarto');
    $this->hasColumn('cod_hospede as codHospede');
    $this->hasColumn('dat_reserva as datReserva');
    $this->hasColumn('qtd_dias as qtdDias');
    $this->hasColumn('sit_reserva as sitReserva');
  }

  public function addData(){
    $this->setNomHospede();
    $this->setNomeHotel();
    $this->_data['nomHospede'] = $this->getNomHospede();
    $this->_data['nomHotel'] = $this->getNomHotel();
  }

  public function setNomHospede($value = null){
    if(is_null($value)){
      $n = HospedeTable::getInstance();
      $value = $n->findOneBy('cod_hospede', $this->codHospede);
      $this->nomHospede = $value->nomHospede;
    }else{
      $this->nomHospede = $value;
    }
  }

  public function getNomHospede(){
    return $this->nomHospede;
  }

  public function setNomeHotel($value = null){
    if(is_null($value)){
      $q = Doctrine_Query::create()
       ->select('q.nom_hotel, h.cod_hotel_quarto')
       ->from('Hotel q')
       ->leftJoin('q.HotelQuarto h on h.cod_hotel = q.cod_hotel')
       ->where('h.cod_hotel_quarto = '.$this->codHotelQuarto);
      $result = $q->execute();
      $v = $result->getData();
      $this->nomHotel = $v[0]->nomHotel;
    }else{
      $this->nomHotel = $value;
    }
  }

  public function getNomHotel(){
    return $this->nomHotel;
  }

}

Apos realizar todo este processo para a criação do projeto o sistema pode ser utilizado executando as operações básicas, salvar, alterar, obter e excluir um objeto, no caso aqui abordado a reserva. A seguir pode a imagem com a cara do sistema criado até agora.

Como pode ser visto todos os campos que representam os dados da reserva está na parte superior da tela, o botão salvar pode ser utilizado tanto na criação de uma nova reserva como para a alteração de uma já existente, em seguida a tabela listando as reservas já cadastradas. Ao selecionar uma reserva na tabela e clicar no botão alterar o objeto será carregando nos campos superiores com cada valor no local correto para que possa ser realizada a alteração do mesmo, e para excluir uma reserva basta apenas selecionar uma na tabela e clicar no botão excluir.

Bom aqui termina o exemplo deste tutorial sobre a integração das ferramentas Flez, Zend Framework e Doctrine. Espero que tenha ficado mais claro como integrar e utilizar estas ferramentas. E como falei muito durante o tutorial os métodos aqui utilizados foram desenvolvidos seguindo uma linha de raciocínio para a aplicação, mas nada impede de ser criado ou adaptado utilizando outros métodos.

Pessoal qualquer dúvida ou sugestão sobre o tema abordado aqui fiquem a vontade de comentar aqui no blog. E obrigado a todos que acompanham este tutorial. Até o próximo post.

A baixo o link com a aplicação para download.

http://www.megaupload.com/?d=BXGMBLHC

Primeira parte do tutorial : http://tiagozis.wordpress.com/2010/07/12/flex-zend-framework-doctrine/

Continuando o desenvolvimento  será necessário criar um arquivo xml com as configurações necessárias para a comunicação do projeto flex com o prjeto Zend, esta comunicação ocorrerá atravez do AMF que já está embutido nas bibliotecas do Zend Framework. Então no projeto flex crie um novo arquivo chamado “services-config.xml” e configure conforme mostrado a seguir.

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
  <services>
    <service id="flextest-service" class="flex.messaging.services.RemotingService" messageTypes="flex.messaging.messages.RemotingMessage">
        <destination id="flextest">
          <channels>
            <channel ref="flextest-channel"/>
          </channels>
          <properties>
            <source>*</source>
          </properties>
        </destination>
        <destination id="flex">
          <channels>
            <channel ref="flex-channel"/>
          </channels>
          <properties>
            <source>*</source>
          </properties>
        </destination>
    </service>
  </services>
    <channels>
      <channel-definition id="flextest-channel" class="mx.messaging.channels.AMFChannel">
        <endpoint uri="http://project/gateway/amf" class="flex.messaging.endpoints.AMFEndpoint"/>
      </channel-definition>
      <channel-definition id="flex-channel" class="mx.messaging.channels.AMFChannel">
		<endpoint uri="http://project/gateway/amf" class="flex.messaging.endpoints.AMFEndpoint"/>
      </channel-definition>
    </channels>
</services-config>

Como podemos ver aqui é definido os canais de comunicação do flex com o PHP ou neste caso o projeto Zend, canais estes que se comunicam como já havia falado através do AMF. Outro detalhe que podemos verificar nesta configuração é a tag que define o “end point” da aplicação, ou seja o local que vai receber as requisições geradas pelo flex quando for solicitado. Explicando a URL do “endpoint”, o “project” refere-se ao nome definido para o projeto o mesmo usado na url de teste ao criarmos o projeto Zend, “gateway” é como vamos chamar a classe “controller” que servirá como o ponto de referencia para a comunicação, esta classe será criada  e explicada a seguir, pro fim “amf” o nome do método que refere-se a uma ação criada na classe “controler gateway”.

Já definimos as configurações de comunicação à parte flex do nosso projeto agora é necessário adicionar o parâmetro “service” ao compilador do flex para que o mesmo reconheça esta configuração. Então na ferramenta de desenvolvimento flex clique com o botão direito na aplicação e selecione “propriedades”, em seguida vá a opção “Flex Compiler” e no campo “Additional compiler argumenst” adicione a seguinte configuração ao campo texto existente, ( -services “services-config.xml” ). Click em “OK” e pronto o services-config do projeto já está definido como um argumento do compilador do flex.

Agora que o meio de comunicação do lado Flex do projeto já está devidamente configurado vamos criar a classe que recebe as requisições para repassar as ações para as classes services que serão criadas. No projeto Zend crie uma classe chamada “GatewayController” dentro do diretório “controllers”. As classes controllers do Zend Framework tem como objetivo controlar a aplicação executando as ações e redirecionando para as páginas referentes às ações definidas. Estas ações são declaradas como métodos que levam em sua nomenclatura o que a ação faz adicionado à palavra “Action” exemplo: ( public function indexAction() {} ). Este é o método padrão de uma classe controller do Zend Framework, e executa uma ação que inicializa a tela index de um módulo, poderíamos ter como base uma tela de cadastro de pessoas e um controller que poderíamos  chamar de “CadastroPessoasController” ao chamarmos uma url “http://meu_site/cadastroPessoas/index”, automaticamente o método do controller indexAction será chamado e iniciando a tela index que será um arquivo que fica no diretório “view” do projeto Zend Framework.

Porem no caso que estamos abordando aqui isto será necessário somente para a classe “GatewayController” que terá o método “amfAction” este método é responsável pelo envio dos das ações a serem executadas para as classes services do projeto. As classes services servirão como as classes de controle do nosso projeto. Observe que usarei este método para controlar a aplicação, mas outras formas podem ser abordadas, você poderá escolher o método que desejar. Na seqüência o código da classe.

class GatewayController extends Zend_Controller_Action {

public function init() {
    $this->getHelper('viewRenderer')->setNoRender();
  }

  public function indexAction() {

  }

  public function amfAction() {
    $server =  new Zend_Amf_Server();
    $server->addDirectory(APPLICATION_PATH. "/services/");
    echo ($server->handle());
  }

}

Então vamos lá crie uma classe no projeto na parte do Flex, onde desejar e com o nome que desejar, e estenda classe “RemoteObject” para essa nova classe criada. Abaixo a classe com o código necessário para a aplicação.

package controller
{
  import mx.controls.Alert;
  import mx.rpc.events.FaultEvent;
  import mx.rpc.events.ResultEvent;
  import mx.rpc.remoting.mxml.RemoteObject;

  public class RemoteObjectController extends RemoteObject {

      /*Construtor da classe definindo ações e configurações da classe.*/
      public function RemoteObjectController(serviceName:String=null) {
          /*Definindo o canal de comunicação*/
          super("flextest");
          /*Adicionando a ação que mostra a animação do cursor enquanto espera
          a resposta de retorno do servidor.*/
          super.showBusyCursor = true;
          /*Adicionando um evento que será disparado caso ocorra um erro.*/
          super.addEventListener(FaultEvent.FAULT, onFault);
          /*Adicionando o nome do service no projeto Zend que será chamado.*/
          if(serviceName is String){
              super.source = serviceName;
          }
      }

      /*Método que define qual função chamar quando servidor retorna com sucesso.*/
      public function setResultFunction(resultFunction:Function=null):void {
          if(resultFunction is Function){
	      super.addEventListener(ResultEvent.RESULT, resultFunction);
	  }
      }

      /*Método que exibe a mensagem de erro caso ocorra algum durante a requisição.*/
      public function onFault(e:FaultEvent):void{
          Alert.show(e.fault.faultString+"\n"+e.fault.faultDetail, e.fault.faultCode.toString());
      }
  }
}

Como podemos observar defini dois métodos alem do construtor um que mandará o retorno em casso de sucesso para uma função que será informada ao usar o objeto e outro dentro da própria classe, esse mostrará a mensagem de erro caso ocorra algum  problema durante a requisição.

Agora já temos o processo de comunicação do projeto definido, como usar essa classe que criamos irei explicar mais a frente, agora vamos criar o modelo do nosso projeto para colocá-lo em funcionamento. Vamos criar o modelo do banco de dados e em seguida as classes de modelo do projeto no lado Zend usando o doctrine e as classes do lado Flex que se comunicará com as classes de modelo. A próxima imagem descreve o modelo relacional para o projeto então fiquem a vontade de criar usando as ferramentas que desejar crie um banco de dados com este modelo e em seguida vamos criar as classes de modelo no projeto.

Para criar as classes de modelo do lado Zend do projeto vá ao prompt de comando percorra o caminho até o local onde se encontra o doctrine.bat e digite a seguinte linha de comando ( doctrine generate-models-db ), com este comando o Doctrine irá gerar as classes de modelo para o projeto.

As classes criadas mostrando na estrutura do projeto:

Bom agora que as classes do lado Zend do projeto já estão criadas e com o mapeamento para o banco de dados definido pelo Doctrine é necessário criar as classes espelho que representaram os objetos do lado flex do projeto. Mas antes quero destacar que ao criarmos essas classes de representação elas terão os seus atributos com o mesmo nome usado ao criar as classes php com o Doctrine, já que ao criar o banco de dados os atributos criados usou-se underline na nomenclatura naturalmente o doctrine também criou os atributos da mesma forma.

<?php
// Connection Component Binding
Doctrine_Manager::getInstance()->bindComponent('Hotel', 'doctrine');

/**
* Base_Hotel
*
* This class has been auto-generated by the Doctrine ORM Framework
*
* @property integer $cod_hotel
* @property string $nom_hotel
* @property integer $qtd_quartos
* @property Doctrine_Collection $HotelQuarto
*
* @package    ##PACKAGE##
* @subpackage ##SUBPACKAGE##
* @author     ##NAME## <##EMAIL##>
* @version    SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
*/
abstract class Base_Hotel extends Doctrine_Record
{
    public function setTableDefinition()
    {
	$this->setTableName('hotel');
	$this->hasColumn('cod_hotel', 'integer', 4, array(
	'type' => 'integer',
	'length' => 4,
	'fixed' => false,
	'unsigned' => false,
	'primary' => true,
	'sequence' => 'hotel_cod_hotel',
	));
	$this->hasColumn('nom_hotel', 'string', null, array(
	'type' => 'string',
	'fixed' => false,
	'unsigned' => false,
	'notnull' => true,
	'primary' => false,
	));
	$this->hasColumn('qtd_quartos', 'integer', 4, array(
	'type' => 'integer',
	'length' => 4,
	'fixed' => false,
	'unsigned' => false,
	'notnull' => true,
	'primary' => false,
	));
    }

    public function setUp()
    {
	parent::setUp();
	$this->hasMany('HotelQuarto', array(
	'local' => 'cod_hotel',
	'foreign' => 'cod_hotel'));
    }
}

Como pode ser analisada em uma das classes (Base) gerada pelo Doctrine, a forma que se usou para nomear os atributos ficou da mesma forma que está no banco de dados e serão desta mesma forma que terá que ser criado as classes no lado Flex. Pessoalmente eu não gosto de usar os atributos desta forma então o que podemos fazer é alterar os atributos da classe da forma que desejarmos. Para realizar esta tarefa abra a classe de modelo que estende a classe base referente e altere o nome do atributo usando o método “hasColumn” e nos comentários no inicio do arquivo podemos definir o “@property” com o mesmo nome do atributo. No código abaixo o exemplo usando a classe modelo “Hotel”.

<?php

/**
 * Hotel
 *
 * This class has been auto-generated by the Doctrine ORM Framework
 *
 * @property integer codHotel
 * @property string nomHotel
 * @property integer qtdQuartos
 *
 * @package    ##PACKAGE##
 * @subpackage ##SUBPACKAGE##
 * @author     ##NAME## <##EMAIL##>
 * @version    SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
 */
class Hotel extends Base_Hotel
{

    public $_explicitType = "Hotel";

    public function setTableDefinition(){
        parent::setTableDefinition();
	$this->hasColumn('cod_hotel as codHotel');
	$this->hasColumn('nom_hotel as nomHotel');
	$this->hasColumn('qtd_quartos as qtdQuartos');
    }
}

Sobrescrevendo o método (setTableDefinition) podemos alterar a nomenclatura do nosso atributo nos comentários definimos os novos nomes dos atributos esta tarefa não é obrigatória pois o novo atributo será reconhecido apenas definindo no método descrito anteriormente. Mas quem usa a o auto-complete de uma IDE poderá ver o atributo na lista ao usar este recurso, sem definir a nova propriedade esse o atributo não aparece na lista ao usar o recurso da IDE. Então se caso optar por alterar a nomenclatura dos atributos da classe podes realizar em todas as classes criadas pelo Doctrine.

Agora criaremos as classes espelho na aplicação flex a seguir um modelo de como deve ser a classe no Flex.

package models
{
    /*Mapeamento da classe Hotel existente no projeto Zend.*/
    [Bindable]
    [RemoteClass(alias="Hotel")]

    public class Hotel
    {
	public var codHotel:int;
	public var nomHotel:String;
	public var qtdQuartos:int;

    }
}

Ai esta a classe do lado flex nela contêm todos os atributos referentes à mesma classe na parte Zend do projeto e no topo a definição para o mapeamento da mesma. No projeto utilizando o zend não será necessário definir o diretório onde encontra-se a classe no Zend. O processo para as outras classes é o mesmo então você pode criar as demais para o projeto.

Com todas as classes criadas e definidas há uma definição exencial para o funcionamento do projeto, faltou o mapeamento das classes criadas no flex na parte Zend do projeto. Para fazer este mapeamento eu encontrei em minhas pesquisas na web três maneiras de realizar este mapeamento das classes. A primeira delas é dentro da classe “GatewayController” dentro do método “amfAction ()” usar esta definição para o mapeamento “$server->setClassMap(“Hotel”, “model.Hotel”);” , as outras duas formas são definidas dentro da classe de modelo referente a classe que será mapeada no Flex, neste casso usando a classe Hotel as definições ficam desta forma:

public function construct(){
    $this->mapValue('_explicitType', 'model.Hotel');
}

public $_explicitType = "Hotel";

Na primeira forma usamos dentro do construtor da classe o método “mapValue” para realizar o mapeamento porem vai um alerta e também uma sugestão para quem quiser pesquisar, com este método de declaração ocorre que em alguns casos o objeto retornado torna-se um objeto comum assim não dando para realizar o cast do objeto no lado Flex. Pode existir uma forma de resolver este problema mas não encontrei nada a respeito ainda. Já segunda forma é a mesma usada para mapear classes quando desenvolvemos utilizando apenas o php e o AMF desta forma também funcionam nada mais é que criar um novo atributo para a classe que é interpretado pelo AMF ao realizar o mapeamento. O método usado fica a sua escolha. Só para explicar, a palavra “model” que vem antes do nome da classe refere-se ao nome do diretório onde se encontra a classe “Hotel” do lado Flex. Esta declaração do diretório é necessária ao mapeamento no primeiro, mas não necessário usando o segundo método. O código abaixo mostra a forma que adotei para mapear as classes.

<?php

/**
 * Hotel
 *
 * This class has been auto-generated by the Doctrine ORM Framework
 *
 * @property integer codHotel
 * @property string nomHotel
 * @property integer qtdQuartos
 *
 * @package    ##PACKAGE##
 * @subpackage ##SUBPACKAGE##
 * @author     ##NAME## <##EMAIL##>
 * @version    SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
 */
class Hotel extends Base_Hotel
{

    public $_explicitType = "Hotel";

    public function setTableDefinition(){
        parent::setTableDefinition();
	$this->hasColumn('cod_hotel as codHotel');
	$this->hasColumn('nom_hotel as nomHotel');
	$this->hasColumn('qtd_quartos as qtdQuartos');
    }
}

Outras classes que tem a necessidade de ser criada nesta etapa do desenvolvimento são as classes “services” do projeto, as classes “services” vão ser chamadas quando o servidor receber a requisição que vem do Flex. No projeto que estamos criando vou usar estas classes também como as classes de controle, claro que não é a forma correta de utilizar este tipo de classe, mas não entrarei neste conceito neste post pois ainda estou estudando outras formas de criar classes de controle para ser utilizada nas classes “services”. Então crie uma classe service para cada classe que foi criada no nosso modelo do projeto. Classe service:

<?php
class HotelService {

    public function executeSave(Hotel $object){

    }

    public function executeDelete(Hotel $object){

    }

    public function executeList(){

    }
}

Agora vamos criar a tela para o projeto, neste post não abordarei a criação de views ou qualquer outro método, o arquivo main irá realizar a função de cadastrar, alterar, excluir uma reserva e listar as mesmas então abra o arquivo principal do projeto Flex, que no meu caso é o “Main.mxml” e crie a tela conforme o código mostrado a seguir.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" creationComplete="init()">
    <mx:Script>
    <![CDATA[

	public function init():void{ }

	public function getQuartos():void{ }

        public function save():void{ }

	public function edit():void{ }

	public function _delete():void{ }
    ]]>
    </mx:Script>
    <mx:DataGrid x="10" y="210" width="669" height="145">
	<mx:columns>
	    <mx:DataGridColumn headerText="Nome Hospede" dataField="nomHospede"/>
	    <mx:DataGridColumn headerText="Data Reserva" dataField="datReserva"/>
	    <mx:DataGridColumn headerText="Quantidade de dias" dataField="qtdDias"/>
	    <mx:DataGridColumn headerText="Hotel" dataField="nomHotel"/>
	    <mx:DataGridColumn headerText="Nº Quarto" dataField="numQuarto"/>
	</mx:columns>
    </mx:DataGrid>
    <mx:Label x="10" y="12" text="Hotel:"/>
    <mx:ComboBox x="138" y="10" width="230" id="comboHotel" labelField="nomHotel" change="getQuartos()"></mx:ComboBox>

    <mx:Label x="10" y="42" text="Quarto:"/>
    <mx:ComboBox x="138" y="40" width="230" id="comboQuarto" labelField="numQuarto"></mx:ComboBox>

    <mx:Label x="10" y="72" text="Hospede:"/>
    <mx:ComboBox x="138" y="70" width="230" id="comboHospede" labelField="nomHospede"></mx:ComboBox>

    <mx:Label x="10" y="102" text="Data Reserva:"/>
    <mx:DateField x="138" y="100" width="230" id="data"/>

    <mx:Label x="10" y="132" text="Quantidade de dias:"/>
    <mx:TextInput x="138" y="130" width="230" restrict="[0-9]" id="dias"/>

    <mx:Button x="296" y="160" label="Salvar" width="72"/>
    <mx:Button x="255" y="363" label="Alterar" width="72" click="edit()"/>
    <mx:Button x="335" y="363" label="Excluir" width="72" click="_delete()"/>

</mx:Application>

Explicando rapidamente as funções existentes aqui, a primeira “init()” é a função chamada quando a tela é criada aqui será feita as chamadas de dados que serão necessários ao carregar a tela, a declaração que chama esta função fica na tag “application” do documento que dispara uma ação ao carregar a tela do projeto (creationComplete="init()"), dados estes como a lista de Hoteis e Hospedes para os componentes “comboBox” e a listagem de reservas do sistema, apenas para esclarecem que o nome da função fica a sua escolha e que nem sempre precisamos carregar algo ao iniciarmos uma tela está é apenas uma abordagem realizada no exemplo. A segunda função “getQuartos()” será chamada quando a ação “change” do comboBox hotel ativar, essa função irá buscar a lista de quartos existentes para aquele hotel selecionado. Por fim as funções ( save(), edit(), _delete() ) que realizarão as operações básicas do projeto, funções estas que serão executadas ao acionar a funcionalidade “click” adicionada aos botões.

Pessoal por enquanto a segunda parte do post se encerra por aqui, na próxima parte e ultima vou mostrar como aplicar as funções e realizar as operações entre o Flex e o Zend Framework. Espero que estejam gostando do tutorial e qualquer dúvida ou sugestão sobre o post é só deixar um comentário. Até o próximo post e obrigado a todos.

Realizando algumas pesquisas de integração entre a ferramenta do Adobe e o framework encontrou-se vários tutoriais e dicas na web muitos deles incompletos ou confusos. Por isso decidi criar este Post para tentar mostrar de forma clara o processo de criação de um projeto integrando estas ferramentas. Espero que este post ajude a esclarecer dúvidas e que de alguma forma possa servir como referencia tanto para quem tem conhecimento e utiliza estas ferramentas como para quem está começando na área de desenvolvimento.

O Post será dividido em partes nesta primeira parte explicarei como instalar o Zend Framework e como criar um projeto com o mesmo, também abordarei a instalação do Doctrine no framework e a criação de um projeto no Flex.

Para começar é necessário estar de posse das seguintes ferramentas para o desenvolvimento deste projeto:

Ter instalado um servidor como, por exemplo, o Apache, ter o PHP também instalado em sua máquina e um banco de dados de sua escolha neste caso eu usarei o Postgre, pois é o banco de dados que uso onde trabalho. E o que estou mais acostumado.

Também será necessário estar de posse da ferramenta de desenvolvimento da Adobe ou qualquer outro tipo de instalação como plugin para eclipse etc. Esta ferramenta pode ser obtida neste link http://www.adobe.com/products/flex/ , onde pode ser baixado o SDK da ferramenta que é distribuído de forma gratuita, ou a ferramenta Flash Builder da Adobe esta ferramenta é paga mas pode ser realizado o download trial para testes que possibilita utilizar a ferramenta durante 60 dias.

Outra ferramenta utilizada neste tutorial é o Zend Framework, este framework para desenvolvimento de softwares em PHP é de distribuição gratuita e licença livre para uso, apenas em caso de criação de código especifico para o framework como, por exemplo, novas funcionalidades para as bibliotecas do mesmo, nestes casos será necessário assinar um termo onde o especifica que o código que será desenvolvido será de propriedade da Zend. Esta ferramenta pode ser obtida neste link http://framework.zend.com/.

Por ultimo a ferramenta Doctrine, esta ferramenta serve para mapeamento de objetos relacionais de um banco de dados ou ORM (Object Relational Mapper), ferramenta também de distribuição e uso gratuito que será usado para mapear as tabelas do banco de dados. A ferramenta pode ser obtida no seguinte link http://www.doctrine-project.org/.

Neste tutorial usarei as seguintes versões dessas ferramentas:

Adobe Flash Builder 3

Zend Framework versão 1.10.6

Doctrine versão 1.2.2

Para o Apache e php a distribuição do MS4W.

PostgreSQL versão 8.4

Porem nada impede de ser utilizado versões mais atualizadas destas ferramentas apenas pode ser que tenha a necessidade de algumas alterações, mas isto fica para outros post ou conforme seguir a linha de aprendizado e estudos que você realizará, mas para este tutorial abordarei as versões descritas.

Para iniciarmos explicarei como realizar a instalação do Zend Framework, no meu caso a instalação foi realizada no sistema operacional Windows, mas nada impede de ser realizado em outro sistema operacional apenas optei por este, pois é o que uso no momento. Apos o download da ferramenta  descompacte o arquivo na pasta que desejar no meu caso adicionou a pasta junto aos arquivos do meu servidor Apache instalado na máquina se sentir a necessidade pode alterar o nome da pasta como desejar, eu alterei o nome da mesma como “zf”, caminho da instalação (C:\ms4w\Apache\zf ). O próximo passo é dizer para o framework o caminho onde está localizado o php.exe e o inicializador de scripts do framework para realizar os comandos de ações que framework disponibiliza utilizando o pronpt de comando, então entre na pasta que acabou de descompactar e em seguida na pasta bin abra o arquivo (zf.bat) em um editor de texto e altere seguinte linha:

SET PHP_BIN=php.exe

Substituindo pelo caminho onde o PHP está instalado, no meu caso ficou desta forma:

SET PHP_BIN=C:\ms4w\Apache\cgi-bin\php.exe

E também altere estas linhas:

SET ZF_SCRIPT=%PHP_DIR%\zf.php

SET ZF_SCRIPT=C:\ms4w\Apache\zf\bin\zf.php

Salve o arquivo. Pronto agora podemos testar se o framework já esta funcionando, abra o prompt de comando e caminhe até a pasta onde está o zf.bat e digite o seguinte comando “zf show version” se estiver correto a instalação ele mostrará a versão do seu framework no prompt de comando.

Agora já pode ser criado um novo projeto zend por comando no prompt, mas antes de explicar esta parte é necessário uma observação, a alteração do arquivo “zf.bat” faz com que os comando digitados funcionem apenas na pasta de origem, para ter flexibilidade de criar os projetos onde desejar é necessário fazer uma cópia do “zf.bat” e coloca-lo na pasta (system32) do windows, assim  copie o arquivo e coloque no diretório, no meu casso o arquivo ficou neste caminho (C:\Windows\System32). Apos realizar esta tarefa vá ao prompt de comando e digite o comando “zf” em qualquer caminho especificado no prompt, ao digitar este comando vai aparecer à lista de comandos do framework na tela do prompt. Vamos criar um novo projeto usando o comando ( zf create project nome_do_projeto ) com este comando o framework criará o projeto no arquivo onde estiver o caminho do prompt de comando, para especificar qual do diretório que deseja criar o peojeto pode seguir este exemplo ( zf create project c:/zf_projects/nome_do_projeto ).

Abaixo está a imagem da estrutura de diretórios criada pelo framework:

Explicando rapidamente, o diretório “aplication” é onde ficará todo o conteúdo desenvolvido para o sistema como classes de controle, de domínio, configurações etc. O diretório “docs” destinado as documentações caso necessário, diretório “library” é o local que ficará as bibliotecas do Zend Framework, Doctrine (explicado a seguir) e outras que desejar para o sistema, o diretório “public” é a pasta que é acessada pelo servidor ou no caso do usuário quando acessar o sistema pelo browser os itens contidos nesta pasta poderão ser visualizados e finalmente o diretório “tests” usado para testes está ainda não cheguei a utilizar então não tenho conhecimento sobre a mesma. Agora com o projeto criado o próximo passo é adicionar as bibliotecas do Zend Framework ao seu projeto. Para fazer isso vá até o diretório que onde está o Zend Framework entre no diretório “library” e copie a pasta “Zend” para a pasta “library” do projeto que foi criado. Esta pasta contêm todas as bibliotecas do Zend Framework.

Antes de testarmos a nossa aplicação vamos realizar algumas configurações no sistema para rodar o projeto dinamicamente e certificando-se que outras pastas do seu projeto alem da (public) não possam ser acessadas pelo bowser. Primeiramente vá até o diretório (System32\drivers\etc) do Windows, procure e abra em um editor o arquivo chamado “hosts” e adicione a seguinte linha.

127.0.0.1       project

Neste caso “project” é o nome do arquivo onde está o projeto Zend Framework. Salve o arquivo.

Em seguida vá até o diretório onde está instalado o servidor apache entre na pasta (conf) e encontre o arquivo chamado (httpd.conf) e remova os comentários (#) destas linhas:

#Include conf/extra/httpd-vhosts.conf

#LoadModule rewrite_module modules/mod_rewrite.so

Agora o mode-rewrite do apache está habilitado e incluiu o arquivo “httpd-vhosts.conf” na leitura do apache, em seguida encontre o arquivo (httpd-vhosts.conf), no meu caso ele encontra-se em ( C:\ms4w\Apache\conf\extra ), abra o arquivo no editor e adicione as linhas a seguir.

<VirtualHost *:80>
  ServerName project
  DocumentRoot C:/zend_projects/project/public
  SetEnv APPLICATION_ENV "development"
  <Directory  C:/zend_projects/project/public>
    DirectoryIndex index.php
    AllowOverride All
    Order allow,deny
    Allow from all
  </Directory>
</VirtualHost>

Estas linhas definem o acesso para o projeto especificando para o servidor onde realizar o seu trabalho independente de onde estiver o projeto em seu computador não sendo necessário aloca-lo no diretório root do servidor. Agora de um restart no servidor e vamos testar se o projeto já está em funcionamento. Acesse a url no navegador desta forma ( http://project/), no lugar de “project” use o nome que destinou ao seu projeto, a imagem a seguir mostra o que deverá aparecer na tela.

O próximo passo a ser realizado é a inclusão do Doctrine na aplicação, descompacte o Doctrine onde desejar entre no diretório “lib” e copie os arquivos existentes ali para o diretório “library” do projeto. A imagem a seguir mostra como ficou o diretório “library” do projeto.

Estes arquivos que foram copiados para o projeto contêm todas as bibliotecas necessárias para a criação das classes de mapeamento do banco de dados que será implementado mais a frente, mas antes será necessário realizar algumas alterações e implementar algumas configurações no projeto para poder usar o Doctrine.

Agora é necessário criar uma estrutura de diretórios para os arquivos que o Doctrine pode gerar. Dentro do diretório (aplication/configs) do seu projeto crie os diretórios “data” e “migrations”, dentro do diretório “data” crie os diretórios “fixtures” e “sql”. Apos fazer isso ficara da forma mostrada abaixo:

Vamos configurar os caminhos para o Docrine no projeto. Abra o arquivo “application.ini” que está com as configurações padrão de quando foi criado o projeto.

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.frontController.params.displayExceptions = 1

Adicione as linhas como é mostrado a seguir.

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

;----------------------------------------------------------------------------------------
;  Auto load do doctrine.
;----------------------------------------------------------------------------------------
autoloaderNamespaces[] = "Doctrine"

;----------------------------------------------------------------------------------------
;  Configuração da string de conexão com o banco de dados.
;----------------------------------------------------------------------------------------
doctrine.dsn = "pgsql://postgres:123456@localhost/db_reserva_hotel"

;----------------------------------------------------------------------------------------
;  Configuração dos diretórios usados pelo Doctrine apos criar alguns arquivos quando
;  for necessário.
;----------------------------------------------------------------------------------------
doctrine.data_fixtures_path = APPLICATION_PATH "/configs/data/fixtures"
doctrine.sql_path           = APPLICATION_PATH "/configs/data/sql"
doctrine.migrations_path    = APPLICATION_PATH "/configs/migrations"
doctrine.yaml_schema_path   = APPLICATION_PATH "/configs/schema.yml"
doctrine.models_path        = APPLICATION_PATH "/models/"

;----------------------------------------------------------------------------------------
;  Parametros de configuração de algumas opções do Doctrine.
;----------------------------------------------------------------------------------------
doctrine.generate_models_options.pearStyle = true
doctrine.generate_models_options.generateTableClasses = false
doctrine.generate_models_options.generateBaseClasses = true
doctrine.generate_models_options.baseClassPrefix = "Base_"
doctrine.generate_models_options.baseClassesDirectory =
doctrine.generate_models_options.classPrefixFiles = false
doctrine.generate_models_options.classPrefix = ""

;----------------------------------------------------------------------------------------
;  Configuração de autoloading do Doctrine, necessário para o CLI ao gerar os models
;  do sistema aproriadamente.
;  MODEL AUTOLOADING: 1 = aggressive, 2 = conservative
;----------------------------------------------------------------------------------------
doctrine.model_autoloading = 1

[doctrineCLI : production ]
doctrine.model_autoloading = 1

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

;----------------------------------------------------------------------------------------
;  Configuração da string de conexão com o banco de dados para o ambiente de teste.
;----------------------------------------------------------------------------------------
doctrine.dsn = "pgsql://postgres:123456@localhost/db_reserva_hotel"

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.frontController.params.displayExceptions = 1

Então como podemos ver, várias configurações foram criadas para o funcionamento do Doctrine as mais importantes como a string de conexão com o banco de dados, as configurações (doctrine.generate_models_options.generateTableClasses = false,
doctrine.generate_models_options.generateBaseClasses = true, doctrine.generate_models_options.generateTableClasses = true) que servem para gerar as classes de domínio e mapeamento das tabelas do banco para o sistema, e duas configurações de como será o prefixo das classes de domínio do sistema que são:

• doctrine.generate_models_options.baseClassPrefix = “Base_”

• doctrine.generate_models_options.classPrefix = “”

Em alguns tutoriais na web podemos encontrar a seguinte configuração para esta ultima (doctrine.generate_models_options.classPrefix = “Model_”), pessoalmente eu não gosto desta forma por que ao gerar as classes para o sistema a nomenclatura delas será desta forma:

• Model_Base_NomeDaClasse para a classe base do sistema onde fica as informações sobre a tabela do banco de dados do sistema.

• Model_NomeDaClasse para a classe que estende a classe base do sistema.

Nada impede de ser feito desta maneira, mas quando for criar um novo objeto durante a aplicação em vez de declarar pelo nome que representa este objeto, por exemplo, o objeto “Carro”, será necessário declarar o objeto desta forma “Model_Carro” então estas configurações ficam a critério de quem implementa, no meu caso coloquei a configuração vazia sem prefixo para declarar o objeto conforme o nome que lhe foi concedido.

Prosseguindo no diretório “aplication” do projeto crie um diretório chamado de “scripts” dentro deste diretório crie dois novos arquivos que serão necessários para rodar o Doctrine na aplicação, “doctrine.php” e “doctrine.bat” abra o arquivo “doctrine.php” e insira as seguintes linhas de código.

<?php
   // Define o caminho do diretório para a aplicação.
   defined('APPLICATION_PATH') || define('APPLICATION_PATH', realpath(dirname(__FILE__) .'/..'));

   // Define onde será o ambiente da aplicação.
   defined('APPLICATION_ENV') || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'doctrineCLI'));

   // Certifica-se se a biblioteca foi incluído no pacorte da aplicação.
   set_include_path(implode(PATH_SEPARATOR, array(realpath(APPLICATION_PATH . '/../library'),get_include_path())));

   // Zend_Application
   require_once 'Zend/Application.php';

   //Cria a aplicação, o bootstrap, e inicia os mesmos.
   $application = new Zend_Application(APPLICATION_ENV, APPLICATION_PATH . '/configs/application.ini');

   $application->getBootstrap()->bootstrap('doctrine');

   $config = $application->getOption('doctrine');
   $cli = new Doctrine_Cli($config);
   $cli->run($_SERVER['argv']);
?>

Nestas linhas de código estão as configurações necessárias para rodar o doctrine dentro da aplicação, assim esta ferramenta poderá encontrar suas bibliotecas quando necessário e iniciar seus serviços quando solicitado. Abra no editor o arquivo “doctrine.bat” e insira as linhas a seguir.

  @echo off
  echo Running Doctrine CLI.
  "C:\ms4w\Apache\cgi-bin\php.exe" -f C:\zend_projects\project\application\scripts\doctrine.php %1 %2 %3 %4 %5 %6 %7 %8 %9

Bom aqui neste arquivo bat configuramos o caminho onde encontra-se o “php.exe” e o arquivo que acabamos de criar “doctrine.php” este bat servirá para utilizarmos os comandos do Doctrine no prompt de comando, comandos estes que geram por exemplo as classes de domínio do nosso sistema. Configure estes caminhos conforme a sua necessidade.

Para finalizar as configurações necessárias para rodar o Doctrine na aplicação, dentro do diretório “aplications” do projeto existe um arquivo chamado “Bootstrap.php” abra o mesmo no editor, aqui podemos analisar que ao abrir este arquivo ele não possui métodos implementados, então vamos adicionar os seguintes métodos a ele.

<?php
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{

    /*Metodo para autoload da aplicação*/
    protected function _initAppAutoload() {
        $moduleLoader = new Zend_Application_Module_Autoloader(array('namespace' => '','basePath' => APPLICATION_PATH));
    }

    /*Metodo de inicialização do doctrine*/
    protected function _initDoctrine()
    {
        $this->getApplication()->getAutoloader()->pushAutoloader(array('Doctrine', 'autoload'));
        spl_autoload_register(array('Doctrine', 'modelsAutoload'));

        $doctrineConfig = $this->getOption('doctrine');

        $manager = Doctrine_Manager::getInstance();
        $manager->setAttribute(Doctrine::ATTR_AUTO_ACCESSOR_OVERRIDE, true);
        $manager->setAttribute(Doctrine::ATTR_MODEL_LOADING,$doctrineConfig['model_autoloading']);

        Doctrine_Core::loadModels($doctrineConfig['models_path']);

        $conn = Doctrine_Manager::connection($doctrineConfig['dsn'],'doctrine');
        $conn->setAttribute(Doctrine::ATTR_USE_NATIVE_ENUM, true);
        return $conn;
 }
}

Estes métodos são mais algumas configurações necessárias para iniciar e colocar o Doctrine em funcionamento. Pronto o Doctrine já está configurado, para testar se está funcionando abra o prompt de comando e prossiga pelo caminho até o diretório onde se encontra o arquivo (doctrine.bat), então digite o comando “doctrine”. Se todas as configurações foram feitas corretamente à lista de comandos do Doctrine será mostrada no prompt de comando.

Agora com o Doctrine instalado e funcionando vamos criar um novo projeto flex. Na ferramenta de desenvolvimento Flex, vá a File->New->Flex Project para criar o projeto.

Uma tela semelhante à imagem a seguir abrirá então, de um nome ao seu projeto Flex e no campo “Project location” selecione o diretório “public” do projeto Zend para deixar a parte Flex do projeto, pois lembrando que o diretório “public” é a que poderá ser acessada pelo browser. Recomendo criar um novo diretório dentro do “public” para que os arquivos do projeto Flex não fiquem espalhados dentro do diretório “public”.

Defina onde serão criados os arquivos SWF e HTML do projeto. Por padrão o flex cria um diretório chamado “bin-debug”, mas nada impede de ser renomeado ou redefinido conforme desejar.

E por fim pode ser alterado o nome do arquivo principal do seu projeto neste caso a página “index” que será carregada durante a execução do sistema e também pode ser adicionado algumas bibliotecas se caso tenhas alguma para adicionar. Conclua a criação do projeto.

Agora que o projeto está criado vamos ver como ficou o esquema de diretórios do projeto. A imagem seguinte mostra a estrutura dos diretórios no projeto.

Pessoal por enquanto vai ficando por aqui mesmo, lembrando que em breve continuarei o Post com a integração destas ferramentas. Continuem acompanhando, pois ao final deste tutorial irei postar os arquivos criados com todo o código fonte do projeto.

Em caso de dúvidas ou sugestões, postem seus comentários aqui BLZ…

Valeu até o próximo Post.