Tutorial Módulo Agenda

MIOLO TEAM
 SUMÀRIO

1 – Montagem da Estrutura de Diretórios Padrão para o Módulo do MIOLO

2 – Criação dos Arquivos Necessários para MIOLO

3 – Interface e Funcionamento

4 – Handler
4.1 – Handler City( city )

5 – Formulário
5.1 – Form City(frmCity)

6 – Business
6.1 – Business City(busCity)

7 – Grid
7.1 – Grid City(grdCity)

8 – Lookup
8.1 – Criando um Lookup
8.2 – Utilizando um Lookup no Form

9 – Gerando um Pacote com o módulo do MIOLO

1. Montagem da Estrutura de Diretórios e Arquivos Padrão para o Módulo do MIOLO

Dentro do diretório modules do MIOLO deve ser criado um diretório com o nome do
módulo. neste caso, o nome do diretório é “Agenda”. dentro do diretório do
módulo, o módulo deve ter a seguinte estrutura:

/handlers: Localiza-se em miolo/modules/nome_do_módulo/handlers. São os

arquivos chamados pelo action do MIOLO. o handler faz a ligação com os
componentes visuais como forms e grids. tem extensão *.inc.

/forms: Localiza-se em miolo/modules/nome_do_módulo/forms. São os

formulários visualizados pelo usuário. são classes com extenxão *.class.

/db: Localiza-se em miolo/modules/nome_do_módulo/db. São as classes

business, extendem Mbusiness, e fazem toda a interação com o banco de
dados. tem extenção *.class.

/sql: Localiza-se em miolo/modules/nome_do_módulo/sql. Possui os comandos

sql para criar o banco com a instalação de módulos do MIOLO. Também pode
pode ter um arquivo do banco de dados sqlite. O nome padrão para o arquivo
com os comandos sql para instalação do módulo deve ser nome_do_módulo.sql.

/html: Localiza-se em miolo/modules/nome_do_módulo/html. Possui arquivos

HTML, Javascript, e imagens(no subdiretório images).

/html/images: Localiza-se em miolo/modules/nome_do_módulo/html/images.

Subdiretório do html que possui as imagens do módulo.

/docs: Localiza-se em miolo/modules/nome_do_módulo/docs. Possui

documentação e diagramas.

/etc: Localiza-se em miolo/modules/nome_do_módulo/etc. Possui o

module.conf que contem as configurações do módulo e o module.inf que tem
as informações do módulo.

/classes: Localiza-se em miolo/modules/nome_do_módulo/classes. Utiliza-se

para inserir outras classes ao módulo.

Monta-se então a estrutura de diretórios padrão do miolo:

miolo@server: cd /usr/local/miolo2/modules
miolo@server: mkdir agenda
miolo@server: cd agenda
miolo@server: mkdir handlers
miolo@server: mkdir forms
miolo@server: mkdir db
miolo@server: mkdir sql
miolo@server: mkdir html
miolo@server: mkdir docs
miolo@server: mkdir etc
2. Criação dos Arquivos Necessários para o Módulo do MIOLO

Cria-se os arquivos necessários para qualquer módulo:

/handlers/handler.class: Arquivo obrigatório para o módulo. O nome da

classe deve conter Handler + nome do módulo. no caso: Handler+Agenda. Deve
conter a seguinte estrutura:

<?php

class HandlerAgenda extends Handler

{
function init()
{
parent::init();
$this->manager->Trace(__METHOD__);
}
}
?>

/etc/module.conf: Arquivo XML com a configuração do módulo. Segue o

padrão de tags do miolo.conf e tem prioridade em relação ao mesmo. Se o
módulo utilizar banco de dados, o module.conf deve conter
obrigatoriamente a tag <db> com sua configuração as demais tags do
miolo.conf só serão adicionadas aqui se for necessária uma configuração
diferente da padrão. Abaixo segue um exemplo de configuração:

<?xml version="1.0" encoding="ISO-8859-1"?>

<conf>
<db>
<agenda>
<system>sqlite</system>
<host>localhost</host>
<name>/home/joe/miolo2/modules/agenda/sql/agenda.sqlite
</name>
<user>miolo</user>
<password>miolo</password>
</agenda>
</db>
</conf>

Dentro da tag db colocar uma tag com o nome do módulo. a tag system
define o tipo de banco de dados a ser utilizado. A tag host define em
qual host esta o servidor do banco. A tag name define o nome do banco e
as tag user e password definem um usuário e uma senha para o banco.
 /handlers/main.inc: Handler chamado inicialmente ao acessar o módulo.
Cria a interface inicial ou chama o handler que for necessário.

Agora a estrutura padrão está montada. Partimos para a construção da interface

e funcionamento do módulo em si.

3. Interface e Funcionamento

O módulo 'agenda' terá inicialmente 3 telas(cadastro de cidades, cadastro de

contatos, cadastro de compromissos) mais uma tela inicial que dará acesso às
outras.

Vamos criar a tela inicial em nosso main.inc, com os três ícones de acesso:

miolo@server: vim handlers/main.inc

Em todos os campos que aparecem para o usuário usamos a função _M(), que faz a
internacionalização. traduzindo o que é passado no 1º parâmetro para o idioma
escolhido na configuração, tomando como base as traduções do módulo passado no
segundo parâmetro.

Através do método addAction() do MActionPanel é adicionado links ao painel,

onde o primeiro parâmetro é o label, o segundo é a imagem, o terceiro o módulo
que será acessado e o último a ação(handlers).

A imagem do ícone deve ser chamado pelo método getImage() da classe MUI, o qual
é acessado através do método getUi() da variável global $MIOLO, passado como
primeiro parâmetro o nome do módulo e como segundo parâmetro o nome da imagem.
A imagem deve estar no diretório html/images dentro do módulo.

<?php

//instância em $panel um painel de nome 'panelPrincipal' e título 'Agenda'

$panel = new MActionPanel('panelPrincipal', _M('Agenda', 'agenda'));

$ui = $MIOLO->GetUI();
$panel->addAction(_M('Contact', 'agenda'), $ui->getImage('agenda',
'contact-32x32.png'), 'agenda', 'main:contact');
$panel->addAction(_M('City', 'agenda'), $ui->getImage('agenda', 'city-
32x32.png'), 'agenda', 'main:city');
$panel->addAction(_M('Schedule', 'agenda'), $ui->getImage('agenda', 'book-
32x32.png'), 'agenda', 'main:schedule');

Para adicionar painel na tela, deve ser chamada a função appendContent() ou

insertContent() da classe MTheme, que está instanciada na variável global
$theme.

$theme->appendContent($panel);
As últimas linhas fazem a chamada do próximo handler chamado pelo action.

$a = $context->shiftAction();
if( $a )
{
$MIOLO->invokeHandler( $module, $a );
}
?>

4 – Handler

4.1 – Handler City( city )

Deve-se criar um handler para cada form. Neste caso o handler do form City
(forms/frmCity.class). Os handlers devem ser criados dentro do módulo no
diretório handlers. Neste caso handlers/city.inc.

<?php

// limpa os campos do tema

$theme->clearContent();

// adiciona os caminhos na barra de navegação

$navbar->AddOption(_M('City','agenda'), 'agenda', 'main:city');

// instância a interface a $ui

$ui =$MIOLO->GetUI();

/* $form instância o form, passado como parâmetros o módulo e o nome do

form */
$form = $ui->GetForm('agenda','frmCity');

// tema recebe o conteúdo do form

$theme->AppendContent($form);

?>
5. Formulário

5.1 – Form City(frmCity)

Chamamos de form a classe que elabora e controla o formulário php. Normalmente

os forms extendem a classe MForm do MIOLO2.
No construtor de um form devemos fazer a chamada para o construtor do MForm, o
qual irá montar a estrutura e executar o método createFields, que criaremos
posteriormente.
Todo MForm possui um botão “Enviar” por padrão. No nosso case ele não é
necessário.
Os formulários no miolo seguem uma espécie de orientação à eventos, sendo que
os métodos podem ser chamados por eles. Normalmente ao fim do construtor
chamamos a função “eventHandler”, que executa os eventos necessários.

<?php
class frmCity extends MForm
{
var $grid; //Cria-se uma Variável Global para a Grid

function __construct()
{
parent::__construct(_M('City','agenda'));

$this->defaultButton = false; // desativando botão padrão

$this->eventHandler(); // chamada dos eventos
}

Abaixo o método “createFields” onde, como o nome já sugere, devem ser criados
os campos e componentes do formulário.
 function createFields()
{
global $MIOLO; // disponibiliza o acesso a variável global $MIOLO

// Abaixo cria-se um vetor de Botões

$buttons[] = new MButton ('btnSearch',_M('Search','agenda'));

A função _REQUEST do MIOLO obtém o valor de uma variável (ou de várias, em um

array) a partir dos arrays globals do PHP ($_REQUEST, $_POST, $_GET, $_SESSION,
global). no nosso caso queremos pegar a variável event.

// se for edit, insere o botão “Save”

if (MIOLO::_REQUEST('event') == 'loadData')
{
$buttons[] = new MButton ('btnSave',_M('Save','agenda'));
}
else // se evento não for Edit insere o botão “Insert”
{
$buttons[] = new MButton ('btnInsert',_M('Insert','agenda'));
}

Criaremos um vetor com todos os elementos gráficos e campos que vão no

formulário. para o cadatro de cidades precisamos de dois campos, um para
colocar o código da cidade e outro para colocar o nome da cidade. para isso
instanciamos duas MTextField.

A MTextField é um campo do tipo texto( <input type=”text”> ). Para ela passamos

como parâmetro o nome do campo, value, text label e o tamanho.

$fields = array(
new MTextField ('idCity','',_M('CodCity','agenda'),10),
new MTextField('nameCity','',_M('City','agenda'), 30),
new MHContainer ('contBtns',$buttons),new MSeparator()
);

Agora temos os elementos visuais armazenados em forma de array dentro da

variável $fields. É necessário lhes aplicar no formulário. Para isso podemos
usar os métodos setFields(), addFields() e addField(), onde o primeiro
substitui os elementos existentes pelos passados por parâmetro em forma de
array; o segundo adiciona o array dos fields passados ao form, sem retirar os
já presentes; e o terceiro adiciona um só elemento, sendo dispensado o uso de
array.

$this->setFields($fields);

Aqui precisaremos do acesso à variável global $MIOLO(instanciada no inicio do

método), que contém as principais funções do framework. Ela é necessária para
obtermos uma instância da classe MUI, que como já explicado anteriormente, é
usada para obter determinados objetos visuais, no nosso caso, a grid.
Instanciamos a grid como um atributo da classe, pois precisamos acessá-la em
outros métodos.

$ui = $MIOLO->getUi(); // Chama a extensão Gráfica do MIOLO

//instancia a Grid
$this->grid = $ui->getGrid('agenda','grdCity');

// Adiciona a grid no Formulário

$this->addField($this->grid);
}

Abaixo função chamada ao clicar no botão “Search”, a qual pega os registros da

base de dados e aplica na grid.

Precisamos do objeto que interage com a tabela City da base de dados(business),

o qual mostraremos como criar mais abaixo. Usando o getBusiness() instanciamos
a classe necessário, passando como primeiro parâmetro o módulo a que ela
pertence, seguido do nome da mesma.

Para fazer a pesquisa atribuímos os campos preenchidos no formulário em nosso

business. Após, método searchCity() faz a busca e retorna os registro
encontrados em forma de array, o qual deve ser setado na grid.

function btnSearch_click()
{
global $MIOLO;
$bus = $MIOLO->getBusiness('agenda', 'busCity');

// Atribui dos campos do formulário na grid

$data = $this->getData();
$bus->setData($data);

// efetua a busca e seta os registros na grid

$data = $bus->searchCity();
$this->grid->setData($data);
}
O método btnInsert_Click() correspondo ao evento clique do botão “Insert”.
Valida os dados, chama o método de inserção do business e mostra as mensagens
necessárias.

function btnInsert_click()
{
global $MIOLO;
 // se não foi digitado o nome da cidade, exibe um erro na tela
if (!$this->getFormValue('nameCity'))
{
// método addError() cria um box de erro no form
$this->addError(_M('City is Required!'));
return;
}
$bus = $MIOLO->getBusiness('agenda', 'busCity');
$data = $this->getData();
$bus->setData($data);

// se a função de inserção retornar um id diferente do digitado

// mostra um um aviso junto da mensagem
// se retornar false(problemas) mostra uma mensagem de erro
if ( $id = $bus->insertCity() )
{
if( $this->getFormValue('idCity')
&& ($id != $this->getFormValue('idCity')) )
{
$msg = _M('Duplicate id. This City ', 'agenda').$this-
>getFormValue('nameCity')._M(' was inserted with id ',
'agenda').$id._M(' Sucefully!','agenda');
}
else
{
$msg = _M('Inserted City ', 'agenda').$this-
>getFormValue('nameCity')._M(' with id ', 'agenda').$id._M('
Sucefully!','agenda');
}
$this->addInfo($msg);
// coloca na grid o registro inserido
$this->btnSearch_click();
}
else
{
$msg = _M('City not Inserted! Check data and try
again','agenda');
$MIOLO->addInfo(); //adiciona um box no form
}
}

Ao clicarmos no botão “edit” de um registro na grid, os dados do mesmo devem

ser carregados nos campos. Esse procedimento é realizado pelo metodo
loadData(), passando seu nome na variável “event” na URL do link da grid.
Lembrando que os eventos ali existentes são executados pelo
“$this->eventHandler()” localizado no construtor do form. Também pela URL do
link da grid é passado o ID do registro que foi clicado, através da variável
“item”.

function loadData()
{
global $MIOLO, $action;

$url = $MIOLO->getActionURL('agenda', $action);

$this->page->setAction($url);

$bus = $MIOLO->getBusiness('agenda', 'busCity');

// getCity carrega os valores do registro no business
// de acordo com o id passado por parâmetro através do item
$bus->getCity(MIOLO::_REQUEST('item'));
$this->setdata($bus->getData());
// desabilitamos o campo ID pois é único, não deve ser alterado
$this->idCity->setReadOnly(true);
}

O método btnSave_click() será acionado assim que for clicado o botão "btnSave".
Ele é responsável por alterar o registro no Business City.
 function btnSave_click()
{
global $MIOLO;

$bus = $MIOLO->getBusiness('agenda', 'busCity');

$data = $this->getData();
$bus->setData($data);

// se não ocorreram erros mostra a mensagem, faz a busca para que

// o registro apareça na grid e depois limpa os casmpo
if ($bus->updateCity())
{
$msg = _M('Register Successfully Updated!','agenda');
$this->addInfo($msg);
$this->btnSearch_click();
$this->setData(null);
}

else
{
$msg = _M('Register Not Updated! Check data and try
again','agenda');
$this->addError($msg);
}
}

Assim que o usuário clicar no botão “delete” de um registro na grid, deve ser
mostrada uma confirmação, o que é feito pelo método abaixo. Quando for clicado
“OK” deve ser chamada o método deleteCity(), que excluirá o registro. Caso for
clicado “Cancelar” devemos voltar ao form com os registros na grid. Fazemos
isso sempre usando a variável “event” passada pela URL, e sem esquecer de
passar o id através do “item”.
function deleteConfirm()
{
global $MIOLO;
$message = _M('Delete City ','agenda').MIOLO::_REQUEST('item').' ?';
// o metodo confirmation() espera no 1º parametro a mensagem
// no 2º a URL a ser acessada quando clicado “OK”
// no 3º a URL a ser acessada quando clicado “Cancelar”
$MIOLO->confirmation(
$message,
$MIOLO->getActionURL( 'agenda', 'main:city', null,
array('event'=>'deleteCity','item'=>MIOLO::_REQUEST('item'))),
$MIOLO->getActionURL( 'agenda', 'main:city',null,
array('event'=>'btnSearch_click')),'','',true);
}

O método deleteCity() que será acionada quando receber a confirmação do

deleteConfirm(). Ela é responsável por deletar o registro, a partir do
Business City.

function deleteCity()
{
global $MIOLO;
$bus = $MIOLO->getBusiness('agenda', 'busCity');

// id do registro a ser deletado deve ser setado no business

$bus->idCity = MIOLO::_REQUEST('item');

// se conseguiu deletar exibe uma mensagem confirmando

// senão exibe uma mensagem de erro

if ($bus->deleteCity())
{
$msg = _M('Register Successfully Deleted!','agenda');
$this->addInfo($msg);
}
else
{
$msg = _M('Register Not Deleted! Check data and try
again','agenda');
$this->addError($msg);
}
$this -> btnSearch_click();
}
6. Business

6.1 – Business City(busCity)

Classe responsável pela interação com o Banco de Dados

Todos os campos da tabela devem ser variáveis globais, para que seja possível
os setar e acessar do form pelos métodos getData() e setData(). Também teremos
a variável $db como global, pois será uma instância da classe do miolo que
acessa diretamente o banco de dados e precisaremos dela em todos os métodos.

$db : será instanciado a classe para interagir diretamente com o

Banco de Dados

$MSQL : será instanciado a classe MSQL responsável por montar o sql

$idCity : variável com o mesmo nome no campo no form.

 $nameCity : variável com o mesmo nome no campo no form.

<?php

class BusinessAgendaBusCity extends MBusiness

{

var $db, $MSQL, $idCity, $nameCity;

No construtor do business instanciamos o $db, que executará os comandos SQL no

banco de dados configurado no módulo. Para conseguir o acesso a esse banco,
chamamos o método getDatabase() passando como parâmetro o nome do módulo.
Criamos também a classe MSQL, onde o primeiro parâmetro é uma string com os
nomes das colunas da tabela, separadas po vírgulas; o segundo é o nome das
tabelas.

function __construct()
{
global $MIOLO;
// atribuindo $db
$this->db = $MIOLO->getDatabase('agenda');

// passa-se como parâmetro o nome da tabela

$this->MSQL = new MSQL('*','city');

$this->MSQL->setDb($this->db);
}

A partir de agora criaremos todas os métodos usados em nosso formulário para

interagir com a base. Começamos com a searchCity(), usado para fazer a pesquisa
e ter seu retorno setado na grid pelo form.
public function searchCity()
{
$this->MSQL->clear(); // Limpa os dados da classe MSQL
// seta as colunas da tabela e a tabela
$this->MSQL->setColumns('id , name');
$this->MSQL->setTables('city');

/* abaixo montaremos a string com a cláusula “where” do SQL. Se o usuário

preencheu um valor nos filtros do form(que já foram setados aqui no
business pelo próprio form) ele deve ser adicionado ao “where”. */

if( $this->idCity )// se tiver id

{
$where = " and id = '".$this->idCity."'";
}
if( $this->nameCity )//se tiver nome da cidade
{
$where .= " and name like '%".$this->nameCity."%'";
}
// usado o substr para remover o and no inicio da condicao
$where = substr($where, 4 );

// Seta a condição de pesquisa no SQL

$this->MSQL->setWhere($where);

// baseado nos dados que setamos, gera automaticamente um SQL

select
$sql = $this->MSQL->select();

Para executarmos select e outros tipos de SQL que retornam dados, usamos o
método query() da classe da base. E quando usamos SQL que gravam dados, deve
ser usado o método execute(), o qual retorna um boolean trazendo o sucesso ou
não do comando.

$data = $this->db->query($sql);
// Retorna um array com os dados
return $data;
}

O método getCity() seta os dados de um regisrro nos respectivos atributos da

classe, conforme o id solicitado no form City. Usado em loadData() do
formulário, para carregar os campos antes de editar um registro.
 public function getCity($id)
{
$this->MSQL->clear();
$this->MSQL->setColumns('id , name');
$this->MSQL->setTables('city');
// seta o “where” com o id passado pelo form
$where =" id = '".$id."'";
$this->MSQL->setWhere($where);
$sql = $this->MSQL->select();
$data = $this->db->query($sql);
// atribuição dos valores retornados aos atributos do business
$this->idCity = $data[0][0];
$this->nameCity = $data[0][1];
}

Cria-se o método insertCity(), usado para inserir um novo registro. Retornará o

ID ao Form City, ou false se ocorrerem problemas.
public function insertCity()
{
// se o ID foi preenchido, testa se ele já não está em uso
// se estiver gera um novo ID pela função getNewId(),
// assim como se o ID não tiver sido preenchido
if( $this->idCity )
{
$where = " id = '".$this->idCity."'";
$this->MSQL->setWhere($where);
$sql = $this->MSQL->select();
$status = $this->db->query($sql);
if( $status ) // se o id digitado ja existe
{
$this->idCity = $this->getNewId();
}
}
else // se nao tiver id
{
$this->idCity = $this->getNewId();
}
// limpa o MSQL e seta os dados corretos
$this->MSQL->clear();

$this->MSQL->setColumns('id , name');
$this->MSQL->setTables('city');
// o método insert() do MSQL espera os dados a serem inseridos
$sql = $this->MSQL->Insert(array($this->idCity,$this->nameCity));
// como citado anteriormente, para gravar dados usamos a função
// execute(), que retornará um boolean
// caso funcione, devemos retornar o ID inserido, senão, false
if( $this->db->Execute($sql) )
{
return $this->idCity;
}
else
{
return false;
}
}
O método updateCity() insere em um registro já existente as modificações
solicitadas no Form City.

public function updateCity()

{
// insere os parâmetros corretos na MSQL
$this->MSQL->clear();
$this->MSQL->setColumns('name');
$this->MSQL->setTables('city');
$where = " id = '".$this->idCity."'";
$this->MSQL->setWhere($where);
$sql = $this->MSQL->update($this->nameCity);
// executa e retorna o resultado
$status = $this->db->execute($sql);
return $status;
}

O método deleteCity() deleta o registro com o ID setado.

public function deleteCity()

{
$this->MSQL->clear();
$this->MSQL->setTables('city');
$where = " id = '".$this->idCity."'";
$this->MSQL->setWhere($where);
$sql = $this->MSQL->delete();

$status = $this->db->execute($sql);
return $status;
}
7. Grid

7.1 – Grid City(grdCity)

Classe Grid do Formulário frmCity.

 Class grdCity extends MGrid
{
function __construct()
{
global $MIOLO;

// Cria-se um Vetor com as colunas, que são objetos de MgridColumn

// que tem como primeiro parâmetro o título, seguido do
// alinhamento, boolean para “sem quebra de linha”, tamanho,
// visibilidade, opções, boolean para ordenação
$columns = array (
new MGridColumn(_M('Id City','agenda'),'left', null, '%15',
true, null, true),
new MGridColumn(_M('City','agenda'),'left', null, '%85', true,
null, true));

// chamada do construtor da MGrid passando os parâmetros data,

// array com as colunas e a URL que ela deve acessar quando um
// evento é chamado
parent::__construct(null,$columns,$MIOLO->getCurrentURL());

// Link de Referência para o Evento “Editar” da Grid

$href_edit = $MIOLO->getActionURL( 'agenda', 'main:city', '%0%',
array( 'event' => 'loadData'));

// Link de Referência para o Evento “Deletar” da Grid

$href_delete = $MIOLO->getActionURL( 'agenda', 'main:city', '%0%',
array( 'event' => 'deleteConfirm'));

// Adiciona a Ação(Edit) com o Link de Referência na Grid

$this->addActionUpdate($href_edit);

// Adiciona a Ação(Delete) com o Link de Referência na Grid

$this->addActionDelete($href_delete);
}

8 – Lookup

8.1 – Criando Um Lookup

Exibe um campo para entrada de texto, que permite fazer pesquisas no banco de
dados. neste caso exibiremos um lookup utilizado no módulo agenda, nos forms
frmContact e frmSchedule. A classe do lookup deve ser criada dentro do
diretório db do módulo. Para criar um lookup segue-se esta estrutura:

O nome da classe deve conter Business + nome do módulo + Lookup, no caso:

BusinessAgendaLookup

<?php

class BusinessAgendaLookup extends MBusiness

{

Lookup da City. O nome da função deve ser Lookup + nome do item, no caso City.

Para adicionar filtros devemos usar a função addFilterField() do $lookup(que

recebemos pelo MIOLO por parâmetro automaticamente), passando o componente a
ser adicionado. Para pegar o valor preenchido no filtro usamos
getFilterValue(), passando o nome do campo como parâmetro.

function LookupCity(&$lookup)
{
// abaixo pegamos o valor digitado(existente se o usuário já filtrou)
// e criamos o filtro, um textField adicionado pelo addFilterField()
$cityName = $lookup->getFilterValue('cityName');

$lookup->addFilterField( new MTextField('cityName', $cityName,

_M('Name','agenda'), 40) );

// as colunas usadas no lookup devem ser do tipo MDataGridColumn()

// parâmetros: nome, título, alinhamento, boolean para “sem quebra de
// linha”, largura, visibilidade, opções, boolean para ordenação
$columns = array( new DataGridColumn('id', _M('ID'), 'left', true,
null, true), new DataGridColumn('name', _M('name'),
'left', true, null, true)
);
// é montado o SQL de busca
if( $cityName != '' ) //descripton
{
$where .= " and name LIKE '%".$cityName."%'";
}

$MIOLO = MIOLO::getInstance();
$db = $MIOLO->getDatabase('agenda');

$sql = new MSQL('id, name', 'city', '', '', '');

if( !is_null($where) )
{
$sql->setWhere( substr($where, 5) );
}
 $sql->setOrderBy('id');

// e isso tudo é setado pelo método setLookupGrid

$lookup->setLookupGrid( 'agenda', // módulo
$sql, // instância sql
$columns, // colunas
_M('Search city','agenda'), // título
10, // registros por pagina
0 ); // coluna padrão (no caso, o ID)

O MlookupTextField(componente do lookup) pode ser usado para completar

automaticamente outro campo. O nome da função responsável deve ser autoComplete
+ item, no caso City. Ela deve setar o SQL que retorna o campo a ser
preenchido, usando a variável $context passado automaticamente por parâmetro
pelo MIOLO.

public function autoCompleteCity(&$context)

{
$sql = 'SELECT name
FROM city
WHERE id = ?';

$context->setContext('agenda', $sql);
}

Abaixo o resto do arquivo de lookup, com as funções para outros dois.

 function LookupContact(&$lookup)
{

$contactName = $lookup->getFilterValue('contactName');

$lookup->addFilterField( new MTextField('contactName', $contactName,

_M('Name','agenda'), 40) );

$columns = array( new DataGridColumn('id', _M('ID'), 'left', true,

null, true), new DataGridColumn('name', _M('name'), 'left',
true, null, true)
);

if( $contactName != '' ) //descripton

{
$where .= " and name LIKE '%".$contactName."%'";
}

$MIOLO = MIOLO::getInstance();
$db = $MIOLO->getDatabase('agenda');

$sql = new MSQL('id, name', 'contact', '', '', '');

if( !is_null($where) )
{
$sql->setWhere( substr($where, 5) );
}

$sql->setOrderBy('id');

$lookup->setLookupGrid( 'agenda', //module

$sql, //instancia sql
$columns, //DatagridColumns
_M('Search city','agenda'), //título
10, //registros por pagina
0 ); //coluna padrao

Auto complete do lookup do Contact. Item Contact.

public function autoCompleteContact(&$context)

{
$sql = 'SELECT name
FROM contact
WHERE id = ?';

$context->setContext('agenda', $sql);
}

?>
8.2 – Utilizando um Lookup no Form

criar um campo MlookupTextField passado como parâmetro nome do campo, valor

inicial, label, tamanho do campo, dica, validador, campo a ser completado ( se
existir a funcao de autoComplete na classe lookup), nome do módulo, nome do
lookup a ser carregado.

$cityLookup = new MLookupTextField ('idCityContact','',null,5, null, null,

'cityDescription', 'agenda', 'city');

Adicionar o campo ao form

$this->addField($cityLookup);

9 – Gerando um Pacote com o módulo do MIOLO

Para gerar um pacote de instalaçao do miolo basta seguir os seguintes passos:

1. MODULE.INF -> Criar um arquivo module.inf dentro do diretório etc/ do

módulo. este arquivo é imprescindível para a instalação do módulo, pois nele
estarão contidas as informações do módulo. o module.inf é um arquivo em xml
que possui a seguinte estrutura:

<?xml version="1.0" encoding="ISO-8859-1"?>

<module>
<name>agenda</name>
<description>Modulo de Agenda</description>
<menu_text>Agenda</menu_text>
<version>1.0</version>
<maintainer>Miolo Team</maintainer>
<home_page>http://www.miolo.org.br</home_page>
<email>miolo@solis.coop.br</email>
<update_url>http://www.miolo.org.br</update_url>
</module>

Onde a tag name é o nome do módulo. também deverá ser o mesmo nome do arquivo
zip. A tag description é a descrição do módulo. menu_text é a tag que
pré-define o texto do menu. version é a versão do módulo. home_page, email e
update_url definem dados do desenvolvedor do módulo.
2. MODULE.CONF -> criar um arquivo xml module.conf no diretório etc/ dentro do
módulo onde serão pré-definidas informações de configuração do módulo e do
banco. Possui a seguinte estrutura:

<?xml version="1.0" encoding="ISO-8859-1"?>

<conf>
<db>
<agenda>
<system>sqlite</system>
<host>localhost</host>
<name>/home/joe/miolo2/modules/agenda/sql/agenda.sqlite
</name>
<user>miolo</user>
<password>miolo</password>
</agenda>
</db>
</conf>

Dentro da tag db colocar uma tag com o nome do módulo. a tag system define o
tipo de banco de dados a ser utilizado. A tag host define em qual host
esta o servidor do banco. A tag name define o nome do banco e as tag user e
password pré-definem um usuário e uma senha para o banco. Estas configurações
podem ser editadas durante a instalação.

3. (MÓDULO).SQL -> criar um arquivo .sql com o mesmo nome do modulo no

diretório sql/ dentro do modulo. neste caso o arquivo criado teria o nome de
agenda.sql.
4. Criar um arquivo zip do módulo. Para isto compacte o módulo em um arquivo
zip com o mesmo nome do módulo. como neste exemplo, ficaria agenda.zip.

5. Se desejar compartilhar este módulo com a comunidade Open Source do MIOLO,

envie um email com o modulo.zip para miolo@solis.coop.br que será
disponibilizado em nosso repositório on line.