ferramenta para administraÇÃo remota e … · na presente monografia é descrita uma ferramenta...
TRANSCRIPT
RICARDO JOSÉ LO FEUDO FERREIRA
FERRAMENTA PARA ADMINISTRAÇÃO REMOTA E
COLABORATIVA DE TABELAS DA AGROREDE
FLORIANÓPOLIS
2003
RICARDO JOSÉ LO FEUDO FERREIRA
FERRAMENTA PARA ADMINISTRAÇÃO REMOTA E
COLABORATIVA DE TABELAS DA AGROREDE
Monografia apresentada para obtenção do título
de bacharel em Ciências da Computação da
Universidade Federal de Santa Catarina.
Orientador: Prof. Msc. Antônio Carlos Mariani.
FLORIANÓPOLIS
2003
AGRADECIMENTOS
Agradeço ao professor A. C. Mariani pela prestativa orientação.
À minha família, que tem me apoiado sempre.
À Ana Claudia, pelas dicas de última hora, atenção e carinho.
À professora Edla pela ajuda prestada.
Aos professores do curso, que proporcionaram minha formação.
Aos colegas do projeto AgroREDE, pela ajuda e companherismo.
E a Deus, que possibilitou minha existência e faz deste planeta o local próprio para
nosso crescimento.
ii
SUMÁRIO
1. INTRODUÇÃO .............................................................................................................................................................. 1
2. APLICATIVOS PARA ADMINISTRAÇÃO REMOTA DE TABELAS DE DADOS .............................. 3
2.1. ADMINISTRADORES REMOTOS DE BASE DE DADOS............................................................................................3
2.1.1. PhpMyAdmin................................................................................................................................................... 3
2.1.2. phpPgAdmin.................................................................................................................................................... 4
2.1.3. Zaval Database Front-end............................................................................................................................ 5
2.1.4. FutureSQL....................................................................................................................................................... 6
2.1.5. myLittleAdmin................................................................................................................................................. 6
2.1.6. TableEditoR..................................................................................................................................................... 8
2.1.7. 1 Click DB Pro................................................................................................................................................ 9
2.1.8. MySQL Data Manager................................................................................................................................ 10
2.1.9. MySQL WebClient........................................................................................................................................ 11
2.1.10. IbaseAdmin.................................................................................................................................................. 12
2.1.11. Comparação Entre As Ferramentas Pesquisadas................................................................................ 13
2.2. OUTROS APLICATIVOS...........................................................................................................................................16
2.2.1. TeamWave ..................................................................................................................................................... 16
3. O SISTEMA AGROREDE ....................................................................................................................................... 17
3.1. ESTRUTURA DO SISTEMA ......................................................................................................................................17
3.2. PLATAFORMA DE IMPLEMENTAÇÃO ....................................................................................................................19
4. FERRAMENTA PARA ADMINISTRAÇÃO REMOTA E COLABORATIVA DE TABELAS DA
AGROREDE ..................................................................................................................................................................... 21
4.1. JUSTIFICATIVA.........................................................................................................................................................21
4.2. OBJETIVOS ...............................................................................................................................................................21
4.3. ESTRUTURA DA FERRAMENTA..............................................................................................................................21
4.3.1. Diagrama das Etapas da Ferramenta ..................................................................................................... 21
4.3.2. Tabelas........................................................................................................................................................... 22
4.3.3. Tipos de Dados............................................................................................................................................. 23
4.3.4. Armazenamento de Dados no MySQL ...................................................................................................... 23
4.4. COMO USAR A FERRAMENTA.................................................................................................................................24
5. TRABALHOS FUTUROS ........................................................................................................................................ 30
GLOSSÁRIO.......................................................................................................................................................................32
iii
REFERÊNCIAS .................................................................................................................................................................33
ANEXOS .............................................................................................................................................................................34
iv
LISTA DE TABELAS
TABELA 1 - COMPARATIVO DE FUNCIONALIDADES ENTRE OS ADMINISTRADORES REMOTOS
DE BASE DE DADOS......................................................................................................................................................14
TABELA 2 - COMPARATIVO DE CARACTERÍSTICAS ENTRE OS ADMINISTRADORES REMOTOS
DE BASE DE DADOS......................................................................................................................................................15
v
LISTA DE ILUSTRAÇÕES
FIGURA 1 - EXEMPLO DE CONJUNTO DE GRUPOS DO SISTEMA AGROREDE.....................................17
FIGURA 2 – DIAGRAMA DAS ETAPAS DA FERRAMENTA.............................................................................22
FIGURA 3 – PÁGINA INICIAL DO SISTEMA AGR OREDE................................................................................24
FIGURA 4 – LISTA DE TABELAS CRIADAS. .........................................................................................................25
FIGURA 5 – CRIANDO UMA NOVA TABELA. ......................................................................................................25
FIGURA 6 – ALTERANDO NOME, DESCRIÇÃO E COLUNAS DE UMA TABELA....................................26
FIGURA 7 – NOVA COLUNA FOI INSERIDA .........................................................................................................27
FIGURA 8 – VISUALIZANDO DADOS DE UMA TABELA .................................................................................28
FIGURA 9 – VISUALIZANDO DADOS DE UMA TABELA. NOVA LINHA FOI INSERIDA.....................28
vi
RESUMO
Na presente monografia é descrita uma ferramenta para administrar remota e
colaborativamente tabelas de dados. Esta ferramenta tem como público alvo usuários
leigos, de forma a apresentar uma interface simples e compreensível, porém robusta e
expansível em sua funcionalidade, dado o conhecimento do usuário.
Está inserida no sistema AgroREDE, que visa a auxiliar e fomentar o processo de
articulação dos atores rurais do meio rural familiar de Santa Catarina.
É apresentado, também, um quadro comparativo entre diferentes administradores
remotos de banco de dados, visando uma compreensão geral sobre as funcionalidades
apresentadas nestes aplicativos.
Palavras-chave : Tabelas de Dados, Agrorede, Agricultura Familiar
vii
ABSTRACT
In the present monograph a tool to remotely and cooperatively manage data tables is
described. This tool has as target group lay users, therefore, it has a simple and
understandable interface. However it’s robust and expandable in functionality.
It is inserted in the AgroREDE system, which aims to assist and to foment the
process of joint of the agricultural familiar actors of Santa Catarina.
It is presented, also, a comparative picture between different database remote
administration tools, aiming at a general understanding over the functionalities presented in
these tools.
Key-words : Data Tables, Agrorede, Familiar Agriculture
viii
1.Introdução
No meio rural de Santa Catarina, há uma quantidade de famílias que desenvolvem
uma produção pequena, para consumo próprio e comercialização de todo o excedente
produzido nas proximidades.
Algumas destas famílias desenvolvem produtos que tem durabilidade a ponto de
poderem ser vendidos em lugares mais longínquos. Para tal, um contato direto com o
consumidor tende a melhorar a renda do agricultor, na medida em que ele pode negociar
seu preço diretamente com o consumidor final.
Nestas famílias é comum encontrarmos pessoas que pararam seus estudos em
decorrência da necessidade de trabalhar. Por isso, infelizmente, no meio rural encontram-se
geralmente pessoas com pouca escolarização, e com, com dificuldades ao acesso à
informação. A informática pode proporcionar a agilização do acesso à informação e a
expansão da capacidade de atingir os consumidores. Entretanto esta tecnologia constitui-se
muitas vezes distante da acessibilidade de algumas pessoas, em alguns casos devido ao
pouco tempo de estudo, e em outros à adaptação de uma nova realidade tecnológica.
Sem a atualização dos conhecimentos sobre suas atividades de trabalho, o produtor
posiciona-se numa situação competitiva inferior à aquele que se atualiza. O rendimento e
lucro sobre o produto torna-se reduzido com o passar do tempo, pois com o advento de
novas técnicas e com o desenvolvimento de novas máquinas o processo produtivo
caracteriza-se por um aumento qualitativo e quantitativo.
O projeto AgroREDE tem como objetivo principal a implantação e estruturação de
uma rede de serviços de telemática de maneira a proporcionar uma maior integração entre
pessoas e instituições ligados à agricultura de Santa Catarina. Também visa agir na
educação sobre o uso efetivo desta rede.
Este objetivo implica, conforme [11] :
?? implantar em núcleos comunitários, centro fornecedores de serviços de
telemática;
?? alfabetizar tecnologicamente pessoas do meio rural;
?? desenvolver ou adaptar métodos pedagógicos para a alfabetização tecnológica;
?? desenvolver ou adaptar tecnologia da informação ao perfil do público alvo;
?? avaliar continuamente o impacto dos centros ao público alvo.
O sistema AgroREDE é um sistema computacional remoto e colaborativo, que
possibilita a interação entre seus usuários através de ferramentas que possibilitam a troca e
o armazenamento de informações. O público alvo do sistema são as pessoas ligadas à
agricultura de Santa Catarina, as quais são leigas com relação à informática.
Antes da construção do sistema AgroREDE, pensou-se em utilizar outros
aplicativos já conhecidos pelo mercado, para prover as funcionalidades requeridas pelo
projeto AgroREDE. Seu uso esbarrou, contudo, em questões diversas, a saber:
complexidade de administração da ferramenta, chegando em alguns casos, a exigir cursos
de formação específica, com custos incompatíveis com a realidade do projeto AgroREDE;
dificuldade de adaptação da ferramenta ás características dos usuários do projeto
AgroREDE; problema de integração de diferentes ferramentas (chat, grupos de discussão,
e-mail, biblioteca, etc) em um todo coerente, fato que confunde o usuário. Optou-se então
por desenvolver uma ferramenta própria e direcionada para a realidade da comunidade
usuária (esta ferramenta/sistema é descrita no capítulo 3).
A ferramenta para administração de tabelas é uma das ferramentas do sistema
AgroREDE. Esta ferramenta proporciona o armazenamento colaborativo de dados, porque
permite a mais de um usuário editar uma ou mais tabelas de dados. As tabelas podem ser
alteradas em sua estrutura, assim como, em seu conteúdo. Nas tabelas de dados é possível
inserir informações como funcionários de uma empresa, relação de atividades de um grupo,
ata de reunião, mobília de residência ou escritório, etc. Esta ferramenta é explicada no
capítulo 4.
No capítulo 2, descreve-se dez administradores remotos de banco de dados, os quais
foram analisados com o objetivo de conhecer suas funcionalidades, suas soluções em
termos da acessibilidade de dados e para elucidar o desenvolvimento da ferramenta de
administração remota e colaborativa de tabelas.
2
2.Aplicativos para administração remota de tabelas de dados
Com o objetivo de obter maior embasamento para a ferramenta proposta, estudei
dez administradores remotos de base de dados. O critério de escolha foram o seguinte:
funcionalidade, apresentação e (em alguns casos) estatísticas de uso no site do Source
Forge (sourceforge.net).
Todas as ferramentas pesquisadas possuem demonstrações de seu funcionamento
via Internet. Os endereços das demonstrações estão informados no capítulo de cada
ferramenta.
A pesquisa não trouxe mudanças visíveis para a ferramenta desenvolvida. Mas
proporcionou o entendimento do funcionamento, conhecimento de características técnicas e
funcionalidades disponíveis neste tipo de aplicativo. Portanto, durante o desenvolvimento
da ferramenta proposta, pude estar ciente do que poderia ou não implementar.
Foi analisado o aplicativo TeamWave, que é uma ferramenta para trabalho
colaborativo. Nesta ferramenta há um construtor de tabelas, em conjunto com outros
utilitários disponíveis. O objetivo de analisar este aplicativo, foi de entender seu
funcionamento e utilizar algumas idéias para a ferramenta desenvolvida.
2.1.Administradores Remotos de Base de Dados
2.1.1. 1 Click DB Pro
1 Click DB Pro é um servidor web para administração de banco de dados MS
Access, SQL Server e Oracle [1].
AccessHelp.net Custom Solutions comercializa esta ferramenta através do endereço:
<http://1clickdb.com/>. É cobrado uma taxa por servidor, para um número de usuários e
bancos de dados ilimitado. O código fonte é também disponibilizado, porém por taxa
adicional. A empresa disponibiliza outra ferramenta parecida, chamada 1 Click DB Free. É
um projeto de código aberto (open source), porém não contém todas as funcionalidades que
a versão paga.
3
Funcionalidades
Conforme a página na Internet da ferramenta [1], as funcionalidades são :
?? importar dados de diversos bancos de dados;
?? administrar a execução de consulta SQL, seja texto ou por arquivo;
?? criar e modificar tabelas, campos, visões, indices, stored procedures e chaves
estrangeiras;
?? procurar, exportar, adicionar, editar e remover funções.
Pré-requisitos
?? Servidor Internet Information Server (IIS) ou Personal Web Server (PWS 4 ou
superior) para Windows 95/98/NT/2000/XP.
?? Data Access Components (MDAC 2.1 ou superior).
2.1.2.FutureSQL
FutureSQL é uma ferramenta de administração de banco de dados com código
aberto (grátis). FutureSQL é escrita em Perl e usa o banco de dados MySQL. Usa um
dicionário de dados, arquivos de configuração e modelos de html.
É muito flexível e possui um conjunto extenso de opções. Pode ser usado para
funções administrativas, mas pode ser também modificado para permitir que usuários da
Internet pesquisem em tabelas de dados (sem poder alterá-las). Ainda, um
administrador/programador pode adaptá-lo para realizar um conjunto grande de funções,
provendo uma interface particular para diferentes sites da Internet.
FutureSQL foi desenvolvido por Peter F. Brown1. A versão aqui analisada é a 2.4,
lançada em 30 de outubro de 2001.
Esta ferramenta é distribuída sob a licença GNU GPL.
4
Funcionalidades
Conforme [2], FutureSQL pode :
?? alterar facilmente arquivos de configuração para ver, editar, remover e processar
registros de um banco de dados MySQL;
?? permitir o pré-processamento e pós-processamento em campos, registros e
operações;
?? permitir múltiplos arquivos de configuração para prover visões diferentes a um
mesmo conjunto de dados.
Pré-requisitos
?? Servidor de banco de dados MySQL instalado.
2.1.3.IbaseAdmin
IbaseAdmin é uma ferramenta de administração de banco de dados Interbase para a
Internet. Basea-se nos aplicativos phpMyAdmin e phpPgAdmin. Esta ferramenta é
desenvolvida pelo projeto FBT na universidade de Wageningen, um projeto com o objetivo
de criar conteúdo educacional usando tecnologia da Internet.
IbaseAdmin não requere arquivos de configuração para armazenar senhas. É feito
uma comparação entre o banco de dados indicado pelo usuário e a senha digitada, portanto
a segurança depende completamente sobre o servidor Interbase.
Esta ferramenta é licenciada sob os termos da GNU GPL. A versão analisada foi a
0.2.
5
Funcionalidades
De acordo com [3], este aplicativo pode :
?? criar e remover bancos de dados;
?? criar e modificar tabelas;
?? visualizar, remover e editar dados em tabelas;
?? adicionar e remover restrições (constraints), triggers, índices e geradores;
?? realizar cópias (backup);
?? fornecer o SQL de definição das tabelas.
Pré-requisitos
?? PHP4 (PHP3 não testado) com módulos do Interbase.
?? Servidor Interbase (somente InterBase 6 foi testado).
2.1.4.MyLittleAdmin
MyLittleAdmin é uma ferramenta de administração de banco de dados SQL Server
baseado em páginas da Internet. Permite o gerenciamento de bancos de dados mesmo
quando não puder usar o MS Enterprise Manager [4].
Esta ferramenta é distribuída comercialmente e pode ser adquirida para um único
servidor ou para uso ilimitado. Foi desenvolvida por Elian Chrebor. A versão analisada foi
a 1.5a.
Funcionalidades
Conforme a página do aplicativo na Internet [4], myLittleAdmin possui um kit para
tradução e pode :
?? criar, remover, alterar, copia e renomeia tabelas;
?? criar e remover índices;
6
?? adicionar, remover e alterar campos;
?? criar, remover e mostrar stored procedures;
?? criar, remover e mostrar gatilhos;
?? criar, remover e mostrar visões;
?? criar, remover e mostrar objetos;
?? adicionar, remover, modificar e duplicar registros;
?? executar qualquer comando SQL (incluindo stored procedures);
?? construir um comando SQL de seleção usando um auxiliar;
?? exportar o resultado de uma pesquisa em banco de dados como um arquivo CSV;
?? exportar o resultado de uma pesquisa em banco de dados como um arquivo
XML;
?? mostrar, exportar e pesquisar o conteúdo de visões.
Pré-requisitos
?? Windows NT 4.0 ou Windows 98.
?? IIS 4.0 ou Personal Web Server.
2.1.5.MySQL Data Manager
MySQL Data Manager é um aplicativo para a Internet e designado para
gerenciamento, desenvolvimento e suporte de banco de dados MySQL.
A ferramenta é desenvolvida pela empresa Edatanew.com e a versão analisada é a
1.41.
Sua distribuição é comercializada pela Internet através do endereço:
<http://www.edatanew.com/order/index.html>. Pode ser adquirido uma licença ou um
volume com várias licenças.
7
Funcionalidades
De acordo com [5], as funcionalidades são :
?? criar, salvar e editar comandos SQL, contendo múltiplas consultas;
?? criar e alterar tabelas e índices;
?? procurar por registros usando critérios múltiplos de pesquisa;
?? importar dados de arquivos texto;
?? exportar consultas, resultados de pesquisas, tabelas inteiras em arquivos texto,
para o MS Excel e MS Word;
?? administrar funções;
?? realizar e recupera cópias;
?? gerar páginas de dados para impressão;
?? permitir o ajuste da interface, alterando cores e formas.
Pré-requisitos
Servidor:
?? Qualquer servidor para Internet.
?? Perl 5 e modulos DBI e DBD::mysql.
Cliente:
?? Qualquer navegador para Internet, habilitado a usar cookies.
2.1.6.MySQL WebClient
MySQL WebClient é uma ferramenta para desenvolvimento de banco de dados
MySQL, e constitui-se de um único arquivo php. Foi desenvolvida por Virtual Internet
Developments e é licenciada sob os termos da GNU GPL, disponibilizada livremente
através da Internet. A versão analisada é a 0.0.1. Foi testada somente com os navegadores
Netscape/4.0 e Internet Explorer com habilitação a JavaScripts [6].
8
A ferramenta pode ser localizada em <http://www.vidwest.net/webclient/>.
Funcionalidades
Conforme [6], esta ferramenta :
?? permite acesso a tabelas, possibilitando configuração estrutural, entrada e saída
de dados;
?? faz a validação das consultas ao servidor no lado do cliente, minimizando a
interação com o servidor;
?? ajuda na construção de comandos SQL e executa comandos em seqüência.
Pré-requisitos
?? Servidor para Internet Apache/1.3.14 ou superior (Win32).
?? MySQL 3.23.32 ou superior.
2.1.7.PhpMyAdmin
PhpMyAdmin foi criado por Tobias Ratschiller2 e desenvolvido por ele até 2000. É
dirigido atualmente pelo phpMyAdmin devel team, em que administram: Marc Delisle,
Loïc Chapeaux e Olivier Mueller. O endereço da ferramenta na Internet é:
<http://www.phpmyadmin.net/> [7].
PhpMyAdmin pode gerenciar um servidor MySQL inteiro, mas também um único
banco de dados. Para utilizar o phpMyAdmin, será preciso criar um usuário no MySQL,
que pode ler e gravar o banco de dados desejado. A configuração do MySQL fica a cargo
do usuário.
PhpMyAdmin é distribuído sob a licença GNU GPL.
9
Funcionalidades
Conforme [7], esta ferramenta permite :
?? criar e excluir banco de dados;
?? criar, copiar, excluir e alterar tabelas;
?? adicionar, editar e excluir campos;
?? executar qualquer consulta SQL, e até consultas em seqüência;
?? gerenciar chaves primárias e estrangeiras em campos;
?? carregar arquivos de texto em tabelas;
?? criar e ler tabelas temporárias;
?? administrar múltiplos servidores e também um único banco de dados;
?? verificar integridade referencial;
?? criar pesquisas complexas, automaticamente conectando as tabelas desejadas;
?? criar gráficos em PDF da estrutura do banco de dados;
?? comunicar em mais de 41 linguagens diferentes.
Pré-requisitos
?? PHP versão 3 ou 4. phpMyAdmin usa largamente a função php “str_replace()”
que foi adicionada na versão 3.0.6, mas tinha algumas falhas até a versão 3.0.8.
Então, phpMyAdmin não deve funcionar corretamente sobre uma versão 3 inferior à
3.0.8. Php precisa ter suporte ao banco de dados MySQL;
?? banco de dados MySQL (versão 4.1.0 ou inferior);
?? um aplicativo para navegar na internet (browser).
2.1.8.phpPgAdmin
PhpPgAdmin é uma ferramenta para administrar banco de dados PostgreSQL. Pode-
se usar para criar e manter múltiplos banco de dados e também múltiplos servidores. Dan
Wilson foi o criador. A página principal da ferramenta é:
10
<http://phppgadmin.sourceforge.net/?page=home>. PhpPgAdmin é distribuído sob a
licença GNU GPL [8].
O demonstrador tem endereço na Internet em:
<http://phppgadmin.kattare.com/phpPgAdmin>. Entre com o nome do usuário (username) :
phppgadmin, e senha (password) : webdb.
Funcionalidades
De acordo com [8], o phpPgAdmin pode :
?? criar e excluir banco de dados;
?? criar, copiar, excluir e alterar tabelas, visões, seqüências, funções, indices e
triggers;
?? adicionar e editar campos;
?? executar qualquer consulta SQL, e também consultas em seqüências;
?? gerenciar chaves primárias e estrangeiras;
?? criar e ler tabelas temporárias;
?? administrar um único banco de dados;
?? administrar múltiplos servidores;
?? administrar usuários e grupos para banco de dados PostgreSQL.
Pré-requisitos
?? PHP versão 3. Sugere-se versão 4;
?? PostgreSQL versão 7 ou superior;
?? Servidor web habilitado a PHP;
?? Navegador de internet que suporta frames e Javascript;
11
2.1.9.TableEditoR
TableEditoR é uma ferramenta para administração remota de banco de dados
MSAccess, DSN e SQL Server 2000, escrita em ASP. Está sendo distribuído em versão
beta, porém é uma ferramenta funcional para muitas das necessidades dos administradores
de banco de dados.
Está sendo administrada e desenvolvida por uma comunidade (open source)
específica para esta ferramenta. Os maiores contribuintes foram Rami Kattan3 e Jeff
Wilkinson4 [9].
A versão analisada é 0.81. A ferramenta é distribuída gratuitamente, por constituir-
se de um projeto open source.
Funcionalidades
TableEditoR pode [9] :
?? realizar e armazenar pesquisas SQL;
?? adicionar, editar e remover registros;
?? acessar, pesquisar, criar, editar e remover tabelas;
?? exportar para XML;
?? exportar para o Excel;
?? criar e remover stored procedures.
Pré-requisitos
Servidor para Internet configurado.
3 http://www.kattanweb.com/webdev/ 4 [email protected]
12
2.1.10.Zaval Database Front-end
Zaval Database Front-end promove acesso a qualquer banco de dados que tenha
drivers JDBC, através de uma interface baseada em páginas de Internet, para realizar uma
série de tarefas para gerenciamento de banco de dados. Na verdade, é mais como uma
ferramenta de linha de comando, mas a saída é mais natural e fácil de usar. É muito
customizável também, pois suporta múltiplas linguagens, autenticação via https. Possibilita
qualquer execução de consulta SQL, e é limitada somente pelo SQL do banco de dados
usado [10].
Esta ferramenta pode ser usada como um componente de administração remota de
banco de dados, em quase todos os projetos na Internet baseados em java.
Esta ferramenta é do Zaval CE Group5. A página principal da ferramenta é:
<http://www.zaval.org/products/db-front-end/>. Esta ferramenta é distribuída sob a licença
GNU GPL.
Funcionalidade
Executa de todo tipo de pesquisa SQL.
Pré-requisitos
Servidor para Internet (Web Server) JSP 1.2 instalado.
2.1.11.Comparação Entre As Ferramentas Pesquisadas
Segue-se duas tabelas comparativas entre os administradores remotos de banco de
dados. A tabela abaixo é sobre as funcionalidades das ferramentas. Estão listados no início
os itens de funcionalidade mais comuns e mais ao final encontra-se alguns itens específicos.
13
Consultas ao banco
de dados por SQL X X X X X X X X X X
Administra
múltiplos bancos de
dados
X X X X X X X X
Cria, remove banco
de dados (sem SQL)X X X X X
Cria, remove, edita
tabela (sem SQL) X X X X X X X X X
Cria e remove
visões (sem SQL) X X X
Cria stored
procedures (sem
SQL)
X X X X
Cria índices (sem
SQL) X X X X X X X
Cria triggers (sem
SQL) X X X
Configura chave
primária X X X X X X X X X
Configura chave
estrangeira X X X X X X
Faz importação de
dados X X
Faz exportação de
dados X X X X
Cria consultas a
tabelas sem SQL X X X X X X X
Aplicativos
Itens de funcionalidade
14
Comunica em mais
de uma linguagem X X
Administra usuários X X X X X X X X X
A tabela a seguir concerne às características dos administradores remotos de base de
dados. Os seguintes itens foram listados: sistema operacional para instalação, linguagem
em que foi implementado e os bancos de dados que pode administrar.
Ferramenta sistema operacional
(instalação)
Linguagem em que foi
implementado
Banco de dados que
pode administrar
PhpMyAdmin - php mySQL
PhpPgAdmin - php PostgreSQL
Zaval Database Front-
End
- Jsp qualquer JDBC
FutureSQL Linux Perl MySQL
My Little Admin Windows Asp SQL Server
TableEditoR Windows Asp Microsoft Access
DSN
SQL Server
1 Click DB Pro Windows Asp Microsoft Access
SQL Server
Oracle
MySQL
MySQL Data Manager - Perl MySQL
MySQL WebClient Windows php mySQL
IbaseAdmin Linux php Interbase
Tabela 1 – comparativo de funcionalidades entre os administradores remotos de base de dados.
Tabela 2 – comparativo de características entre os administradores remotos de base de dados.
15
2.2.Outros Aplicativos
2.2.1.TeamWave
É um ambiente para trabalho colaborativo. Neste ambiente pode haver uma ou mais
salas, podendo, os usuários, trafegar entre elas. Tem algumas ferramentas para uso dos
usuários: caderno de endereços, caixa virtual para armazenar idéias, mapa conceitual, banco
de dados, elemento de porta para sair da sala, mantenedor de arquivo, visualizador de
arquivos, imagem para quadro branco, assistente para organizar reuniões, quadro de
mensagens, quadro para recados (PostIt), assistente para organizar uma lista de atividades,
mantenedor de endereço de página da Internet, assistente para votação de idéias e um
navegador de páginas da Internet. Para cada ferramenta que é utilizada, há algumas funções
disponíveis: remover, ver versões salvas, ver permissões, salvar versão, copiar para outra
sala, copiar para outro servidor e exportar para arquivo texto.
No fundo do aplicativo há um quadro branco para desenho e escrita, que
corresponde a uma sala. Há também um espaço para conversa via texto, entre os presentes
na sala.
A ferramenta de banco de dados, cria uma tabela a cada vez que seleciona-se a
ferramenta. Para cada tabela pode-se editar os campos para inserir dados. Há três tipos
possíveis para os campos: Text, Choice e Boolean.
O tipo Text corresponde a um tipo em que se permite qualquer texto. Com o tipo
Choice, deve-se digitar os valores possíveis para seleção. Com este tipo, o campo somente
receberá um dos valores que foram previamente informados. Já o tipo Boolean, permitirá a
seleção dos valores verdadeiro ou falso.
Após a configuração dos campos, pode-se adicionar os dados nas caixas localizadas
abaixo da tabela.
Mudando a permissão de uma tabela para uso de toda a sala, os dados armazenados
poderão ser compartilhados e alterados entre todos os usuários presentes na sala.
Entretanto, pode-se negar a permissão de uso para outros usuários.
As tabelas são fixas na sala em que foram criadas. Portanto, se o usuário sair da
sala, ele não verá mais a tabela, mas ao retornar ela reaparece.
O aplicativo pode ser encontrado em: <http://www.teamwave.com/>.
16
3.O Sistema AgroREDE
3.1.Estrutura do Sistema
Um grupo no sistema AgroREDE, é um ponto de encontro de pessoas que tem pelo
menos um objetivo em comum. Nele estarão disponíveis meios para que possa haver a
interação entre seus membros.
Os grupos são construídos e associados entre si de acordo com uma estrutura
hierárquica. Grupos mais genéricos, que abrangem uma quantidade maior de assuntos e
pessoas terão grupos mais específicos e menos populosos. Desta maneira, podemos
imaginar um conjunto de grupos como é demonstrado na figura abaixo.
Grupo nível Zero
Grupo nível Um
Grupo nível Dois
Grupo nível Três
Grupo nível n
Figura 1 – exemplo de conjunto de grupos do sistema AgroREDE [12].
17
Quanto à administração de um grupo, dependerá dos membros do grupo a decisão
de quais pessoas terão a função de administrar. É possível também fazer com que todas as
pessoas do grupo tenham todas as permissões, tornando-os todos administradores.
Na criação de um grupo é preciso definir o nome do grupo e quais serão os
administradores.
Na configuração de um grupo será necessário definir os papéis dos participantes.
“Um papel é um subconjunto de permissões selecionada de uma lista de prerrogativas pré-
existentes” [12].
Algumas das possíveis permissões, conforme [12], são as seguintes:
- permissão para administrar : criar e excluir grupos filhos, definir papéis, incluir
e excluir membros;
- permissão para interagir : ter acesso aos recursos do sistema podendo interagir
com pessoas e com o ambiente;
- permissão para observar : ter acesso aos recursos do sistema mas não podendo
interagir com pessoas e com o ambiente.
Cada participante do sistema AgroREDE tem a sua disposição um espaço pessoal,
onde ele pode se apresentar, informando seu nome, endereço, fotos, motivação pessoal,
entre outras informações. Neste espaço ele encontra também os grupos a que pertence, seus
papéis nestes grupos, seu histórico de participação nos grupos, entre outros [12].
O sistema AgroREDE inclui uma série de ferramentas associada aos grupos, que
visam facilitar e incrementar a participação dos usuários no sistema. Estas ferramentas
podem não ser obrigatoriamente utilizadas por todos os grupos. Há ferramentas para troca
de informações, armazenamento de dados, agendamento de atividades, dentre outras.
As ferramentas, conforme [12], são as seguintes:
- Sala de Café : constitui-se de uma sala para conversação no estilo das salas de
chat.
- E-mail : é uma ferramenta que permite a troca de mensagens entre os
participantes de um grupo.
18
- Lista de Discussão : é um meio para troca de informações via e-mail sobre um
determinado assunto.
- Mural : consiste de uma ferramenta para dispor informações em forma de um
quadro, para serem lidas por outros membros.
- Tabelas de dados : consistem de tabelas com uma determinada estrutura de
colunas, para inserção de informações.
- Planilhas de Cálculo : ferramenta que permite realizar cálculos sobre um
conjunto de dados, como média, soma, máximo, ordenação, etc.
- Agenda : é um meio para inserir informações sobre as atividades do grupo na
hora e no dia em que estão agendadas.
- Biblioteca de Documentos : é um local para guardar documentos pertencentes ao
grupo. Os documentos podem ser organizados em uma estrutura hierárquica de
pastas.
3.2.Plataforma de Implementação
Para implementação deste sistema estabeleceu-se uma plataforma, consistindo de
linguagens de programação, servidor de HTTP e banco de dados, que pudessem ser
utilizada sem custos financeiros.
As linguagens de programação escolhidas foram JSP e Java, as quais proporcionam
portabilidade de código fonte, são linguagens atuais e muito usadas mundialmente. JSP ou
Java Server Pages, é uma linguagem do tipo script, que é inserida sobre páginas de
hipertexto (Internet) escritas em HTML (ou sobre suas variantes). O JSP é executado
quando a página em que ele está inserido é carregada. Através dos seus scripts6 contendo
estruturas de controle e repetição, ele permite alteração do código HTML final. Com o
Java, foram criadas classes que são instanciadas para representação das entidades do
sistema. Ao entrar na página principal do sistema, é executado o código JSP existente nela,
que por sua vez acionará a criação de classes Java.
6 trechos de código fonte
19
O servidor de HTTP usado foi o Apache. Este servidor proporciona o acesso às
páginas do sistema através da Internet.
O banco de dados escolhido foi o mySQL, o qual é muito usado em todo o mundo
pois tem vantagens como: velocidade de execução de consultas e código fonte aberto a
todos, que o torna gratuito.
20
4.Ferramenta para administração remota e colaborativa de tabelas de dados
Esta ferramenta foi idealizada para proporcionar a construção e edição de tabelas de
dados. Foi baseada na condição de ser simples de usar, pois o público alvo do projeto, em
sua maioria, não tem experiência de uso com computadores e com sistemas de telemática.
4.1.Justificativa
O convívio com grupos que são parceiros do projeto AgroREDE, e portanto
potenciais usuários do sistema, mostra que estes grupos têm conjuntos de informações a
controlar. Exemplos destes tipos de informações são: lista de trabalhadores da instituição
ou centro que pertence, lista de tarefas, objetos, animais, compras, vendas, etc.
Percebe-se então a necessidade de uma ferramenta que possibilite,
colaborativamente, a criação, edição e consulta destas informações.
4.2.Objetivos
?? Permitir a criação, alteração e remoção das colunas de tabelas de dados.
?? Permitir a inserção, alteração e remoção de linhas em tabelas.
?? Construir uma interface simples de entender e usar.
4.3.Estrutura da Ferramenta
4.3.1.Diagrama das Etapas da Ferramenta
No uso da ferramenta, pode-se descrever uma série de etapas que ocorrem em
seqüência. Observando num contexto geral estas etapas, é possível construir um diagrama
das etapas da ferramenta (figura 2).
21
O estado inicial é representado pela lista das tabelas, entretanto, para chegar até esta
página é preciso percorrer outras etapas no sistema AgroREDE, as quais não cabem serem
descritas por esta monografia.
A transição de etapas ocorre quando o usuário interage com o sistema, realizando
uma ação de modificação ou consulta dos dados.
Figura 2 – diagrama das etapas da ferramenta.
4.3.2.Tabelas
Para cada tabela do sistema AgroREDE há uma tabela correspondente no banco de
dados mySQL.
Uma tabela é estruturada em colunas e linhas. As colunas representam
características do conjunto de informações armazenado. Cada coluna tem uma
característica especial que consiste no tipo de informação que ela permite armazenar. As
linhas são unidades de informação em uma tabela. Nelas poderão ser inseridas informações
de acordo com cada coluna da tabela.
Lista de tabelas
Editando uma tabela
Visualizando uma tabela
Remover tabela
Ver tabela
Editar tabela
Editar tabela Ver tabela
Ver outras linhas da tabela
Adicionar uma coluna Remover uma coluna
Incluir uma linha
Excluir uma linha
Criar tabela
22
4.3.3.Tipos De Dados
Há um conjunto extenso de tipos de dados disponíveis nos sistemas de banco de
dados como mySQL, Interbase, Oracle, Access, PostgreSQL, etc. Destes tipos apenas uma
parte pode ser disponibilizada no sistema AgroREDE. Os tipos escolhidos vêm de encontro
com os conjuntos de informações que os usuários do projeto AgroREDE detêm.
Os tipos são: número, texto, linha de texto, lista de opções, moeda, sim/não e data.
4.3.4.Armazenamento De Dados No MySQL
Foram criadas no banco de dados mySQL duas tabelas de controle: Tabela e
TabelaCampos. A tabela de nome “Tabela” armazena características de todas as tabelas
criadas pela ferramenta. Guarda informações como: código do grupo, nome interno, nome
externo, descrição, data de criação e código da pessoa criadora. A tabela de nome
“TabelaCampos” mantém informações sobre as colunas das tabelas criadas pela ferramenta.
Guarda informações como: código da tabela, nome externo do campo, nome interno do
campo, tipo do campo, valores de enumeração, ordem de apresentação, tamanho e se
permite valores repetidos.
Cada tabela criada na ferramenta de administração de tabelas tem uma
correspondente no banco de dados. Estas recebem o nome de “TabelaUsuarioX”, em que o
X é um número que é fornecido de acordo com a ordem de criação da tabela. Nestas tabelas
há sempre um campo chamado “cod”, que consiste na chave primária da tabela, e há um
campo para cada coluna da tabela.
23
4.4.Como Usar A Ferramenta
Ao abrir a página inicial do sistema AgroREDE, o usuário necessita digitar o e-mail
e a senha para ter acesso aos serviços.
Com a confirmação de e-mail e senha corretos, uma nova página é aberta. No lado
direito desta página há acesso as três seções do sistema: administração, área pessoal e
serviços. Clicando sobre o item de serviço Tabela, abre à direita uma página com a lista de
tabelas criadas.
Figura 3 – página inicial do sistema AgroREDE
24
Com a lista de tabelas, é possível acessar uma tabela clicando sobre o nome dela ou
sobre o botão de título “Ver”. Pode-se alterar e remover clicando sobre os botões
correspondentes. Nesta página é possível criar uma nova tabela, clicando sobre o botão de
título “Criar Tabela”. Ao clicar sobre este botão, abre uma página (figura 5) contendo um
campo para nome e outro para a descrição da tabela.
Figura 4 – lista de tabelas criadas
Figura 5 – criando uma nova tabela 25
Clicando sobre o botão de título “Criar Tabela”, abre uma página para adição de
colunas na tabela (figura 6), que na realidade é a página para alterar uma tabela.
Figura 6 – alterando nome, descrição e colunas de uma tabela.
Na imagem acima, a tabela de nome “Máquinas do LSC” contém 3 colunas num
formato de tabela. As linhas são precedidas pelas características das colunas : nome, tipo,
valores, tamanho e permite valor repetido. A característica “valores” serve somente para
colunas do tipo “Lista de Opções” e a característica “tamanho”, para colunas de tipo “Linha
de Texto”.
Sobre cada coluna há duas setas em sentidos opostos. Servem para alterar a ordem
de apresentação das colunas, quando na visualização dos dados da tabela.
Abaixo de cada coluna há um botão para remover a coluna.
Todas as características das colunas podem ser alteradas, porém a alteração do tipo
(e ainda outros) requere uma validação para impedir a inconsistência dos dados. Esta
validação não foi implementada e está listada como trabalho futuro.
26
Para inserir uma nova coluna (figura 7), deve-se clicar no botão de título “Inserir
Coluna”.
Figura 7 – nova coluna foi inserida.
No botão de título “Ver Conteúdo” (figura 7), ter-se-á acesso aos dados da tabela.
Na imagem abaixo é mostrada a página de acesso aos dados de uma tabela (figura
8). No botão de título “Alterar Colunas”, ter-se-á acesso a alteração da estrutura da tabela.
Vê-se que cada coluna, como tem um tipo diferente do outro, tem amostragem visual
também diferente. A coluna “Nome da máquina”, como tem tipo “Linha de Texto”, é
amostrada em uma caixa de texto simples. A coluna “Data de Aquisição”, com o tipo
“Data”, possui três caixas de texto com divisórias, restringindo o formato dos dados. Já a
coluna “Origem” tem tipo “Lista de Opções”, então é mostrada como uma caixa de seleção.
Abaixo dos dados da tabela é informado qual o período das linhas a serem
amostradas. As setas, também abaixo, permite o acesso a outras linhas, já que o limite por
página é de dez linhas.
27
Figura 8 – visualizando dados de uma tabela.
Clicando no botão de título “Inserir nova linha”, abre uma nova linha abaixo da
última (figura 9).
Figura 9 – visualizando dados de uma tabela. Nova linha foi inserida.
28
Para salvar as alterações realizadas, clica-se no botão “Salvar alterações”. Os dados
amostrados na página são salvos no banco de dados e a página é atualizada no navegador.
Ao lado direito de cada linha de dados há um botão cujo título é “remover”, que tem
a função de remover a linha associada.
29
5.Trabalhos futuros
Há uma série de funcionalidades que poderão ser adicionadas à ferramenta, a saber:
?? Filtro de dados : esta funcionalidade deve fazer uma pesquisa em uma tabela de
dados, retornando um conjunto que reponde verdadeiramente à uma ou mais
condições imposta pelo filtro. Ex.: Pessoas.idade >= 21. Isto é: esta condição
restringe o conjunto de dados de retorno, para que sejam buscadas somente as
pessoas com idade maior ou igual a 21.
?? Relatório : monta um documento esteticamente preparado para impressão, a
partir de uma tabela ou de um filtro.
?? Adição de novos tipos de dados : os tipos existentes tendem a não atender a todas
as necessidades de armazenamento dos usuários. A seguir estão descritos alguns
tipos de dados para serem implementados no futuro. Para cada tipo, deve-se usar
uma interface específica para características do tipo de dados.
??números reais : possibilitando armazenar números fracionados, como
valores de distâncias, pesos, larguras, tempo (em segundos, minutos ou
horas), temperatura, umidade relativa, pressão atmosférica, entre outros;
??imagem : arquivos de imagem como Jpeg, Gif e Bmp. Por exemplo:
imagens de animais, objetos, pessoas, logos, etc;
??hora : deve guardar horas e minutos. Útil para guardar a hora de uma
reunião, da chegada de aeronaves, de alteração climática, do nascimento de
animais, etc;
??arquivo : possibilitando o armazenamento de qualquer arquivo, como:
relatórios, artigos, planilhas de cálculo, documentos descritivos sobre
técnicas, entre outros.
?? Ordenação ascendente e descendente de uma tabela : a ordenação de uma tabela
consiste na organização das linhas de tabelas conforme uma ordem seqüencial
ditada por um ou mais colunas. Com esta funcionalidade, o usuário poderá mais
facilmente localizar uma informação desejada.
30
?? Importação de dados : para que o usuário não tenha trabalho desnecessário para
inserir as informações que já detém, vê-se essencial uma função de importação de
dados de documentos de texto e planilhas de cálculo.
?? Exportação de dados : uma outra funcionalidade importante é a de exportação de
dados das tabelas para documentos de texto e planilhas de cálculo. Pois é comum a
necessidade da troca de documentos e planilhas de cálculo com outras pessoas e
entidades.
?? Função de cópia de dados de uma coluna para outra : a alteração de tipos das
colunas não é possível, pois poderia causar uma inconsistência de dados, caso a
tabela contivesse dados. Por exemplo: se uma coluna tem tipo texto e é alterada para
número, os textos existentes não poderão ser convertidos para número, e então os
dados serão perdidos. Portanto, uma função de cópia de dados de uma coluna para
outra é necessária para possibilitar que o usuário crie uma nova coluna com o tipo
de dados que gostaria de alterar, e copie os dados da coluna antiga para a nova.
?? Análise ergonomica da interface : consistiria de um trabalho em que se testasse a
ferramenta com usuários reais ou potenciais em laboratório, verificando a
ergonomia da ferramenta. De acordo com a reação dos usuários com o
posicionamento dos elementos visuais nas interfaces, a seqüência de interfaces e os
elementos textuais, seria diagnosticado os problemas que atrapalhariam ou
confundiriam os usuários durante o uso da ferramenta.
31
GLOSSÁRIO
Aplicativos open source : aplicativos de código fonte aberto, aplicativos que são livres e
passíveis de modificação.
Cookie : arquivo com informações de acesso à Internet.
Ftp : protocolo para transferencia de arquivos através da Internet.
GNU GPL : general public licence - é uma licença pública que permite o uso, distribuição e
modificação de maneira gratuita.
Html : Hipertext Markup Language - linguagem para páginas de Internet.
Http (HyperText Transfer Protocol) : protocolo de transferência de hipertexto.
Https : é a utilização do protocolo HTTP (HyperText Transfer Protocol) em conjunto com o
protocolo SSL (Secure Sockets Layer), que é um protocolo proposto por um grupo liderado
pela Netscape Communications, pela Verisign e pela Sun.
Interbase : sistema de gerência de banco de dados.
MS Enterprise Manager : aplicativo para administração de banco de dados SQL Server.
MS Internet Explorer : navegador de páginas da Internet.
MySQL : sistema de gerencia de banco de dados.
Perl : linguagem de programação.
Php : linguagem de programação para a Internet.
Scripts : são trechos de códigos em uma linguagem imbutidos em código de outra
linguagem (principal).
Sítio de Internet : local na Internet, endereço em que se localiza um conjunto de páginas da
Internet (www).
Stored procedures : conjunto de instruções Transact-SQL que são executadas dentro do
banco de dados.
32
REFERÊNCIAS
[1] AccessHelp.net CS. 1 Click DB Pro. Disponível em: <http://1clickdb.com/> Acesso
em: 20 dezembro de 2002.
[2] Brown, P. FutureSQL – The Rad Web Database Tool. Disponível em:
<http://worldcommunity.com/opensource/futuresql/> Acesso em: 14 dezembro 2002.
[3] Olivier. IbaseAdmin. Disponível em: <http://pkedu.fbt.eitn.wau.nl/ibaseadmin/>
Acesso em: 3 janeiro 2003.
[4] Chrebor, E. My Little Admin – SQL Server version.
Disponível em: <http://www.mylittletools.net/scripts/en/mla_sql/default.asp> Acesso
em: 14 dezembro 2002.
[5] Edatanew.com. MySQL Data Manager. Disponível em:
<http://www.edatanew.com/> Acesso em: 3 janeiro 2003.
[6] [email protected]. MySQL WebClient. Disponível em:
<http://www.vidwest.net/webclient/> Acesso em: 3 janeiro 2003.
[7] phpMyAdmin devel team. The phpMyAdmin project. Disponível em:
<http://www.phpmyadmin.net/documentation/> Acesso em: 12 dezembro 2002.
[8] Winson, D. phpPgAdmin -- Web-bases PostgreSQL Administration. Disponível
em: <http://sourceforge.net/projects/phppgadmin/> Acesso em: 12 dezembro 2002.
[9] Kattan, Rami; Wilkinson, Jeff. TableEditoR – the legendary database tool.
Disponível em: <http://www.2enetworx.com/dev/projects/tableeditor.asp> Acesso em:
20 dezembro de 2002.
[10] Zaval CE Group. Zaval Database Front-end. Disponível em:
<http://www.zaval.org/products/db-front-end/> Acesso em: 14 dezembro 2002.
[11] Ramos, E. M. F. Versao final PSPPG.doc. BSCW do Laboratório de Sistemas de
Conhecimento - UFSC. Florianópolis, 22 janeiro 2002. 176 kbytes. Microsoft Word
97.
[12] Ramos, Prof. Dra. Edla Maria Faust. Descrição o preliminar do ambAR - ambiente
AgroREDE.doc. BSCW do Laboratório de Sistemas de Conhecimento - UFSC.
Florianópolis, 22 janeiro 2002. 56 kbytes. Microsoft Word 97.
33
ANEXOS
ANEXO 1 - ARTIGO
Ferramenta para Administração Remota e Colaborativa de Tabelas da
Agrorede
Ricardo José Lo Feudo Ferreira [email protected]
Universidade Federal de Santa Catarina - UFSC
Curso de Bacharelado em Ciências da Computação - CCO Cx.P. 476 Fone: +55 048 331-9739 - Fax: +55 048 331-9770
http://www.inf.ufsc.br/ CEP: 88040-970 Florianópolis-SC
Resumo
Neste artigo é descrita uma ferramenta para administrar remota e colaborativamente tabelas de dados. Esta ferramenta tem como público alvo usuários leigos, de forma a apresentar uma interface simples e compreensível, porém robusta e expansível em sua funcionalidade, dado o conhecimento do usuário.
Está inserida no sistema AgroREDE, que visa a auxiliar e fomentar o processo de articulação dos atores rurais do meio rural familiar de Santa Catarina.
É apresentado, também, um quadro comparativo entre diferentes administradores remotos de banco de dados, visando uma compreensão geral sobre as funcionalidades apresentadas nestes aplicativos. Palavras-chave : Tabelas de Dados, Agrorede, Agricultura Familiar
Abstract
In the present article a tool to remotely and cooperatively manage data tables is described. This tool has as target group lay users, therefore, it has a simple and understandable interface. However it’s robust and expandable in functionality.
It is inserted in the AgroREDE system, which aims to assist and to foment the process of joint of the agricultural familiar actors of Santa Catarina.
It is presented, also, a comparative picture between different database remote administration tools, aiming at a general understanding over the functionalities presented in these tools. Key-words : Data Tables, Agrorede, Familiar Agriculture
34
1.Introdução
No meio rural de Santa Catarina, há uma quantidade de famílias que desenvolvem uma produção pequena, para consumo próprio e comercialização de todo o excedente produzido nas proximidades.
Algumas destas famílias desenvolvem produtos que tem durabilidade a ponto de poderem ser vendidos em lugares mais longínquos. Para tal, um contato direto com o consumidor tende a melhorar a renda do agricultor, na medida em que ele pode negociar seu preço diretamente com o consumidor final.
O projeto AgroREDE tem como objetivo principal a implantação e estruturação de uma rede de serviços de telemática de maneira a proporcionar uma maior integração entre pessoas e instituições ligados à agricultura de Santa Catarina. Também visa agir na educação sobre o uso efetivo desta rede.
Este objetivo implica, conforme [11] : - implantar em núcleos comunitários, centro fornecedores de serviços de
telemática; - alfabetizar tecnologicamente pessoas do meio rural; - desenvolver ou adaptar métodos pedagógicos para a alfabetização tecnológica; - desenvolver ou adaptar tecnologia da informação ao perfil do público alvo; - avaliar continuamente o impacto dos centros ao público alvo.
O sistema AgroREDE é um sistema computacional remoto e colaborativo, que
possibilita a interação entre seus usuários através de ferramentas que possibilitam a troca e o armazenamento de informações. O público alvo do sistema são as pessoas ligadas à agricultura de Santa Catarina, as quais são leigas com relação à informática (este sistema é descrito no capítulo 2).
A ferramenta para administração de tabelas é uma das ferramentas do sistema AgroREDE. Esta ferramenta proporciona o armazenamento colaborativo de dados, porque permite a mais de um usuário editar uma ou mais tabelas de dados. As tabelas podem ser alteradas em sua estrutura, assim como, em seu conteúdo. Nas tabelas de dados é possível inserir informações como funcionários de uma empresa, relação de atividades de um grupo, ata de reunião, mobília de residência ou escritório, etc. Esta ferramenta é explicada no capítulo 3. 2.A Estrutura do Sistema AgroREDE
Um grupo no sistema AgroREDE, é um ponto de encontro de pessoas que tem pelo
menos um objetivo em comum. Nele estarão disponíveis meios para que possa haver a interação entre seus membros.
Os grupos são construídos e associados entre si de acordo com uma estrutura hierárquica. Grupos mais genéricos, que abrangem uma quantidade maior de assuntos e pessoas terão grupos mais específicos e menos populosos. Desta maneira, podemos imaginar um conjunto de grupos como é demonstrado na figura abaixo.
Quanto à administração de um grupo, dependerá dos membros do grupo a decisão de quais pessoas terão a função de administrar. É possível também fazer com que todas as pessoas do grupo tenham todas as permissões, tornando-os todos administradores.
35
Na criação de um grupo é preciso definir o nome do grupo e quais serão os administradores.
Na configuração de um grupo será necessário definir os papéis dos participantes. “Um papel é um subconjunto de permissões selecionada de uma lista de prerrogativas pré-existentes” [12].
Algumas das possíveis permissões, conforme [12], são as seguintes: - permissão para administrar : criar e excluir grupos filhos, definir papéis, incluir
e excluir membros; - permissão para interagir : ter acesso aos recursos do sistema podendo interagir
com pessoas e com o ambiente; - permissão para observar : ter acesso aos recursos do sistema mas não podendo
interagir com pessoas e com o ambiente. Cada participante do sistema AgroREDE tem a sua disposição um espaço pessoal,
onde ele pode se apresentar, informando seu nome, endereço, fotos, motivação pessoal, entre outras informações. Neste espaço ele encontra também os grupos a que pertence, seus papéis nestes grupos, seu histórico de participação nos grupos, entre outros [12].
O sistema AgroREDE inclui uma série de ferramentas associada aos grupos, que visam facilitar e incrementar a participação dos usuários no sistema. Estas ferramentas podem não ser obrigatoriamente utilizadas por todos os grupos. Há ferramentas para troca de informações, armazenamento de dados, agendamento de atividades, dentre outras.
As ferramentas, conforme [12], são as seguintes: - Sala de Café : constitui-se de uma sala para conversação no estilo das salas de
chat. - E-mail : é uma ferramenta que permite a troca de mensagens entre os
participantes de um grupo. - Lista de Discussão : é um meio para troca de informações via e-mail sobre um
determinado assunto. - Mural : consiste de uma ferramenta para dispor informações em forma de um
quadro, para serem lidas por outros membros. - Tabelas de dados : consistem de tabelas com uma determinada estrutura de
colunas, para inserção de informações. - Planilhas de Cálculo : ferramenta que permite realizar cálculos sobre um
conjunto de dados, como média, soma, máximo, ordenação, etc. - Agenda : é um meio para inserir informações sobre as atividades do grupo na
hora e no dia em que estão agendadas. - Biblioteca de Documentos : é um local para guardar documentos pertencentes ao
grupo. Os documentos podem ser organizados em uma estrutura hierárquica de pastas.
3.Ferramenta para administração remota e colaborativa de tabelas de dados
Esta ferramenta foi idealizada para proporcionar a construção e edição de tabelas de dados. Foi baseada na condição de ser simples de usar, pois o público alvo do projeto, em sua maioria, não tem experiência de uso com computadores e com sistemas de telemática.
36
3.1.Justificativa O convívio com grupos que são parceiros do projeto AgroREDE, e portanto
potenciais usuários do sistema, mostra que estes grupos têm conjuntos de informações a controlar. Exemplos destes tipos de informações são: lista de trabalhadores da instituição ou centro que pertence, lista de tarefas, objetos, animais, compras, vendas, etc.
Percebe-se então a necessidade de uma ferramenta que possibilite, colaborativamente, a criação, edição e consulta destas informações.
3.2.Objetivos ?? Permitir a criação, alteração e remoção das colunas de tabelas de dados. ?? Permitir a inserção, alteração e remoção de linhas em tabelas. ?? Construir uma interface simples de entender e usar.
3.3.Estrutura da Ferramenta
3.3.1.Diagrama das Etapas da Ferramenta No uso da ferramenta, pode-se descrever uma série de etapas que ocorrem em
seqüência. Observando num contexto geral estas etapas, é possível construir um diagrama das etapas da ferramenta (figura 1).
O estado inicial é representado pela lista das tabelas, entretanto, para chegar até esta página é preciso percorrer outras etapas no sistema AgroREDE, as quais não cabem serem descritas por esta monografia.
A transição de etapas ocorre quando o usuário interage com o sistema, realizando uma ação de modificação ou consulta dos dados.
37
Figura 1 – diagrama das etapas da ferramenta.
3.3.2.Tabelas
Para cada tabela do sistema AgroREDE há uma tabela correspondente no banco de dados mySQL.
Uma tabela é estruturada em colunas e linhas. As colunas representam características do conjunto de informações armazenado. Cada coluna tem uma característica especial que consiste no tipo de informação que ela permite armazenar. As linhas são unidades de informação em uma tabela. Nelas poderão ser inseridas informações de acordo com cada coluna da tabela.
3.3.3.Os Tipos de Dados
Há um conjunto extenso de tipos de dados disponíveis nos sistemas de banco de dados como mySQL, Interbase, Oracle, Access, PostgreSQL, etc. Destes tipos apenas uma parte pode ser disponibilizada no sistema AgroREDE. Os tipos escolhidos vêm de encontro com os conjuntos de informações que os usuários do projeto AgroREDE detêm.
Os tipos são: número, texto, linha de texto, lista de opções, moeda, sim/não e data.
Lista de tabelas
Editando uma tabela
Visualizando uma tabela
Remover tabela
Ver tabela
Editar tabela
Editar tabela
Ver tabela
Ver outras linhas da tabela
Adicionar uma coluna Remover uma coluna
Incluir uma linha
Excluir uma linha
Criar tabela
38
3.3.4.Armazenamento de Dados no MySQL
Foram criadas no banco de dados mySQL duas tabelas de controle: Tabela e TabelaCampos. A tabela de nome “Tabela” armazena características de todas as tabelas criadas pela ferramenta. Guarda informações como: código do grupo, nome interno, nome externo, descrição, data de criação e código da pessoa criadora. A tabela de nome “TabelaCampos” mantém informações sobre as colunas das tabelas criadas pela ferramenta. Guarda informações como: código da tabela, nome externo do campo, nome interno do campo, tipo do campo, valores de enumeração, ordem de apresentação, tamanho e se permite valores repetidos.
Cada tabela criada na ferramenta de administração de tabelas tem uma correspondente no banco de dados. Estas recebem o nome de “TabelaUsuarioX”, em que o X é um número que é fornecido de acordo com a ordem de criação da tabela. Nestas tabelas há sempre um campo chamado “cod”, que consiste na chave primária da tabela, e há um campo para cada coluna da tabela.
39
ANEXO 2 – CÓDIGO FONTE Classe ModuloTabela.java package org.agrorede; import java.sql.*; import java.util.ArrayList; import java.util.Vector; public class ModuloTabela { private ModuloMembroGrupo modulo; public void setModuloMembroGrupo( ModuloMembroGrupo modulo ) { this.modulo = modulo; } public ModuloTabela() throws ExcecaoAgrorede { } protected void finalize() throws ExcecaoAgrorede{ modulo = null; } public Connection getConexao(){ return modulo.getConexao(); } private Pessoa getPessoa(){ return modulo.getPessoa(); } private Grupo getGrupo(){ return modulo.getGrupo(); } public boolean temPermissaoPara(String verbo, String objeto) { return modulo.temPermissaoPara(verbo, objeto); } // -------------------------------------------------------------------------------------------- public int criaTabela(String nomeExternoTabela, String descricao, int codigoGrupo) throws ExcecaoAgrorede { /* Cria uma tabela */ if (!this.temPermissaoPara("Criar","Tabela")) { throw new ExcecaoAgrorede("Sem Permissão para Criar Tabela"); } try { Tabela tab = new Tabela(); tab.setNomeExterno( nomeExternoTabela ); tab.setDescricao( descricao ); if (codigoGrupo == -1) { tab.setCodigoGrupo( this.getGrupo().getCodigo() ); } else { tab.setCodigoGrupo( codigoGrupo ); } //falta o codigo da pessoa criadora tab.insert( modulo.getConexao() );
40
return tab.getCodigo(); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void alteraTabela(int codigoTabela, String nomeExternoTabela, String descricao, Vector campos) throws ExcecaoAgrorede { /* Altera características de uma tabela */ if ( ! this.temPermissaoPara("Alterar", "Tabela") ) { throw new ExcecaoAgrorede("Sem Permissão para Alterar Tabela"); } try { //atualiza o nome e descrição da tabela Tabela tab = this.tabelaDadoCodigo( codigoTabela ); tab.setNomeExterno( nomeExternoTabela ); tab.setDescricao( descricao ); tab.update( modulo.getConexao() ); for (int i=0;i<campos.size();i++) { tab.updateCampo( modulo.getConexao(), (Vector) campos.get(i) ); } } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void removeTabela(int codigoTabela) throws ExcecaoAgrorede { /* Remove uma tabela */ if ( ! this.temPermissaoPara("Remover", "Tabela") ) { throw new ExcecaoAgrorede("Sem Permissão para Remover Tabela"); } try { Tabela tab = this.tabelaDadoCodigo(codigoTabela); tab.remove(modulo.getConexao()); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void insereRegistro(int codigoTabela) throws ExcecaoAgrorede { /* Insere um registro em uma tabela */ //if ( ! this.temPermissaoPara("InserirRegistro","Tabela") ) { // throw new ExcecaoAgrorede("Sem Permissão para inserir linhas."); //} Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); umaTabela.insertRegistro( modulo.getConexao() ); } public void alteraRegistro(int codigoTabela, int codigoRegistro, Vector vetorRegistro) throws ExcecaoAgrorede { /* Atualiza o registro */ if ( ! this.temPermissaoPara("AlterarRegistro","Tabela") ) { throw new ExcecaoAgrorede("Sem Permissão para alterar linhas."); } Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); umaTabela.updateRegistro( modulo.getConexao(), codigoRegistro, vetorRegistro ); } public void removeRegistro(int codigoTabela, int codigoRegistro) throws ExcecaoAgrorede { /* Remove um registro em uma tabela */
41
if ( ! this.temPermissaoPara("RemoverRegistro","Tabela") ) { throw new ExcecaoAgrorede("Sem Permissão para remover linhas."); } Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); try { PreparedStatement sql = modulo.getConexao().prepareStatement( "DELETE FROM `"+umaTabela.getNomeInterno()+"` WHERE cod = ?" ); sql.setInt( 1, codigoRegistro ); sql.execute(); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void insereCampo(int codigoTabela) throws ExcecaoAgrorede { /* Insere um campo na tabela */ if ( ! this.temPermissaoPara("InserirCampo","Tabela") ) { throw new ExcecaoAgrorede("Sem Permissão para inserir colunas."); } Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); umaTabela.insertCampo( modulo.getConexao() ); } public void removeCampo(int codigoTabela, String nomeCampo) throws ExcecaoAgrorede { /* Remove um campo na tabela */ if ( ! this.temPermissaoPara("RemoverCampo","Tabela") ) { throw new ExcecaoAgrorede("Sem Permissão para remover colunas."); } Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); umaTabela.removeCampo( modulo.getConexao(), nomeCampo ); } public void alteraOrdemCampo(int codigoTabela, String nomeCampo, int orientacao) throws ExcecaoAgrorede { /* Altera a ordem de amostragem de um campo */ Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); umaTabela.updateOrdemCampo( modulo.getConexao(), nomeCampo, orientacao ); } //-------------------------------------------------------------------------------------------- public ArrayList tabelasDadaExpressaoSql(String expressaoSql) throws ExcecaoAgrorede { try { Statement sql = modulo.getConexao().createStatement(); ResultSet resultado = sql.executeQuery(expressaoSql); ArrayList tabelas = new ArrayList(); while(resultado.next()){ tabelas.add(new Tabela(resultado)); } return tabelas; } catch ( SQLException e ) { throw new ExcecaoAgrorede(e.getMessage()); } } public ResultSet registrosDadaExpressaoSql(String expressaoSql) throws ExcecaoAgrorede { try { Statement sql = modulo.getConexao().createStatement();
42
ResultSet resultado = sql.executeQuery(expressaoSql); return resultado; } catch ( SQLException e ) { throw new ExcecaoAgrorede(e.getMessage()); } } public Tabela tabelaDadoCodigo(int codigoTabela) throws ExcecaoAgrorede { ArrayList tabelas = tabelasDadaExpressaoSql( "SELECT * FROM `Tabela` WHERE codigo = " + codigoTabela ); if (tabelas.size() == 0){ throw new ExcecaoAgrorede("Não foi encontrado a tabela: " + codigoTabela); } else { return (Tabela)tabelas.get(0); } } public Tabela tabelaDadoNome(String nomeTabela) throws ExcecaoAgrorede { ArrayList tabelas = tabelasDadaExpressaoSql( "SELECT * FROM `Tabela` WHERE nome = '" + nomeTabela + "'"); if (tabelas.size() == 0){ throw new ExcecaoAgrorede("Não foi encontrado a tabela: " + nomeTabela ); } else { return (Tabela)tabelas.get(0); } } public ArrayList tabelas() throws ExcecaoAgrorede{ return tabelasDadaExpressaoSql("SELECT * FROM Tabela ORDER BY codigo"); } public ResultSet registrosDadoTabela( int codigoTabela, int inicioPeriodo, int fimPeriodo ) throws ExcecaoAgrorede { Tabela umaTabela = this.tabelaDadoCodigo( codigoTabela ); return umaTabela.registros( modulo.getConexao(), inicioPeriodo, fimPeriodo ); } public ResultSet camposDadaTabela(int codigoTabela) throws ExcecaoAgrorede { try { Tabela umaTabela = this.tabelaDadoCodigo(codigoTabela); return umaTabela.campos( modulo.getConexao() ); } catch (ExcecaoAgrorede e) { throw new ExcecaoAgrorede(e.getMessage()); } } public Vector valoresEnumeracaoCampo(int codigoTabela, String nomeInternoCampo) throws ExcecaoAgrorede { try { Vector valores = new Vector(); ResultSet campos = this.camposDadaTabela(codigoTabela); while (campos.next()) { if (campos.getString("nomeInternoCampo").equals(nomeInternoCampo)) { String textoValores = campos.getString("valoresEnumeracao"); int i = 0; int j = 0; while (i < textoValores.length()) { if (textoValores.charAt(i) == ',') {
43
valores.add( textoValores.substring( j, i ).trim() ); j = i+1; } i = i+1; } valores.add( textoValores.substring( j, i ).trim() ); } } return valores; } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public Vector ultimoPeriodoDe(int codigoTabela) throws ExcecaoAgrorede { Vector periodo = new Vector(); int quantReg = this.quantRegistros(codigoTabela); int i = quantReg/10; if (i == 0) { periodo.add( String.valueOf(1) ); } else { periodo.add( String.valueOf(i*10) ); } periodo.add( String.valueOf(quantReg) ); return periodo; } public int quantRegistros(int codigoTabela) throws ExcecaoAgrorede { Tabela umaTabela = this.tabelaDadoCodigo(codigoTabela); return umaTabela.quantRegistros(modulo.getConexao()); } public Vector verificaPeriodoDe(int codigoTabela, int inicioPeriodo, int fimPeriodo) throws ExcecaoAgrorede { Vector periodo = new Vector(); int quantReg = this.quantRegistros(codigoTabela); int i = quantReg/10; if (i == 0) { periodo.add( String.valueOf(1) ); periodo.add( String.valueOf(quantReg) ); } else { if (inicioPeriodo > quantReg) { periodo.add( String.valueOf(i*10) ); periodo.add( String.valueOf(quantReg) ); } else { if (fimPeriodo > quantReg) { periodo.add( String.valueOf(inicioPeriodo) ); periodo.add( String.valueOf(quantReg) ); } else {//inicioPeriodo < quantReg < fimPeriodo periodo.add( String.valueOf(inicioPeriodo) ); periodo.add( String.valueOf(fimPeriodo) ); } } } return periodo; } public Vector dezAnterioresDe(int codigoTabela, int inicioPeriodo, int fimPeriodo) throws ExcecaoAgrorede { Vector periodo = new Vector(); int quantReg = this.quantRegistros(codigoTabela); int i = quantReg/10; if (i == 0) {
44
periodo.add( String.valueOf(1) ); periodo.add( String.valueOf(quantReg) ); } else { if (inicioPeriodo == 1) { periodo.add( String.valueOf(1) ); periodo.add( String.valueOf(10) ); } else { if ((inicioPeriodo-10) > quantReg) { periodo.add( String.valueOf(i*10) ); periodo.add( String.valueOf(quantReg) ); } else { periodo.add( String.valueOf(inicioPeriodo-10) ); periodo.add( String.valueOf(fimPeriodo-10) ); } } } return periodo; } public Vector proximosDezDe(int codigoTabela, int inicioPeriodo, int fimPeriodo) throws ExcecaoAgrorede { Vector periodo = new Vector(); int quantReg = this.quantRegistros(codigoTabela); int i = quantReg/10; if (i == 0) { periodo.add( String.valueOf(1) ); periodo.add( String.valueOf(quantReg) ); } else { if (inicioPeriodo > quantReg) { periodo.add( String.valueOf(i*10) ); periodo.add( String.valueOf(quantReg) ); } else { if (fimPeriodo > quantReg) { periodo.add( String.valueOf(inicioPeriodo) ); periodo.add( String.valueOf(quantReg) ); } else { if ((fimPeriodo+10) > quantReg) { periodo.add( String.valueOf(inicioPeriodo+10) ); periodo.add( String.valueOf(quantReg) ); } else { periodo.add( String.valueOf(inicioPeriodo+10) ); periodo.add( String.valueOf(fimPeriodo+10) ); } } } } return periodo; } public int tamanhoResultSet(ResultSet rs) throws SQLException { int tamanho = 0; rs.beforeFirst(); while (rs.next()) { tamanho += 1; } rs.beforeFirst(); return tamanho; } public boolean haTipoEmAlgumCampoDaTabela( int codigoTabela, String tipoExterno ) throws ExcecaoAgrorede { try { Tabela umaTabela = this.tabelaDadoCodigo(codigoTabela);
45
ResultSet rs = umaTabela.campos( modulo.getConexao() ); boolean haTipo = false; while (rs.next()) { if (rs.getString("tipoCampo").equals(tipoExterno)) { haTipo = true; } } return haTipo; } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public String tipoDeCampoDeTabela( int codigoTabela, String nomeInternoCampo ) throws ExcecaoAgrorede { try { Tabela umaTabela = this.tabelaDadoCodigo(codigoTabela); ResultSet rs = umaTabela.campos( modulo.getConexao() ); String tipo = ""; while (rs.next()) { if (rs.getString("nomeInternoCampo").equals(nomeInternoCampo)) { tipo = rs.getString("tipoCampo"); } } return tipo; } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } //--------------------------------------------------------------------------------------------- } Classe Tabela.java package org.agrorede; import java.sql.*; import java.sql.Date; import java.util.Vector; public class Tabela { public static String TIPOEXTERNO_DATA = "Data"; public static String TIPOEXTERNO_LINHADETEXTO = "Linha de Texto"; public static String TIPOEXTERNO_LISTADEOPCOES = "Lista de Opções"; public static String TIPOEXTERNO_MOEDA = "Moeda"; public static String TIPOEXTERNO_NUMERO = "Número"; public static String TIPOEXTERNO_SIMNAO = "Sim/Não"; public static String TIPOEXTERNO_TEXTO = "Texto"; public static String TIPOINTERNO_DATA = "DATE"; public static String TIPOINTERNO_LINHADETEXTO = "VARCHAR"; public static String TIPOINTERNO_LISTADEOPCOES = "VARCHAR"; public static String TIPOINTERNO_MOEDA = "DECIMAL"; public static String TIPOINTERNO_NUMERO = "INT"; public static String TIPOINTERNO_SIMNAO = "INT"; public static String TIPOINTERNO_TEXTO = "TEXT"; public Tabela() {
46
} public Tabela(ResultSet resultadoSQL) throws SQLException { this.setCodigo(resultadoSQL.getInt("codigo")); this.setCodigoGrupo(resultadoSQL.getInt("codigoGrupo")); this.setNomeInterno(resultadoSQL.getString("nomeInterno")); this.setNomeExterno(resultadoSQL.getString("nomeExterno")); this.setDescricao(resultadoSQL.getString("descricao")); this.setDataCriacao(resultadoSQL.getDate("dataCriacao")); this.setCodigoPessoaCriador(resultadoSQL.getInt("codigoPessoaCriador")); } public boolean equals(Object tab) { if (! (tab instanceof Tabela) ) { return false; } return ((Tabela)tab).getCodigo() == this.getCodigo(); } public int hashCode() { return this.getCodigo(); } //--------------------------------------------------------------------------------------------- public void insert(Connection db) throws SQLException { //insere o registro em Tabela, com as informações da nova tabela PreparedStatement sql = db.prepareStatement( "INSERT INTO `Tabela` (`codigo`, `codigoGrupo`, `nomeInterno`, `nomeExterno`,"+ "`descricao`, `dataCriacao ,̀ `codigoPessoaCriador`)" + " VALUES ('', ?, ?, ?, ?, ?, ? )"); sql.setInt(1,this.codigoGrupo); this.setNomeInterno( "TabelaUsuario" ); sql.setString(2,this.nomeInterno); sql.setString(3,this.nomeExterno); sql.setString(4,this.descricao); sql.setDate(5,new Date( (new java.util.Date()).getTime() )); sql.setInt(6,this.codigoPessoaCriador); sql.execute(); //atualiza o nome interno da tabela no registro em Tabela sql = db.prepareStatement( "SELECT codigo FROM `Tabela` WHERE nomeExterno = ? AND codigoGrupo = ? "); sql.setString(1,this.nomeExterno); sql.setInt(2,this.codigoGrupo); sql.execute(); ResultSet resultado = sql.getResultSet(); resultado.next(); setCodigo( resultado.getInt("codigo")); this.setNomeInterno( "TabelaUsuario"+this.getCodigo() ); this.update( db ); //cria a tabela fisicamente no banco de dados sql = db.prepareStatement( "CREATE TABLE `"+this.getNomeInterno()+"` ("+ "`cod` INT NOT NULL AUTO_INCREMENT PRIMARY KEY);" ); sql.execute(); }
47
public void update(Connection db) throws SQLException { PreparedStatement sql = db.prepareStatement( "UPDATE `Tabela` "+ "SET nomeExterno = ?, descricao = ?, codigoGrupo = ?, nomeInterno = ? " + "WHERE codigo = ?"); sql.setString(1,this.nomeExterno); sql.setString(2,this.descricao); sql.setInt(3,this.codigoGrupo); sql.setString(4,this.nomeInterno); sql.setInt(5,this.codigo); sql.execute(); } public void remove(Connection db) throws SQLException { PreparedStatement sql = db.prepareStatement( "DELETE FROM `Tabela` WHERE codigo = ?"); sql.setInt(1,this.codigo); sql.execute(); sql = db.prepareStatement("DROP TABLE "+this.getNomeInterno()); sql.execute(); } public ResultSet campos(Connection db) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement( "SELECT * FROM `TabelaCampos` WHERE codigoTabela = ? ORDER BY ordemApresentacaoCampo" ); sql.setInt( 1, codigo ); return sql.executeQuery(); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public int quantCampos(Connection db) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement( "SELECT COUNT(*) AS NumCampos FROM `TabelaCampos` WHERE codigoTabela = ?" ); sql.setInt( 1, codigo ); ResultSet rs = sql.executeQuery(); rs.next(); return rs.getInt("NumCampos"); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public int quantRegistros(Connection db) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement( "SELECT COUNT(*) AS NumRegistros FROM `"+this.getNomeInterno()+"`" ); ResultSet rs = sql.executeQuery(); rs.next(); return rs.getInt("NumRegistros"); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } }
48
public void insertCampo(Connection db) throws ExcecaoAgrorede { try { //insere o registro do novo campo em TabelaCampos PreparedStatement sql = db.prepareStatement( "INSERT INTO `TabelaCampos` "+ "(`codigoTabela`, `nomeInternoCampo`,`ordemApresentacaoCampo`, `tipoCampo` ) VALUES ( ?, ?, ?, ? )" ); String nomeInternoCampo = this.getProximoNomeCampo(db); sql.setInt( 1, this.getCodigo() ); sql.setString( 2, nomeInternoCampo ); sql.setInt( 3, this.getProximoValorApresentacaoCampo(db) ); sql.setString( 4, TIPOEXTERNO_LINHADETEXTO ); sql.execute(); //altera o campo no banco de dados sql = db.prepareStatement( "ALTER TABLE `"+this.getNomeInterno()+"` ADD `"+nomeInternoCampo+"` VARCHAR(50) NOT NULL" ); sql.execute(); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void updateCampo(Connection db, Vector vetorCampo) throws ExcecaoAgrorede { try { //atualiza dados do campo PreparedStatement sql = db.prepareStatement( "UPDATE `TabelaCampos` "+ "SET nomeExternoCampo = ?, tipoCampo = ?, valoresEnumeracao = ?,"+ " tamanhoCampo = ?, permiteRepetido = ? "+ "WHERE nomeInternoCampo = ? "+ " AND codigoTabela = ?" ); sql.setString( 1, (String) vetorCampo.get(1) ); String tipo = ((String) vetorCampo.get(2)).trim(); sql.setString( 2, tipo ); if (((String) vetorCampo.get(2)).equals(TIPOEXTERNO_LISTADEOPCOES)) { sql.setString( 3, (String) vetorCampo.get(3) ); } else { sql.setString( 3, "" ); } String tamanho = ""; if (vetorCampo.get(4) == null) { sql.setInt( 4, 0 ); } else { tamanho = (String) vetorCampo.get(4); if (tamanho.equals("")) { sql.setInt( 4, 0 ); } else { sql.setInt( 4, Integer.parseInt(tamanho) ); } } sql.setString( 5, (String) vetorCampo.get(5) ); String nomeInternoCampo = (String) vetorCampo.get(0); sql.setString( 6, nomeInternoCampo ); sql.setInt( 7, this.getCodigo() ); sql.execute(); //altera o campo no banco de dados
49
if (tipo.equals(TIPOEXTERNO_LINHADETEXTO)) { //se o tamanho for vazio ou zero, deve ser igual a 50 if ((tamanho.equals("")) | (tamanho.equals("0"))) { tamanho = "50"; } sql = db.prepareStatement( "ALTER TABLE `"+this.getNomeInterno()+"` CHANGE `"+nomeInternoCampo+ "` `"+nomeInternoCampo+"` "+this.getTipoInternoDe(tipo)+"("+tamanho+")" ); } if (tipo.equals(TIPOEXTERNO_LISTADEOPCOES)) { sql = db.prepareStatement( "ALTER TABLE `"+this.getNomeInterno()+"` CHANGE `"+nomeInternoCampo+ "` `"+nomeInternoCampo+"` "+this.getTipoInternoDe(tipo)+"(50)" ); } if ((!tipo.equals(TIPOEXTERNO_LINHADETEXTO)) & (!tipo.equals(TIPOEXTERNO_LISTADEOPCOES))) { sql = db.prepareStatement( "ALTER TABLE `"+this.getNomeInterno()+"` CHANGE `"+nomeInternoCampo+ "` `"+nomeInternoCampo+"` "+this.getTipoInternoDe(tipo) ); } sql.execute(); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void removeCampo(Connection db, String nomeInternoCampo) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement( "DELETE FROM `TabelaCampos` WHERE nomeInternoCampo = ?"); sql.setString( 1, nomeInternoCampo ); sql.execute(); sql = db.prepareStatement("ALTER TABLE `"+this.getNomeInterno()+"` DROP `"+nomeInternoCampo+"`" ); sql.execute(); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void updateOrdemCampo(Connection db, String nomeInternoCampo, int orientacao) throws ExcecaoAgrorede { try { //busca a ordem do campo que se quer trocar (1) PreparedStatement sql = db.prepareStatement( "SELECT ordemApresentacaoCampo FROM `TabelaCampos` "+ "WHERE nomeInternoCampo = ?"+ " AND codigoTabela = ?" ); sql.setString( 1, nomeInternoCampo ); sql.setInt( 2, this.getCodigo() ); sql.execute(); ResultSet resultado = sql.getResultSet();
50
resultado.next(); int ordemCampo1 = resultado.getInt("ordemApresentacaoCampo"); if (((orientacao==0) & (ordemCampo1>1)) | ((orientacao==1) & (ordemCampo1<this.quantCampos(db)))) { //busca o nome do outro campo (2), que será trocado, com o valor da orientação (0=acima;1=abaixo) sql = db.prepareStatement( "SELECT nomeInternoCampo FROM `TabelaCampos` "+ "WHERE ordemApresentacaoCampo = ?"+ " AND codigoTabela = ?" ); if (orientacao==0) { sql.setInt( 1, ordemCampo1-1 ); } else { sql.setInt( 1, ordemCampo1+1 ); } sql.setInt( 2, this.getCodigo() ); sql.execute(); resultado = sql.getResultSet(); resultado.next(); String nomeCampo2 = resultado.getString("nomeInternoCampo"); //atualiza o campo 1 sql = db.prepareStatement( "UPDATE `TabelaCampos` "+ "SET ordemApresentacaoCampo = ? "+ "WHERE nomeInternoCampo = ?"+ " AND codigoTabela = ?" ); if (orientacao==0) { sql.setInt( 1, ordemCampo1-1 ); } else { sql.setInt( 1, ordemCampo1+1 ); } sql.setString( 2, nomeInternoCampo ); sql.setInt( 3, this.getCodigo() ); sql.execute(); //atualiza o campo 2 sql = db.prepareStatement( "UPDATE `TabelaCampos` "+ "SET ordemApresentacaoCampo = ? "+ "WHERE nomeInternoCampo = ?"+ " AND codigoTabela = ?" ); sql.setInt( 1, ordemCampo1 ); sql.setString( 2, nomeCampo2 ); sql.setInt( 3, this.getCodigo() ); sql.execute(); } } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public void insertRegistro(Connection db) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement( "INSERT INTO `"+this.getNomeInterno()+ "` ( `cod` ) VALUES ( '' )" ); sql.execute(); } catch (SQLException e) {
51
throw new ExcecaoAgrorede(e.getMessage()); } } public void updateRegistro(Connection db, int codigoRegistro, Vector vetorRegistro) throws ExcecaoAgrorede { ResultSet campos = this.campos(db); String textoSql; try { Statement sql = db.createStatement(); textoSql = "UPDATE `"+this.getNomeInterno()+"` SET "; for (int i=0;i<vetorRegistro.size();i++) { textoSql = textoSql+"`"+(String)((Vector)vetorRegistro.get(i)).get(0)+"` = '"+ (String)((Vector)vetorRegistro.get(i)).get(1)+"'"; if (i < (vetorRegistro.size()-1)) { textoSql = textoSql+","; } } textoSql = textoSql + " WHERE `cod` = "+codigoRegistro; sql.executeQuery( textoSql ); } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public String getTipoInternoDe(String tipoExterno) { if (tipoExterno.equals(TIPOEXTERNO_DATA)) { return TIPOINTERNO_DATA; } if (tipoExterno.equals(TIPOEXTERNO_LINHADETEXTO)) { return TIPOINTERNO_LINHADETEXTO; } if (tipoExterno.equals(TIPOEXTERNO_LISTADEOPCOES)) { return TIPOINTERNO_LISTADEOPCOES; } if (tipoExterno.equals(TIPOEXTERNO_MOEDA)) { return TIPOINTERNO_MOEDA; } if (tipoExterno.equals(TIPOEXTERNO_NUMERO)) { return TIPOINTERNO_NUMERO; } if (tipoExterno.equals(TIPOEXTERNO_SIMNAO)) { return TIPOINTERNO_SIMNAO; } if (tipoExterno.equals(TIPOEXTERNO_TEXTO)) { return TIPOINTERNO_TEXTO; } return ""; } public String getProximoNomeCampo(Connection db) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement("SELECT * FROM `TabelaCampos` WHERE codigoTabela = ?"); sql.setInt( 1, this.getCodigo() ); sql.execute(); ResultSet resultado = sql.getResultSet(); int cont = 0; while (resultado.next()) { cont += 1; } return "campo"+String.valueOf(cont+1);
52
} catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public int getProximoValorApresentacaoCampo(Connection db) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement("SELECT MAX(ordemApresentacaoCampo) AS Maximo FROM `TabelaCampos` WHERE codigoTabela = ?"); sql.setInt( 1, this.getCodigo() ); sql.execute(); ResultSet resultado = sql.getResultSet(); resultado.next(); int ultimo = resultado.getInt("Maximo"); ultimo = ultimo + 1; return ultimo; } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } public ResultSet registros(Connection db, int inicioPeriodo, int fimPeriodo) throws ExcecaoAgrorede { try { PreparedStatement sql = db.prepareStatement( "SELECT nomeInterno FROM Tabela WHERE codigo = ?" ); sql.setInt( 1, this.getCodigo() ); ResultSet resultado = sql.executeQuery(); resultado.first(); sql = db.prepareStatement( "SELECT * FROM "+resultado.getString("nomeInterno")+" LIMIT "+String.valueOf(inicioPeriodo-1)+", "+String.valueOf(fimPeriodo) ); resultado = sql.executeQuery(); return resultado; } catch (SQLException e) { throw new ExcecaoAgrorede(e.getMessage()); } } //--------------------------------------------------------------------------------------------- public int getCodigo() { return codigo; } private void setCodigo(int codigo) { this.codigo = codigo; } public int getCodigoGrupo() { return codigoGrupo; } public void setCodigoGrupo(int codigoGrupo) { this.codigoGrupo = codigoGrupo; } public int getCodigoPessoaCriador() {
53
return codigoPessoaCriador; } private void setCodigoPessoaCriador(int codigoPessoaCriador) { this.codigoPessoaCriador = codigoPessoaCriador; } public Date getDataCriacao() { return dataCriacao; } private void setDataCriacao(Date dataCriacao) { this.dataCriacao = dataCriacao; } public String getDescricao() { return descricao; } public void setDescricao(String descricao) { this.descricao = descricao; } public String getNomeExterno() { return nomeExterno; } public void setNomeExterno(String nomeExterno) { this.nomeExterno = nomeExterno; } public String getNomeInterno() { return nomeInterno; } private void setNomeInterno(String nomeInterno) { this.nomeInterno = nomeInterno; } //--------------------------------------------------------------------------------------------- /** * auto_increment * @rdbPhysicalName codigo * @rdbNotNull * @rdbSize 11 * @rdbDigits 0 * @rdbLogicalType INTEGER * @rdbPrimaryKey */ private int codigo; /** * * @rdbPhysicalName codigoGrupo * @rdbNotNull * @rdbSize 11 * @rdbDigits 0 * @rdbLogicalType INTEGER */ private int codigoGrupo; /**
54
* * @rdbPhysicalName nomeInterno * @rdbNotNull * @rdbSize 50 * @rdbDigits 0 * @rdbLogicalType VARCHAR */ private String nomeInterno; /** * * @rdbPhysicalName nomeExterno * @rdbNotNull * @rdbSize 50 * @rdbDigits 0 * @rdbLogicalType VARCHAR */ private String nomeExterno; /** * * @rdbPhysicalName descricao * @rdbSize 200 * @rdbDigits 0 * @rdbLogicalType VARCHAR */ private String descricao; /** * * @rdbPhysicalName dataCriacao * @rdbNotNull * @rdbSize 10 * @rdbDigits 0 * @rdbLogicalType DATE */ private Date dataCriacao; /** * * @rdbPhysicalName codigoPessoaCriador * @rdbNotNull * @rdbSize 11 * @rdbDigits 0 * @rdbLogicalType INTEGER */ private int codigoPessoaCriador; } //--------------------------------------------------------------------------------------------- Arquivo alteraOrdemCampo.jsp <%@ page import="org.agrorede.*"%> <%@ page import="java.sql.ResultSet" %> <%@ page import="java.util.Vector" %> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" />
55
<% String campo = request.getParameter("campo"); String orientacao = request.getParameter("orientacao"); moduloTabela.alteraOrdemCampo( Integer.parseInt(tabela), campo, Integer.parseInt(orientacao) ); %> <jsp:forward page="../index.jsp?objeto=Tabela&acao=Alterar" /> Arquivo alteraTabela.jsp <%@ page import="java.sql.ResultSet" %> <%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="objeto" class="java.lang.String" scope="session" /> <jsp:useBean id="acao" class="java.lang.String" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <% boolean podeIncluirCampo = moduloTabela.temPermissaoPara("IncluirCampo", "Tabela"); boolean podeAlterarCampo = moduloTabela.temPermissaoPara("AlterarCampo", "Tabela"); boolean podeRemoverCampo = moduloTabela.temPermissaoPara("RemoverCampo", "Tabela"); Tabela umaTabela; if (request.getParameter("tabela") != null) { session.setAttribute("tabela", request.getParameter("tabela")); umaTabela = moduloTabela.tabelaDadoCodigo(Integer.parseInt(request.getParameter("tabela"))); } else { umaTabela = moduloTabela.tabelaDadoCodigo(Integer.parseInt(tabela)); } %> <center> <h1> <%=umaTabela.getNomeExterno()%></h1> </center> <form action="index.jsp?objeto=Tabela&acao=SalvarCampos" method="post"> <table> <tr> <th><p align="right">Nome : </p></th> <td><input type="edit" name="nomeTabela" value="<%=umaTabela.getNomeExterno()%>"></td> </tr> <tr> <th><p align="right">Descrição : </p></th> <td><textarea name="descricaoTabela" rows="5" cols="100"><%=umaTabela.getDescricao()%></textarea></td> </tr> <% ResultSet campos = moduloTabela.camposDadaTabela(umaTabela.getCodigo()); int tamanho = moduloTabela.tamanhoResultSet(campos); if (tamanho > 0) { %> <tr> <th><br><p align="right">Colunas : </p></th> <td></td> </tr> <% } %>
56
</table> <% if (tamanho > 0) { %> <table border="0"> <colgroup align="left" width="100"> <% for (int i=1;i<=tamanho;i++) { %> <colgroup align="left" width="100"> <% } %> <tr> <th></th> <% campos.beforeFirst(); while (campos.next()) { %> <td bgcolor="#CCCCCC"> <center> <button type="button" name="alteraOrdemCampo_acima" value="acima" onclick="alteraOrdemCampoParaCima('<%=campos.getString("nomeInternoCampo")%>')"><img src="Tabela/seta_esquerda.bmp" alt="Movimenta o campo para frente"></button> <button type="button" name="alteraOrdemCampo_abaixo" value="abaixo" onclick="alteraOrdemCampoParaBaixo('<%=campos.getString("nomeInternoCampo")%>')"><img src="Tabela/seta_direita.bmp" alt="Movimenta o campo para trás"></button> </center> </td> <% } %> </tr> <tr> <th bgcolor="#CCCCCC"><p align="left">Nome</p></th> <% campos.beforeFirst(); while (campos.next()) { %> <td bgcolor="#CCCCCC"> <input type="text" name="nomeCampo_<%=campos.getString("nomeInternoCampo")%>" value="<%=campos.getString("nomeExternoCampo")%>"> </td> <% } %> </tr> <tr> <th bgcolor="#CCCCCC"> <p align="left">Tipo</p> </th> <% campos.beforeFirst(); while (campos.next()) { %> <td bgcolor="#CCCCCC"> <select name="tipoCampo_<%=campos.getString("nomeInternoCampo")%>" dir="ltr"> <option value="Data" <% if (campos.getString("tipoCampo").equals("Data")) {%>selected<% } %> >Data</option> <option value="Linha de Texto" <% if (campos.getString("tipoCampo").equals("Linha de Texto")) {%>selected<% } %> >Linha de Texto</option> <option value="Lista de Opções" <% if (campos.getString("tipoCampo").equals("Lista de Opções")) {%>selected<% } %> >Lista de Opções</option> <option value="Moeda" <% if (campos.getString("tipoCampo").equals("Moeda")) {%>selected<% } %> >Moeda</option> <option value="Número" <% if (campos.getString("tipoCampo").equals("Número")) {%>selected<% } %> >Número</option> <option value="Sim/Não" <% if (campos.getString("tipoCampo").equals("Sim/Não")) {%>selected<% } %> >Sim/Não</option> <option value="Texto" <% if (campos.getString("tipoCampo").equals("Sim/Não")) {%>selected<% } %> >Texto</option>
57
</select> </td> <% }%> </tr> <% if (moduloTabela.haTipoEmAlgumCampoDaTabela( umaTabela.getCodigo(), Tabela.TIPOEXTERNO_LISTADEOPCOES )) {%> <tr> <th bgcolor="#CCCCCC"><p align="left">Valores *</p></th> <% campos.beforeFirst(); while (campos.next()) {%> <td bgcolor="#CCCCCC"> <% if (moduloTabela.tipoDeCampoDeTabela( umaTabela.getCodigo(), campos.getString("nomeInternoCampo") ).equals( Tabela.TIPOEXTERNO_LISTADEOPCOES )) {%> <input type="text" name="valoresEnumCampo_<%=campos.getString("nomeInternoCampo")%>" value="<%=campos.getString("valoresEnumeracao")%>"> <% }%> </td> <% }%> </tr> <% } if (moduloTabela.haTipoEmAlgumCampoDaTabela( umaTabela.getCodigo(), Tabela.TIPOEXTERNO_LINHADETEXTO )) {%> <tr> <th bgcolor="#CCCCCC"><p align="left">Tamanho</p></th> <% campos.beforeFirst(); while (campos.next()) {%> <td bgcolor="#CCCCCC"> <% if (moduloTabela.tipoDeCampoDeTabela( umaTabela.getCodigo(), campos.getString("nomeInternoCampo") ).equals( Tabela.TIPOEXTERNO_LINHADETEXTO )) {%> <input type="text" name="tamanhoCampo_<%=campos.getString("nomeInternoCampo")%>" value="<%=campos.getString("tamanhoCampo")%>"> <% }%> </td> <% } %> </tr> <% }%> <tr> <th bgcolor="#CCCCCC"><p align="left">Permite valor repetido</p></th> <% campos.beforeFirst(); while (campos.next()) { %> <td bgcolor="#CCCCCC"> <p align="center"> <input type="radio" name="permiteRepetidoCampo_<%=campos.getString("nomeInternoCampo")%>" value="Sim" <% if (campos.getString("permiteRepetido").equals("Sim")) {%>checked<% } %> >Sim</input> <input type="radio" name="permiteRepetidoCampo_<%=campos.getString("nomeInternoCampo")%>" value="Não" <% if (campos.getString("permiteRepetido").equals("Não")) {%>checked<% } %> >Não</input> </p> </td> <% } %> </tr> <tr> <th></th> <% campos.beforeFirst(); while (campos.next()) { %> <td bgcolor="#CCCCCC">
58
<% if (podeRemoverCampo) {%> <p align="center"> <button type="button" name="removeCampo_<%=campos.getString("nomeInternoCampo")%>" value="remover a coluna" onclick="removeCampo('<%=campos.getString("nomeInternoCampo")%>')">remover</button> </p> <% }%> </td> <% }%> </tr> </table> <i> <br> * Deve estar entre vírgulas. </i> <% } %> <table border="0" width="100%"> <tr align="right"> <td> <p align="right" > <input type="submit" name="salvar" value="Salvar alterações"> </form> </p> </td> <% if (podeIncluirCampo) {%> <td width="7%"> <p align="right" > <form action="index.jsp?objeto=Tabela&acao=InserirCampo" method="post"> <input type="submit" name="criarColuna" value="Inserir Coluna"> </form> </p> </td> <% }%> <td width="7%"> <p align="right" > <form action="index.jsp?objeto=Tabela&acao=VisualizarRegistros&tabela=<%=umaTabela.getCodigo()%>&inicioPeriodoTabela=1&fimPeriodoTabela=10" method="post"> <input type="submit" name="listaTabelas" value="Ver Conteúdo"> </form> </p> </td> </tr> </table> <script language="JavaScript"> function alteraOrdemCampoParaCima(nomeCampo) { location = "index.jsp?objeto=Tabela&acao=AlteraOrdemCampo&campo="+nomeCampo+"&orientacao=0"; } function alteraOrdemCampoParaBaixo(nomeCampo) { location = "index.jsp?objeto=Tabela&acao=AlteraOrdemCampo&campo="+nomeCampo+"&orientacao=1"; } function removeCampo(nomeCampo) { location = "index.jsp?objeto=Tabela&acao=RemoverCampo&campo="+nomeCampo; } </script>
59
Arquivo criaTabela.jsp <form action="index.jsp?objeto=Tabela&acao=SalvarNovaTabela" method="post"> <center> <p> <h2>Criando Tabela</h2> <p> <table> <tr> <th bgcolor="#CCCCCC">Nome : </th> <td bgcolor="#CCCCCC"><input type="edit" name="nomeTabela" value="" size="50"></td> </tr> <tr> <th bgcolor="#CCCCCC">Descrição : </th> <td bgcolor="#CCCCCC"><textarea name="descricaoTabela" rows="5" cols="100"></textarea></td> </tr> </table> <p> <p> <input type="submit" name="criar" value="Criar Tabela" /> </center> </form> Arquivo insereCampo.jsp <%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <% moduloTabela.insereCampo( Integer.parseInt(tabela) ); %> <jsp:include page="alteraTabela.jsp" /> Arquivo insereRegistro.jsp <%@ page import="org.agrorede.*"%> <%@ page import="java.util.Vector" %> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <% moduloTabela.insereRegistro( Integer.parseInt(tabela) ); Vector periodo = moduloTabela.ultimoPeriodoDe( Integer.parseInt(tabela) );%> <jsp:include page="visualizaTabela.jsp?inicioPeriodoTabela=<%=(String) periodo.get(0)%>&fimPeriodoTabela=<%=(String) periodo.get(1)%>" /> Arquivo listaTabelas.jsp <%@ page import="java.util.ArrayList"%>
60
<%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session"/> <jsp:useBean id="objeto" class="java.lang.String" scope="session" /> <jsp:useBean id="acao" class="java.lang.String" scope="session" /> <% Tabela tabela; boolean podeCriar = moduloTabela.temPermissaoPara("Criar", "Tabela"); boolean podeRemover = moduloTabela.temPermissaoPara("Remover", "Tabela"); boolean podeAlterar = moduloTabela.temPermissaoPara("Alterar", "Tabela"); %> <center> <p> <h2>Lista de Tabelas</h2> <table border="0"> <tr> <th>Nome</th> <th>Descrição</th> <th></th> <% if (podeAlterar){ %><td></td><% } %> <% if (podeRemover){ %><td></td><% } %> </tr> <% ArrayList tabelas = moduloTabela.tabelas(); for(int i = 0 ; i < tabelas.size() ; i++){ tabela = (Tabela)tabelas.get(i); %> <tr> <td bgcolor="#CCCCCC" nowrap="nowrap"> <a href="index.jsp?objeto=Tabela&acao=VisualizarRegistros&tabela=<%=tabela.getCodigo()%>&inicioPeriodoTabela=1&fimPeriodoTabela=10"> <%=tabela.getNomeExterno()%> </a> </td> <td bgcolor="#CCCCCC" nowrap="nowrap"><%=tabela.getDescricao()%></td> <td bgcolor="#CCCCCC"> <button type="button" name="verTabela_<%=tabela.getCodigo()%>" value="ver tabela" onclick="verTabela('<%=tabela.getCodigo()%>')">ver</button> </td> <% if (podeAlterar){%> <td bgcolor="#CCCCCC"> <button type="button" name="alterarTabela_<%=tabela.getCodigo()%>" value="alterar tabela" onclick="alteraTabela('<%=tabela.getCodigo()%>')">alterar</button> </td> <% }%> <% if (podeRemover){%> <td bgcolor="#CCCCCC"> <button type="button" name="removerTabela_<%=tabela.getCodigo()%>" value="remover tabela" onclick="removeTabela('<%=tabela.getCodigo()%>')">remover</button> </td> <% }%> </tr> <% }%> </table> </center> <% if (podeCriar) {%> <P align="right" > <form action="index.jsp?objeto=Tabela&acao=Criar" method="post">
61
<input type="submit" name="inscrever" value="Criar Tabela" /> </form> <% }%> <script language="JavaScript"> function verTabela(codigoTabela) { location = "index.jsp?objeto=Tabela&acao=VisualizarRegistros&tabela="+codigoTabela+"&inicioPeriodoTabela=1&fimPeriodoTabela=10"; } function alteraTabela(codigoTabela) { location = "index.jsp?objeto=Tabela&acao=Alterar&tabela="+codigoTabela; } function removeTabela(codigoTabela) { location = "index.jsp?objeto=Tabela&acao=Remover&tabela="+codigoTabela; } </script> Arquivo removeCampo.jsp <%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <% moduloTabela.removeCampo( Integer.parseInt(tabela), request.getParameter("campo") );%> <jsp:include page="alteraTabela.jsp" /> Arquivo removeRegistros.jsp <%@ page import="org.agrorede.*"%> <%@ page import="java.sql.ResultSet" %> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <% moduloTabela.removeRegistro(Integer.parseInt(tabela), Integer.parseInt(request.getParameter("registro")));%> <jsp:forward page="../index.jsp?objeto=Tabela&acao=VisualizarRegistros"/> Arquivo removeTabela.jsp <%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <% moduloTabela.removeTabela( Integer.parseInt( request.getParameter("tabela") ) );%> <jsp:forward page="../index.jsp?objeto=Tabela&acao=Visualizar" />
62
Arquivo salvaCampos.jsp <%@ page import="org.agrorede.*"%> <%@ page import="java.sql.ResultSet" %> <%@ page import="java.util.Vector" %> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <% Vector vetorCampos = new Vector(); ResultSet campos = moduloTabela.camposDadaTabela(Integer.parseInt(tabela)); while (campos.next()) { Vector subVetorCampos = new Vector(); String nomeInterno = campos.getString("nomeInternoCampo"); if (!request.getParameter("nomeCampo_"+nomeInterno).equals("")){ subVetorCampos.add( nomeInterno ); subVetorCampos.add( request.getParameter("nomeCampo_"+nomeInterno) ); subVetorCampos.add( request.getParameter("tipoCampo_"+nomeInterno) ); subVetorCampos.add( request.getParameter("valoresEnumCampo_"+nomeInterno) ); subVetorCampos.add( request.getParameter("tamanhoCampo_"+nomeInterno) ); subVetorCampos.add( request.getParameter("permiteRepetidoCampo_"+nomeInterno) ); vetorCampos.add( subVetorCampos ); } } moduloTabela.alteraTabela( Integer.parseInt(tabela), request.getParameter("nomeTabela"), request.getParameter("descricaoTabela"), vetorCampos ); %> <jsp:include page="alteraTabela.jsp" /> Arquivo salvaNovaTabela.jsp <%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <% String tabela; tabela = String.valueOf( moduloTabela.criaTabela( request.getParameter("nomeTabela"), request.getParameter("descricaoTabela"), -1 )); session.setAttribute("tabela", tabela); %> <jsp:include page="alteraTabela.jsp" /> Arquivo salvaRegistroTabela.jsp <%@ page import="org.agrorede.*"%> <%@ page import="java.sql.ResultSet" %> <%@ page import="java.util.Vector" %> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" />
63
<jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <jsp:useBean id="inicioPeriodoTabela" class="java.lang.String" scope="session" /> <jsp:useBean id="fimPeriodoTabela" class="java.lang.String" scope="session" /> <% ResultSet registros = moduloTabela.registrosDadoTabela(Integer.parseInt(tabela), Integer.parseInt(inicioPeriodoTabela), Integer.parseInt(fimPeriodoTabela)); while (registros.next()) { Vector vetorRegistro = new Vector(); String cod = registros.getString("cod"); ResultSet campos = moduloTabela.camposDadaTabela(Integer.parseInt(tabela)); while (campos.next()) { Vector subVetorRegistro = new Vector(); String nomeInterno = campos.getString("nomeInternoCampo"); subVetorRegistro.add( nomeInterno ); if (campos.getString("tipoCampo").equals("Data")) { subVetorRegistro.add( request.getParameter("campo_ano_"+nomeInterno+"_"+cod)+"-"+ request.getParameter("campo_mes_"+nomeInterno+"_"+cod)+"-"+ request.getParameter("campo_dia_"+nomeInterno+"_"+cod) ); } if (campos.getString("tipoCampo").equals("Lista")) { subVetorRegistro.add( request.getParameter("campo_"+nomeInterno+"_"+cod) ); } if ((!campos.getString("tipoCampo").equals("Data")) & (!campos.getString("tipoCampo").equals("Lista"))) { subVetorRegistro.add( request.getParameter("campo_"+nomeInterno+"_"+cod) ); } vetorRegistro.add( subVetorRegistro ); } moduloTabela.alteraRegistro( Integer.parseInt(tabela), Integer.parseInt(cod), vetorRegistro ); } %> <jsp:include page="visualizaTabela.jsp" /> Arquivo trataTabelas.jsp <%@ page import="org.agrorede.*"%> <jsp:useBean id="moduloMembroGrupo" class="org.agrorede.ModuloMembroGrupo" scope="session"/> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="objeto" class="java.lang.String" scope="session" /> <jsp:useBean id="acao" class="java.lang.String" scope="session" /> <% moduloTabela.setModuloMembroGrupo( moduloMembroGrupo ); boolean podeCriar = moduloTabela.temPermissaoPara("Criar", "Tabela"); boolean podeAlterar = moduloTabela.temPermissaoPara("Alterar", "Tabela"); boolean podeRemover = moduloTabela.temPermissaoPara("Remover", "Tabela");
64
boolean podeVisualizar = moduloTabela.temPermissaoPara("Visualizar", "Tabela"); boolean podeInserirRegistro = moduloTabela.temPermissaoPara("InserirRegistro", "Tabela"); boolean podeRemoverRegistro = moduloTabela.temPermissaoPara("RemoverRegistro", "Tabela"); boolean podeAlterarRegistro = moduloTabela.temPermissaoPara("AlterarRegistro", "Tabela"); boolean podeInserirCampo = moduloTabela.temPermissaoPara("InserirCampo", "Tabela"); boolean podeRemoverCampo = moduloTabela.temPermissaoPara("RemoverCampo", "Tabela"); boolean podeAlterarCampo = moduloTabela.temPermissaoPara("AlterarCampo", "Tabela"); String tabela = request.getParameter("tabela"); %> <% if ( acao.equals("Criar") && podeCriar ){ %> <jsp:include page="criaTabela.jsp" /> <% } %> <% if ( acao.equals("Alterar") && podeAlterar ){ %> <jsp:include page="alteraTabela.jsp?tabela=<%=tabela%>" /> <% } %> <% if ( acao.equals("Remover") && podeRemover ){ %> <jsp:include page="removeTabela.jsp?tabela=<%=tabela%>" /> <% } %> <% if ( acao.equals("Visualizar") && podeVisualizar ){ %> <jsp:include page="listaTabelas.jsp" /> <% } %> <% if ( acao.equals("SalvarNovaTabela") ){ %> <jsp:include page="salvaNovaTabela.jsp" /> <% } %> <% if ( acao.equals("InserirRegistro") && podeInserirRegistro ){ %> <jsp:include page="insereRegistro.jsp" /> <% } %> <% if ( acao.equals("RemoverRegistro") && podeRemoverRegistro ){ %> <jsp:include page="removeRegistros.jsp" /> <% } %> <% if ( acao.equals("AlterarRegistro") && podeAlterarRegistro ){ %> <jsp:include page="alteraRegistroTabela.jsp" /> <% } %> <% if ( acao.equals("VisualizarRegistros") && podeVisualizar ){ %> <jsp:include page="visualizaTabela.jsp" /> <% } %> <% if ( acao.equals("SalvarRegistro") ){ %> <jsp:include page="salvaRegistroTabela.jsp?tabela=<%=tabela%>" /> <% } %> <% if ( acao.equals("SalvarNovoRegistro") ){ %> <jsp:include page="salvaNovoRegistroTabela.jsp?tabela=<%=tabela%>" /> <% } %> <% if ( acao.equals("InserirCampo") && podeInserirCampo ){ %> <jsp:include page="insereCampo.jsp" />
65
<% } %> <% if ( acao.equals("RemoverCampo") && podeRemoverCampo ){ %> <jsp:include page="removeCampo.jsp" /> <% } %> <% if ( acao.equals("AlterarCampo") && podeAlterarCampo ){ %> <jsp:include page="alteraCampo.jsp" /> <% } %> <% if ( acao.equals("SalvarCampos") && podeAlterarCampo ){ %> <jsp:include page="salvaCampos.jsp" /> <% } %> <% if ( acao.equals("SalvarNovoCampo") && podeInserirCampo ){ %> <jsp:include page="salvaNovoCampo.jsp?tabela=<%=tabela%>" /> <% } %> <% if ( acao.equals("AlteraOrdemCampo") && podeAlterarCampo ){ %> <jsp:include page="alteraOrdemCampo.jsp" /> <% } %> Arquivo visualizaTabela.jsp <%@ page import="org.agrorede.*"%> <%@ page import="java.sql.ResultSet"%> <%@ page import="java.util.Vector"%> <jsp:useBean id="moduloTabela" class="org.agrorede.ModuloTabela" scope="session" /> <jsp:useBean id="objeto" class="java.lang.String" scope="session" /> <jsp:useBean id="acao" class="java.lang.String" scope="session" /> <jsp:useBean id="tabela" class="java.lang.String" scope="session" /> <jsp:useBean id="inicioPeriodoTabela" class="java.lang.String" scope="session" /> <jsp:useBean id="fimPeriodoTabela" class="java.lang.String" scope="session" /> <% boolean podeAlterar = moduloTabela.temPermissaoPara("Alterar", "Tabela"); boolean podeIncluirRegistro = moduloTabela.temPermissaoPara("IncluirRegistro", "Tabela"); boolean podeAlterarRegistro = moduloTabela.temPermissaoPara("AlterarRegistro", "Tabela"); boolean podeRemoverRegistro = moduloTabela.temPermissaoPara("RemoverRegistro", "Tabela"); if (request.getParameter("tabela") != null) { tabela = request.getParameter("tabela"); session.setAttribute("tabela", tabela ); } Tabela umaTabela = moduloTabela.tabelaDadoCodigo(Integer.parseInt(tabela)); if (request.getParameter("inicioPeriodoTabela") != null) { inicioPeriodoTabela = request.getParameter("inicioPeriodoTabela"); session.setAttribute("inicioPeriodoTabela", inicioPeriodoTabela ); } if (request.getParameter("fimPeriodoTabela") != null) { fimPeriodoTabela = request.getParameter("fimPeriodoTabela"); session.setAttribute("fimPeriodoTabela", fimPeriodoTabela ); } %> <p>
66
<h1><%=umaTabela.getNomeExterno()%></h1> <h2><%=umaTabela.getDescricao()%></h2> <% if (podeAlterar){ %> <form action="index.jsp?objeto=Tabela&acao=Alterar&tabela=<%=umaTabela.getCodigo()%>" method="post"> <input type="submit" name="alterar" value="Alterar Colunas"> </form> <% }%> <br> <br> <center> <form action="index.jsp?&objeto=Tabela&acao=SalvarRegistro&inicioPeriodoTabela=<%=inicioPeriodoTabela%>&fimPeriodoTabela=<%=fimPeriodoTabela%>" method="post"> <% ResultSet campos = moduloTabela.camposDadaTabela(umaTabela.getCodigo()); int quantCampos = moduloTabela.tamanhoResultSet(campos);%> <table border="0"> <% for (int i=1;i<=quantCampos;i++) { %> <colgroup align="left" width="100"> <% } %> <thead valign="top"> <tr> <% campos.beforeFirst(); while (campos.next()) { String nomeExternoCampo = campos.getString("nomeExternoCampo"); if (nomeExternoCampo.equals("")) { nomeExternoCampo = "(sem nome)"; }%> <th bgcolor="#CCCCCC"><b><%=nomeExternoCampo%></b></th> <% } if (podeRemoverRegistro) {%> <th></th> <% }%> </tr> <tbody> <% ResultSet registros = moduloTabela.registrosDadoTabela(umaTabela.getCodigo(), Integer.parseInt(inicioPeriodoTabela), Integer.parseInt(fimPeriodoTabela)); int contRegistros = 0; while (registros.next()) { String cod = registros.getString("cod"); campos.beforeFirst();%> <tr> <% while (campos.next()) { if (!campos.getString("nomeInternoCampo").equals("cod")) {%> <td bgcolor="#CCCCCC"> <% if (campos.getString("tipoCampo").equals(Tabela.TIPOEXTERNO_LISTADEOPCOES)) { Vector valores = moduloTabela.valoresEnumeracaoCampo( umaTabela.getCodigo(), campos.getString("nomeInternoCampo") );%> <select name="campo_<%=campos.getString("nomeInternoCampo")%>_<%=cod%>" dir="ltr"> <% for (int k=0;k<valores.size();k++) {%> <option value="<%=(String) valores.get(k)%>" <% if (registros.getString(campos.getString("nomeInternoCampo")).equals((String) valores.get(k))) {%>checked<% } %> ><%=(String) valores.get(k)%></option> <% }%> </select> <% } if (campos.getString("tipoCampo").equals(Tabela.TIPOEXTERNO_DATA)) {
67
String dado = registros.getString(campos.getString("nomeInternoCampo")); String dia = ""; String mes = ""; String ano = ""; if (!dado.equals("")) { dia = dado.substring(8,10); mes = dado.substring(5,7); ano = dado.substring(0,4); }%> <input type="text" name="campo_dia_<%=campos.getString("nomeInternoCampo")%>_<%=cod%>" value="<%=dia%>" size="2"> / <input type="text" name="campo_mes_<%=campos.getString("nomeInternoCampo")%>_<%=cod%>" value="<%=mes%>" size="2"> / <input type="text" name="campo_ano_<%=campos.getString("nomeInternoCampo")%>_<%=cod%>" value="<%=ano%>" size="4"> <% } if ((!campos.getString("tipoCampo").equals(Tabela.TIPOEXTERNO_DATA)) & (!campos.getString("tipoCampo").equals(Tabela.TIPOEXTERNO_LISTADEOPCOES))) {%> <input type="text" name="campo_<%=campos.getString("nomeInternoCampo")%>_<%=cod%>" value="<%=registros.getString(campos.getString("nomeInternoCampo"))%>"> <% }%> </td> <% } } contRegistros += 1; if (podeRemoverRegistro) {%> <td> <button type="button" name="removeRegistro_<%=campos.getString("nomeInternoCampo")%>_<%=cod%>" value="remover a linha" onclick="removeRegistro('<%=cod%>')">remover</button> </td> <% }%> </tr> <% }%> </table> <!-- Barra de navegação--> <% if (contRegistros > 0) { Vector periodo;%> <button type="button" name="visualizaPrimeirasDez" value="Primeiras dez linhas" onclick="visualizaPrimeirasDez()"> <img src="Tabela/setadupla_esquerda.bmp" alt="Primeiras dez linhas"> </button> <% periodo = moduloTabela.dezAnterioresDe(umaTabela.getCodigo(), Integer.parseInt(inicioPeriodoTabela), Integer.parseInt(fimPeriodoTabela));%> <button type="button" name="visualizaDezAnteriores" value="Dez linhas anteriores" onclick="visualizaDezAnteriores('<%=(String)periodo.get(0)%>', '<%=(String)periodo.get(1)%>')"> <img src="Tabela/seta_esquerda.bmp" alt="Dez linhas anteriores"> </button> <% periodo = moduloTabela.verificaPeriodoDe(umaTabela.getCodigo(), Integer.parseInt(inicioPeriodoTabela), Integer.parseInt(fimPeriodoTabela));%> Mostrando linhas de <%=(String)periodo.get(0)%> até <%=(String)periodo.get(1)%>.
68
<% periodo = moduloTabela.proximosDezDe(umaTabela.getCodigo(), Integer.parseInt(inicioPeriodoTabela), Integer.parseInt(fimPeriodoTabela));%> <button type="button" name="visualizaProximasDez" value="Próximas dez linhas" onclick="visualizaProximasDez('<%=(String)periodo.get(0)%>', '<%=(String)periodo.get(1)%>')"> <img src="Tabela/seta_direita.bmp" alt="Próximas dez linhas"> </button> <button type="button" name="visualizaUltimasDez" value="Últimas dez linhas" onclick="visualizaUltimasDez()"> <img src="Tabela/setadupla_direita.bmp" alt="Últimas dez linhas"> </button> <% } %> </center> <br> <table border="0" width="100%"> <tr align="right"> <td> <p align="right" > <input type="submit" name="salvar" value="Salvar alterações"> </form> </p> </td> <td width="7%"> <p align="right" > <form action="index.jsp?objeto=Tabela&acao=InserirRegistro" method="post"> <input type="submit" name="inserirNovaLinha" value="Inserir nova linha"> </form> </p> </td> </tr> </table> <script language="JavaScript"> function visualizaPrimeirasDez() { location = "index.jsp?objeto=Tabela&acao=VisualizarRegistros&inicioPeriodoTabela=1&fimPeriodoTabela=10"; } function visualizaDezAnteriores(inicio, fim) { location = "index.jsp?objeto=Tabela&acao=VisualizarRegistros&inicioPeriodoTabela="+inicio+"&fimPeriodoTabela="+fim; } function visualizaProximasDez(inicio, fim) { location = "index.jsp?objeto=Tabela&acao=VisualizarRegistros&inicioPeriodoTabela="+inicio+"&fimPeriodoTabela="+fim; } function visualizaUltimasDez() { location = "index.jsp?objeto=Tabela&acao=VisualizarRegistros&inicioPeriodoTabela=1&fimPeriodoTabela=10"; } function removeRegistro(registro) { location = "index.jsp?objeto=Tabela&acao=RemoverRegistro®istro="+registro; } </script>
69