CURSO SUPERIOR DE TECNOLOGIA EM DESENVOLVIMENTO E
ANÁLISE DE SISTEMAS
FRANCILA DE ALMEIDA ARAÚJO
NATHÁLIA SANTOS DE OLIVEIRA ANDRADE
NELIELSON MANHÃES PESSANHA
DESENVOLVIMENTO DE UM SISTEMA DE PESQUISA
BIBLIOGRÁFICA UTILIZANDO O FRAMEWORK MIOLO/PHP
Campos dos Goytacazes/RJ
2008
FRANCILA DE ALMEIDA ARAÚJO
NATHÁLIA SANTOS DE OLIVEIRA ANDRADE
NELIELSON MANHÃES PESSANHA
DESENVOLVIMENTO DE UM SISTEMA DE PESQUISA
BIBLIOGRÁFICA UTILIZANDO O FRAMEWORK MIOLO/PHP
Monografia apresentada ao Centro Federal de
Educação Tecnológica de Campos como requisito
parcial para conclusão do Curso de Tecnologia
em Desenvolvimento e Análise de Sistemas.
Orientador: Profº. Marcelo Machado Feres
Campos dos Goytacazes/RJ
2008
Dados de Catalogação na Publicação (CIP)
A633d Araújo, Francila de Almeida. Desenvolvimento de um sistema de pesquisa bibliográfica utilizando o Framework MIOLO/PHP / Francila de Almeida Araújo, Nathália Santos de Oliveira Andrade, Nelielson Manhães Pessanha. – Campos dos Goytacazes, RJ : [s.n.], 2008. 82 f. ; il. Orientador: Marcelo Machado Feres. Monografia (Tecnologia em Desenvolvimento e Análise de Sistemas). Centro Federal de Educação Tecnológica de Campos. Campos dos Goytacazes, RJ, 2008. Bibliografia: f. 78 – 79. 1. PHP (Linguagem de programação de computador. 2.
Framework (Programa de computador). 3. Catálogos coletivos – Campos dos Goytacazes (RJ) – Automação.
I. Andrade, Nathália Santos de Oliveira. II. Pessanha, Nelielson Manhães. III. Feres, Marcelo Machado, orient. IV. Título.
CDD – 005.133(PHP)
FRANCILA DE ALMEIDA ARAÚJO
NATHÁLIA SANTOS DE OLIVEIRA ANDRADE
NELIELSON MANHÃES PESSANHA
DESENVOLVIMENTO DE UM SISTEMA DE PESQUISA BIBLIOGRÁ FICA
UTILIZANDO O FRAMEWORK MIOLO/PHP
Monografia apresentada ao Centro Federal de Educação Tecnológica de Campos como requisito parcial para conclusão do Curso de Tecnologia em Desenvolvimento e Análise de Sistemas.
Orientador: Profº. Marcelo Machado Feres
Aprovada em 15 de setembro de 2008
Banca Avaliadora:
.................................................................................................................................
Profº Marcelo Machado Feres (orientador)
Mestre em Engenharia de Software/EMN-VUB
Centro Federal de Educação Tecnológica de Campos
.................................................................................................................................
Profº. Jonivan Coutinho Lisboa
Mestre em Computação Paralela e Distribuída - UFF
Centro Federal de Educação Tecnológica de Campos
.................................................................................................................................
Profº. José Elias da Silva Justo
Pós-graduado em Administração em Redes Linux - UFLA
Centro Federal de Educação Tecnológica de Campos
Dedicamos este trabalho a nossos familiares, especialmente a nossos pais, namorados, esposa, filhos e a todos que acreditaram em nós.
AGRADECIMENTOS
Agradecemos em primeiro lugar a Deus, pois sem seu consentimento nada nesta vida é possível. Á instituição CEFET Campos (Centro Federal de Educação Tecnológica de Campos) por proporcionar uma boa estrutura física que nos possibilitou a realização deste sonho. Aos nossos professores, em especial a Marcelo Feres que nos orientou e incentivou neste processo final, nos indicando o melhor caminho para atingir nossos objetivos. A nossos pais, filhos, namorados, esposas pela compreensão de nossas ausências nos nossos lares neste período que durou o curso. Aos colegas do Projeto SIGA (Sistema Integrado de Gestão Acadêmica) que trabalham no núcleo do CEFET Campos, em especial a Ítalo dos Santos Ferreira, que contribuiu com dicas importantíssimas na fase de implementação do projeto. Aos colegas de classe.
Tudo tem seu tempo e até certas manifestações mais vigorosas e originais entram em voga ou saem de moda. Mas a sabedoria tem uma vantagem: é eterna."
Baltasar Gracián
RESUMO
Este Trabalho Monográfico apresentado ao CEFET Campos como parte das exigências para conclusão do Curso Superior de Desenvolvimento de Software será parte complementar do projeto “Viagem aos Campos dos Goytacazes: um roteiro bibliográfico” da pesquisadora Heloisa de Cássia, do Laboratório de Estudos da Sociedade Civil e do Estado, do Centro de Ciências do Homem, da Universidade Estadual do Norte Fluminense Darcy Ribeiro. O projeto da pesquisadora supracitada objetiva a identificação do acervo bibliográfico das instituições públicas e privadas da cidade de Campos dos Goytacazes produzindo um guia impresso que permitiria melhores condições de pesquisa a estudantes e pesquisadores em geral, além de disponibilizar informações bibliográficas para a comunidade acadêmica, colecionadores, estudiosos que elegeram Campos como foco de leitura e produção, como também, o de promover a consciência sobre a necessidade de preservação da identidade cultural de Campos, considerando o seu patrimônio histórico-bibliográfico-documental. Apresentaremos uma ferramenta que permitirá a pesquisadora catalogar os dados coletados, semelhante a um software de biblioteca, e disponibilizar a consulta aos mesmos via internet. Foi necessário fazer um estudo dos dados coletados e adequar a coleta de acordo com as normas da ABNT de referência bibliográfica, determinando quais dados devem ser coletados das publicações. Para a implementação deste sistema usaremos a linguagem PHP, juntamente com o framework MIOLO. Apresentando um estudo detalhado do framework e as etapas de desenvolvimento do sistema.
Palavras chaves: Programação web, Desenvolvimento de software, Frameworks PHP, MIOLO
PHP – framework – PHP
ABSTRACT
This work presented to CEFET Campos as part of the requirements for completion of Studied Software Development will be complementary part of the project "Journey to the Campos dos Goytacazes: a roadmap bibliographic" the researcher Heloisa de Cássia, Laboratory of Civil Society Studies and State, the Centre for Human Sciences, State University of North Fluminense Darcy Ribeiro. The researcher said the project aims to identify the bibliographic collection of public and private institutions of the city of Campos dos Goytacazes producing a printed guide that would best position to search for students and researchers in general, plus bibliographic information available to the academic community, collectors , Scholars who elected camps as a focus for reading and production, but also, to promote awareness of the need to preserve the cultural identity of fields, considering its heritage-bibliographic-documentary. We will make a tool that will allow the researcher catalogued the data collected, similar to a library of software, and provide consultation to them via the internet. It was necessary to do a study of data collected and bring the collection in accordance with the standards of ABNT of reference literature, determining which data should be collected publications. For the implementation of this system we will use the PHP language with the framework MIOLO. Presenting a detailed study of the framework and the steps for developing the system.
LISTA DE FIGURAS
Figura 1: Exemplo da diferença entre uma biblioteca de classes e um Framework (Sauvé Jacques Philippe) .................................................................................................................
18
Figura 2: Função controller do handler......................................................................................... 27
Figura 3: Estrutura de Camadas do MIOLO ................................................................................. 29
Figura 4 - Implementação de camadas em MVC .......................................................................... 30
Figura 5 - Diagrama de caso de uso .............................................................................................. 50
Figura 6 – Diagrama de Classes ................................................................................................... 51
Figura 7 – Diagrama de seqüência efetuar login............................................................................ 52
Figura 8 – Diagrama de seqüência cadastro de publicação ........................................................... 52
Figura 9 – Diagrama de atividade efetuar login ............................................................................ 53
Figura 10 – Diagrama de atividade cadastrar publicação ............................................................. 54
Figura 11 – MER Modelo Entidade Relacionamento ................................................................... 55
Figura 12 – Diretório e subdiretório do módulo Guia ................................................................... 63
Figura 13 – Trecho do arquivo miolo.comf ................................................................................... 64
Figura 14 – Tela de login................................................................................................................ 65
Figura 15 – Tela de manutenção de dados do módulo Guia. ........................................................ 66
Figura 16 – Tabelas auxiliares ....................................................................................................... 67
Figura 17 – Tela de cadastro de idioma ......................................................................................... 67
Figura 18 – Tela de entrada de dados de Editora .......................................................................... 68
Figura 19 – Tela de cadastro autor ............................................................................................... 68
Figura 20 – Tela de cadastro de assuntos ...................................................................................... 69
Figura 21 – Tela 1 para cadastro de livros..................................................................................... 70
Figura 22 – Tela 2 de cadastro de livros ........................................................................................ 70
Figura 23 – Tela da função Loockup ............................................................................................. 71
Figura 24 – Tela 3 de cadastro de livros ........................................................................................ 72
Figura 25 – Tela de cadastro de autores numa publicação............................................................. 72
Figura 26 – Inclusão de assunto na publicação ............................................................................. 73
Figura 27 - Tela de entrada de dados para Instituição ................................................................... 74
LISTA DE SIGLAS E ABREVIATURAS
ABNT Associação Brasileira de Normas Técnicas
AJAX Asynchronous Javascript And XML (desenvolvimento de aplicações em
JavaScript com XML)
ASCII American Standard Code for Information Interchange (Código Padrão
Norteamericano)
ASP Active Server Pages
BD Banco de Dados
BSD Berkeley Software Distribution
CEFET-Campos Centro Federal de Educação Tecnológica de Campos
CONF Configuração
CRUD Create, Retrieve, Update e Delete
CSS Cascading Style Sheets (Folhas de Estilo em Cascata)
DAO Data Access Objects
DOCS Documentos
Forms Formulários
GB Gigabite
Gdk GIMP Drawing Kit
GNU General Public License (Licença Pública Geral)
GTK GIMP toolkit
HTML HyperText Markup Language (Linguagem de Marcação de Hipertexto)
ID Identificador
ISBN International Standard Book Number
ISSN International Standard Serial Number
LOG Termo utilizado para descrever o processo de registro de eventos relevantes
num sistema computacional
MVC Model-view-controller (Modelo Visualização Controle)
NCSA Center for Supercomputing Applications (Centro Nacional de Aplicativos
NET Network
OOP (POO) Programação Orientada à Objeto
OS (SO) Sistema Operacional
PDF Portable Document Format
PEAR PHP Extension and Application Repository
PHP Hypertext Preprocessor
RC Release Candidate
SAGU Sistema Acadêmico de Gestão Unificada
SD Sem Data definida
SGbD Sistema Gerenciador de Banco de Dados
SGML (Standard Generalized Markup Language - Norma Padrão para Linguagem de
Marcação
SIGA Sistema Integrado de Gestão Acadêmica
SOLIS Cooperativa de Soluções Livres
SQL Structured Query Language (Linguagem de Consulta Estruturada)
SSL Secure Sockets Layer
TB Tabela de Banco
TCC Trabalho de Conclusão de Curso
TI Tecnologia da Informação
UFJF Universidade Federal de Juiz de Fora
UI User Interface – Interface do Usuário
UML Unified Modeling Language
URL Uniform Resource Locator
W3C World Wide Web Consortium
WWW World Wide Web
WYSIWYG What You See Is What You Get (O que você vê é o que você tem)
XHTML eXtensible Hypertext Markup Language
XML Extensible Markup Language (Linguagem de Marcação de Extensível)
SUMÁRIO
LISTA DE ILUSTRAÇÕES ............................................................................................... 8
LISTA DE SIGLAS E ABREVIAÇÕES ............................................................................
9
INTRODUÇÃO .................................................................................................................. 14
Motivação ....................................................................................................................... 14
Objetivo .......................................................................................................................... 14
Organização do trabalho ................................................................................................ 15
1 FRAMEWORK PARA DESENVOLVIMENTO COM PHP ........................................... 16
1.1 Introdução ......................................................................................................... 16
1.2 Vantagens de se utilizar um Framework ........................................................... 19
1.3 Alguns Framework PHP ................................................................................... 20
1.3.1 PRADO PHP FRAMEWORK ....................................................................... 20
1.3.2 SYMFONY PHP FRAMEWORK ................................................................... 20
1.3.3 CAKE PHP FRAMEWORK ……………………………………………… 21
1.3.4 MIOLO PHP ………………………………………………………………… 22
1.4 Considerações finais ................................................................................................ 23
2 DETALHANDO O FRAMEWORK MIOLO ................................................................. 24
2.1 Introdução ................................................................................................................ 24
2.2 Histórico.................................................................................................................... 25
2.3 Arquitetura do Framework MIOLO ........................................................................ 26
2.4 Implementação das camadas do MIOLO ................................................................. 28
2.5 Estrutura de diretórios .............................................................................................. 31
2.6 Arquivos principais .................................................................................................. 32
3 ANÁLISE DO SISTEMA PROPOSTO ........................................... .............................. 34
3.1 Domínio do sistema ................................................................................................. 34
3.2 REQUISITOS DO SISTEMA ................................................................................. 35
3.2.1 Requisitos funcionais ....................................................................................... 35
3.2.2 Requisitos não- funcionais ............................................................................... 36
3.3 Modelagem UML...................................................................................................... 36
3.4 Casos de uso ............................................................................................................. 37
3.5 Descrição dos Casos de Uso .................................................................................... 37
3.6 Diagrama de Casos de Uso ...................................................................................... 49
3.7 Diagrama de Classes ................................................................................................ 50
3.8 Diagramas de sequência .......................................................................................... 52
3.9 Diagramas de atividades .......................................................................................... 53
3.10 Modelam Entidade Relacionamento ...................................................................... 54
4 TECNOLOGIAS UTILIZADAS .................................................................................. 56
4.1 Servidor Apache ...................................................................................................... 56
4.2 HTML ...................................................................................................................... 56
4.3 CSS .......................................................................................................................... 57
4.4 JavaScript ................................................................................................................. 58
4.5 PHP .......................................................................................................................... 58
4.6 Banco de dados Postgres ......................................................................................... 60
4.7 MIOLO ................................................................................................................... 61
5 DESENVOLVIMENTO E APRESENTACAO DO PROTÓTIPO 62
5.1 Gerador de código para MIOLO .............................................................................. 62
5.2 Apresentação do protópito ....................................................................................... 63
6 CONCLUSÃO ................................................................................................................ 76
6.1 Trabalhos Futuros .................................................................................................... 77
REFERÊNCIAS .............................................................................................................. 78
APÊNDICES .................................................................................................................... 80
APÊNDICE A: Formulário para coleta dos dados de material monográfico ..................... 81
INTRODUÇÃO
MOTIVAÇÃO
Nos últimos anos, a cidade de Campos vem se destacando como pólo universitário,
reunindo diversas instituições de ensino superior nos níveis de graduação, pós-graduação,
mestrado e doutorado. Em muitos cursos oferecidos, a história da cidade de Campos é o
principal objeto de pesquisa de seus estudantes. Isso tem elevado, consideravelmente, a busca
por publicações relacionadas à história da cidade.
Visando atender este universo de pesquisadores e promover a consciência sobre a
necessidade de preservação da identidade cultural de Campos, esta monografia vem completar
o projeto “Viagem aos Campos dos Goytacazes: um roteiro bibliográfico”, da
pesquisadora Heloisa de Cássia, da UENF (Universidade Estadual do Norte Fluminense
Darcy Ribeiro), o qual a princípio, seria somente uma guia impresso contendo todas as
informações bibliográficas coletadas sobre o acervo de Campos.
Este trabalho apresenta um estudo para o desenvolvimento de uma aplicação web
utilizando o Framework MIOLO/PHP para disponibilizar através da internet a pesquisa dos
dados coletados, tanto das publicações, quanto das instituições que possuem em seus acervos
obras de referência sobre Campos dos Goytacazes e sua história, possibilitando o acesso a
essas informações, de forma a auxiliar e orientar todos os interessados nas obras que contam a
história da cidade.
OBJETIVO
Desenvolver uma ferramenta que possibilita catalogar as publicações sobre a cidade de
Campos que se encontram espalhadas nas diversas instituições da cidade e disponibilizar a
consulta via internet desses dados. Apresentar o Framework MIOLO e o processo de
desenvolvimento de aplicações web por meio de framework.
Num mundo atual, milhares de informações são lançadas a cada instante e a criação do
site possibilita manter estes dados sobre a cidade sempre atualizados, permitindo que a cada
lançamento de obras sobre a cidade, os mesmos possam ser lançados imediatamente no site.
15
ORGANIZAÇÃO DO TRABALHO
Esta monografia apresenta oito capítulos.
Esta primeira parte contém a apresentação deste trabalho monográfico, destacando a
motivação para a aceitação deste desafio e os objetivos a serem alcançados.
O capítulo um apresenta um breve estudo sobre Frameworks para desenvolvimento
com a linguagem PHP, destacando suas principais características.
No capítulo dois, encontra-se a apresentação do Framework MIOLO/PHP.
O capítulo três é dedicado à análise do projeto. Neste capítulo, será apresentado os
requisitos funcionais e não funcionais do sistema, a apresentação dos diagramas.
No capítulo quatro é feito um estudo teórico das ferramentas e tecnologias utilizadas
durante o desenvolvimento do sistema.
O capitulo cinco é dedicado ao processo de desenvolvimento e apresentação do
protótipo do sistema analisado (nesta fase são feitos os testes e as aprovações) e a versão
funcional do protótipo.
O capítulo seis é a conclusão. Este capítulo demonstra o sucesso obtido no decorrer
desta fase do curso. Nele é feito um breve levantamento do que foi executado e as previsões
para novos trabalhos que poderão contribuir para o crescimento deste sistema.
Por fim, o capítulo sete, traz uma lista cronológica de toda a bibliografia utilizada e o
oito, os anexos.
1 FRAMEWORK PARA DESENVOLVIMENTO COM PHP
1.1 INTRODUÇÃO
Neste capítulo serão referenciados os conceitos de framework e alguns exemplos de
Frameworks para desenvolvimento de aplicações com a linguagem PHP.
Atualmente a linguagem PHP é bastante difundida e uma das mais utilizadas para o
desenvolvimento de aplicações web. A partir do lançamento do PHP 5 com suporte a
programação orientada a objeto, a linguagem passou a ser ainda mais utilizada e esse
crescimento alavancou a utilização de Frameworks voltados para o PHP.
Com o lançamento da versão 5 esse objetivo foi atingido com sucesso. A partir desse “amadurecimento” o PHP começou a chamar a atenção de programadores acostumados a utilizar o paradigma de programação orientada a objetos, além de favorecer a criação de aplicações mais robustas e de melhores componentes de software (MINETTO, 2007).
Desenvolver sistemas de médio porte iniciando o trabalho do zero é algo muito
trabalhoso e dispendioso. Para reduzir os esforços, o desenvolvedor está sempre em busca de
ferramentas que facilitem o seu trabalho. Seguindo este conceito, cada vez mais surgem novas
formas de se construir software. Uma delas é a reutilização de códigos e componentes, e essas
técnicas passaram a ser mais empregadas junto com a Programação Orientada a Objeto. A
partir disso, muitos outros conceitos foram agregados como o repositório de classes e objetos
e mais adiante surgiu o conceito de framework.
Pode-se definir um framework como sendo a estrutura principal para criação de um
projeto. Esta definição poderia ser usada para descrever um arcabouço para qualquer tipo de
projeto seja na área de TI ou engenharia civil, por exemplo. Portanto, um framework nada
mais é do que o esqueleto ou a estrutura principal de uma aplicação.
Um framework de desenvolvimento é uma “base” de onde se pode desenvolver algo
maior ou mais específico. É uma coleção de códigos-fonte, classes, funções, técnicas e
metodologias que facilitam o desenvolvimento de novos softwares. (MINETTO, 2007).
17
Tipicamente, um framework pode incluir programas de apoio, bibliotecas de código,
linguagens de script e outros softwares para ajudar a desenvolver e juntar diferentes
componentes do seu projeto. (WIKIPÉDIA, 2008).
Um framework deve reunir as funcionalidades principais de várias aplicações onde o
foco principal, ou problema, devem pertencer a um mesmo domínio.
Frameworks são projetados com a intenção de facilitar o desenvolvimento de
software, habilitando designers e programadores a gastarem mais tempo determinando as
exigências do software do que com detalhes de baixo nível do sistema. (WIKIPÉDIA, 2008).
As principais características de um Framework são: provê a solução para um conjunto
de problemas semelhantes e a reutilização de design provendo um guia de solução para um
domínio específico. Especificamente em POO (Programação Orientada a Objeto), o
Framework fornece um conjunto de classes e interfaces que mostra como decompor os
problemas que surgem durante a implementação (o conjunto de classes deve ser extensível e
flexível para possibilitar a construção de várias aplicações com pouco esforço)
Um Framework pode incluir programas de suporte, bibliotecas de códigos, linguagens
de script e outros software no sentido de colaborar no desenvolvimento de diferentes
componentes em um projeto de software.
Segundo SAUVÉ Jacques Philippe:
Existem grandes diferenças em um Framework e uma biblioteca de classes orientada a objeto. Em uma biblioteca de classes, cada classe é única e independente das outras. Em contrapartida, em um Framework as dependências ou colaborações já estão embutidas no projeto. (SUAVÈ, [SD])
A figura 1 mostra a diferença referenciada por SUAVÉ apresentando como as classes
e objetos se comportam num Framework e numa biblioteca de classes.
18
Figura 1: Exemplo da diferença entre uma biblioteca de classes e um
Framework (Sauvé Jacques Philippe)
O quadro do lado esquerdo que representa a biblioteca de classes é representado sendo
apenas um repositório. A imagem mostra claramente que as classes que compõe uma
biblioteca não se relacionam e são totalmente independentes, ou seja, elas não colaboram
entre si enviando mensagens ou mesmo compartilhando métodos. Já a representação do
framework na figura 1 mostra que as classes de um framework podem interagir umas com as
outras trocando mensagens ou até mesmo complementando uma a outra.
Segundo FAYAD e SCHMIDT: Framework é um conjunto de classes que colaboram
para realizar uma responsabilidade para um domínio de um subsistema da aplicação.
Ainda segundo SAUVÉ Jacques Philippe (SD), já que a comunicação entre objetos já
está definida, o projetista de aplicações não precisa saber quando chamar cada método: é o
Framework que faz isso.
Segundo o site www.palpitedigital.com.br:
Especificamente em orientação a objeto, Framework é um conjunto de classes com objetivo de reutilização de um design, provendo um guia para uma solução de arquitetura em um domínio específico de software.
Ainda segundo SAUVÉ Jacques Philippe (SD), um Framework deve ser reusável, mas
para ser reusável, primeiro ele tem que ser usável, bem documentado e fácil de usar.
Um Framework deve ser também extensível contendo funcionalidades abstratas (sem
implementação) que devem ser completadas; deve ser de uso seguro (o desenvolvedor de
19
aplicações não pode destruir o Framework); deve ser eficiente em suas aplicações devido ao
seu uso em muitas situações; deve ser completo para endereçar o domínio do problema
pretendido.
Atualmente existem diversos frameworks desenvolvimento com PHP. A seguir uma
breve citação de alguns Framework.
1.2 VANTAGENS DE SE UTILIZAR UM FRAMEWORK
Diante da busca de soluções para acelerar o desenvolvimento de uma aplicação,
principalmente a codificação e a documentação, recorre-se aos Frameworks. Para tirar bom
proveito do uso de um framework, o desenvolvedor terá que estudá-lo, tendo que, muitas
vezes, entender seus códigos, readaptar sua maneira de escrever códigos, ou seja, se adequar a
uma sintaxe diferente, chegando até a se sentir limitado às funcionalidades que o Framework
oferece.
Segundo Minetto, 2007, para se utilizar um novo Framework:
É necessário aprender uma sintaxe diferente, convenções para nomes de arquivos, variáveis e tabelas de banco de dados. Além disso, muitas vezes surge a sensação de estar “engessado”, pois é preciso fazer as coisas da forma que o Framework trabalha, de modo que qualquer coisa diferente requer um empenho melhor. Contudo, as vantagens a médio e longo prazo fazem esse pequeno esforço inicial valer.
Dentre as vantagens citadas por Minetto, 2007, destacam-se: a manutenibilidade, a
automatização de muitas tarefas repetitivas e a separação da apresentação e da lógica.
Em se tratando da manutenibilidade, os programadores que usam um determinado
Framework, programam usando uma mesma convenção, por isso entender os códigos escritos
entre eles é muito mais fácil. Em conseqüência, a inclusão de novos programadores na equipe
se torna mais fácil diminuindo o custo e tempo com treinamento.
Já na parte da separação da apresentação e da lógica, vale a pena destacar que este
conceito é possível devido a utilização de design patterns ou padrões de projeto, mais
especificamente o MVC Model, View e Controller (Modelo, Visão e Controlador).
20
1.3 ALGUNS FRAMEWORK PHP
1.3.1 PRADO PHP FRAMEWORK
O PRADO é um Framework de PHP5 baseado em componentes e eventos, que torna o
modelo de programação WEB muito similar ao ASP.NET. Criado por Qiang Xue, o PRADO
foi inicialmente inspirado no projeto Apache Tapestry. Durante o design e implementação, o
Borland Delphi e o ASP.NET tiveram um papel importante na definição do Framework.
Aqueles que já conhecem essas tecnologias vão se sentir mais confortáveis no seu
entendimento. (FRAMEWORK, Prado.2005).
Como principais características, podemos citar: viewstate1, sessions2, caching3,
validação de formulários, autenticação e autorização.
Segundo FRAMEWORK, PRADO (2008), o PRADO fornece os seguintes benefícios
para os desenvolvedores: reusabilidade, facilidade de utilização e a robustez.
Os códigos dos componentes de PRADO são altamente reusáveis. Tudo em PRADO é
um componente reusável.
No PRADO a criação e o uso de componentes é extremamente fácil. Em geral,
envolve simplesmente configurar propriedades componentes.
O PRADO é robusto, pois reduz o esforço empreendido pelos colaboradores na
criação de mais funcionalidades.
1.3.2 SYMFONY PHP FRAMEWORK
Como todo Framework, o Symfony apresenta uma estrutura para desenvolvimento de
aplicações destinado a agilizar a criação e manutenção das aplicações web. O Symfony é uma
estrutura PHP5 orientado a objeto baseada no modelo MVC permitindo a separação de regras
de negócio, a lógica do usuário e a visão da apresentação de uma aplicação para web.
Também contém ferramentas numerosas que visam encurtar a fase de desenvolvimento de
uma aplicação complexa para web.
1 ViewState é o mecanismo qual o framework utiliza para manter o estado de controles e objetos quando há uma mudança de página. As informações são armazenadas em um controle html do tipo hidden. 2 Sessions é uma funcionalidade do PHP. É utilizada por meio de uma variável global. 3 Caching é um mecanismo interno do sistema que serve de intermediário entre o operador de um sistema e o dispositivo de armazenamento. A principal função é evitar o acesso ao dispositivo de armazenamento - que pode ser demorado -, armazenando os dados em meios de acesso mais rápidos.
21
A primeira versão do Symfony foi lançada em outubro de 2005, pelo fundador do
projeto Fabien Potencier. O Symfony é patrocinado pela Sesion, uma agência web francesa
muito conhecida pelos seus pontos de vista inovadores sobre desenvolvimento web.
Segundo o site oficial: “Symfony destina-se a construir aplicações robustas em um
contexto empresarial”.
O Symfony oferece uma estrutura inteiramente caracterizada que inclui tudo que o
programador da web necessita: suporte completo e nativo a internacionalização, boa
documentação (tutoriais, wiki´s4, livros, os screencasts5, APIs e exemplos reais), geradores de
códigos e vários módulos e bibliotecas "pré-construídas" para as tarefas mais comuns.
O Symfony foi desenvolvido tomando como base experiências em outros Frameworks
de sucesso obtendo desta experiência os melhores conceitos e práticas.
Para os desenvolvedores que optarem por trabalhar com o Symfony, tem ainda o
suporte, não menos importante, de uma boa comunidade.
Em contrapartida o Symfony tem alguns pontos desfavoráveis como: contempla
somente o PHP5, não é recomendado para projetos simples e parece ser muito grande
comparado aos outros, e com muitos recursos que não são úteis a todos os colaboradores.
Symfony implementa a execução fácil de AJAX e inclui o suíte inteiro de scripts.
"script aculo.us" de efeitos do Javascript. Symfony tem também a habilidade de gerar
"CRUD e scaffolding" da aplicação de uma base de dados já construída em SQL. Isso
significa que ele incorpora toda SQL. (PULIDO, Nick.2006).
Bases de dados suportadas: MySQL, PostgreSQL, SQLite, Oracle, MS SQL e
qualquer outra suportada pela camada de abstração da base de dados Creole.
1.3.3 CAKE PHP FRAMEWORK
CakePHP é um Framework escrito em PHP que tem como principal objetivo oferecer
uma estrutura que possibilite aos programadores de PHP de todos os níveis desenvolverem
aplicações rapidamente, sem perder flexibilidade.
4 Wiki é um sistema que possibilita o compartilhamento de conteúdos on-line, permitindo a edição do seu conteúdo por qualquer um. Não só se adiciona conteúdo, como se complementa o conteúdo existente, editando-o, acrescentando ou corrigindo. 5 Screencasts é o registro (gravação) da saída do vídeo gerado por computador em atividade. Pode ou não conter
o áudio integrado. São largamente utilizados em forma de vídeo-tutoriais ou vídeo-aulas.
22
A primeira versão do Cake foi lançada no dia 15 de abril de 2005. O projeto ainda está
em desenvolvimento e se encontra na versão 1.2.
O CakePHP é baseado no Framework Ruby on Rails e utiliza padrões de projeto
conhecidos, tais como ActiveRecord, Association Data Mapping, Front Controller e MVC
(Model-View-Controller). (pt.wikipedia.org/wiki/CakePHP).
Segundo site oficial “O CakePHP possibilita a desenvolvedores de PHP desenvolver
rapidamente aplicações robustas na web” (cakephp.org)
Este modelo fornece uma estrutura que permite aos usuários de PHP em todos os
níveis o poder de desenvolver rapidamente aplicações robustas para web, sem nenhuma perda
de flexibilidade.
Os fatores favoráveis que podem ser destacados deste Framework são: contém
somente o código essencial, funciona em PHP4 e PHP5, é necessário somente a execução de
uma configuração simples e curta da base de dados e em algumas constantes que podem ser
modificadas, permite a criação de arquiteturas complexas da base de dados, estrutura
extremamente lógica e funcional de diretórios, fácil uso de AJAX (Asynchronous Javascript
And XML - desenvolvimento de aplicações em JavaScript com XML) através dos ajudantes
que auxiliam na criação de AJAX e de Javascript, possui um script de linha de comando para
gerar automaticamente partes do código, chamado BAKE, comunidades muito ativas e o fato
de ser apropriado para qualquer tipo de website,dá aplicação pessoal de pequeno porte à
aplicação avançada de e-business.
Os pontos desfavoráveis são: não faz uso inteiramente das vantagens oferecidas pelo
PHP5 e a documentação oficial necessita ainda alguma melhoria, principalmente em outros
idiomas como o português.
Bases de dados suportadas: MySQL, PostgreSQL, SQlite, MS SQL + e outras que
suportem a camada de abstração das bases ADOdb ou PEAR::DB23.
1.3.4 MIOLO PHP
O framework MIOLO PHP por ter sido escolhido como ferramenta para este trabalho
terá um capítulo dedicado a ele, onde serão detalhados seus conceitos, seu histórico, sua
arquitetura, suas funções mais importantes, a implementação de suas camadas, a estrutura de
seus diretórios e seus principais arquivos.
23
1.4 CONSIDERAÇÕES FINAIS
Com base nas pesquisas realizadas, em sites, periódicos e livros especializados em
desenvolvimentos com PHP, os resultados indicam diversos tipos de Frameworks. Escolher
um Framework para servir de base para uma aplicação onde se deseja ter liberdade para criar
e que ao mesmo tempo torne a tarefa de desenvolvimento menos cansativa não é das mais
fáceis. Para tal escolha seria necessário à instalação e experimentação de vários Frameworks
para, assim, se realizar um comparativo. Como o objetivo deste trabalho não é fazer
comparações entre frameworks e sim apresentar as vantagens da utilização dos mesmos,
dentre tantos frameworks consagrados, o MIOLO foi escolhido por ser uma nova opção de
framework para desenvolvimento PHP, estável, de código aberto, totalmente nacional e
voltado para o ambiente corporativo.
Os frameworks têm seu foco voltado para desenvolvedores. O Framework MIOLO já
possui todas as características, que serão mais detalhadas no capítulo seguinte, e vantagens
apresentadas pelos frameworks citados neste capítulo.
É importante destacar que um framework se apresenta de uma maneira mais
complexa, e que para se trabalhar com framework, tanto para PHP ou qualquer outra
linguagem, é preciso conhecimento da linguagem utilizada por ele.
Segundo Rubens Queirós de Almeida (2004):
Se imaginarmos que o conjunto de objetos com os quais se desenvolve uma aplicação é similar às peças de um Lego, o Miolo oferece tais peças, mas feitas de "massa de modelar". Assim, se um determinado objeto não se presta exatamente a uma função específica, ele pode ser estendido para que sirva, e ainda, se necessário, o Miolo permite obviamente o uso do PHP diretamente para que se criem novos objetos ou funções (ALMEIDA, 2004).
2 DETALHANDO O FRAMEWORK MIOLO
2.1 INTRODUÇÃO
O MIOLO como os demais Frameworks apresentados neste trabalho, oferece uma
excelente estrutura de trabalho para PHP objetivando o desenvolvimento de aplicações web.
O Framework MIOLO é um Framework totalmente desenvolvido com a linguagem
PHP, que oferece uma grande gama de funções para otimizar e agilizar o processo de criação
de sistemas.
O MIOLO teve seu projeto de desenvolvimento baseado no SAGU (Sistema
Acadêmico de Gestão Unificada), tendo algumas funções como o mapeamento de
necessidades, definição de funcionalidades e a metodologia utilizada no MIOLO baseados no
SAGU.
O MIOLO trabalha com o conceito de modularização. Nessa sistemática, o processo
de criação de um novo módulo para um sistema ou mesmo a integração de módulos/sistemas
distintos, torna-se uma tarefa muito simples. Isso possibilita inclusive que, utilizando a
mesma senha e de acordo com os direitos de acesso, um usuário possa interagir em diferentes
sistemas no mesmo ambiente de produção. Essa estrutura permite um grande
reaproveitamento de funcionalidades, contribuindo inclusive para padronização do código.
Outra característica relevante também, está no fato do MIOLO tratar, de forma transparente,
das conexões a Bases de Dados. Dessa forma, por exemplo, é fácil implementar soluções
distribuídas, inclusive em diferentes posições geográficas do globo.
Dentre outras características que podem ser destacadas estão: geração e apresentação
das páginas utilizando o conceito de temas, o que facilita a mudança e criação de novas
interfaces para os usuários, a automatização do processo de criação e validação de formulários
para entrada de dados, a montagem automática de listagens e controle relacionados, o controle
das conexões e abstração da Base de Dados, o controle de erros, a validação de usuários e o
controle dos direitos de acesso.
Atualmente o MIOLO está na versão 2.0 e o grande diferencial para as versões
anteriores é ser totalmente orientado a objetos.
Segundo o site www.miolo.codigolivre.org.br:
O MIOLO consiste em um conjunto de objetos para a conexão e manipulação de bases de dados, construção de interface web e fornece um
25
ambiente que garante a implementação de segurança lógica na aplicação entre uma série de outras funcionalidades. A UNIVATES já utiliza o MIOLO em seus projetos GNUTECA, PILA, QUALITAS e no SAGU2, que está em desenvolvimento.
O MIOLO 2.0 é um Framework para criação de sistemas de informação acessíveis via
WEB, baseado na linguagem PHP5, scripts Javascript e conceitos de POO (Programação
Orientada a Objetos), gerando páginas HTML. Como o MIOLO é o "kernel" de todos os
sistemas criados, os mesmos podem ser facilmente integrados, funcionando como módulos de
um sistema mais complexo. Além de proporcionar as funcionalidades para o desenvolvimento
de sistemas, o MIOLO também define e implementa toda uma sistemática e uma metodologia
para que os resultados esperados sejam obtidos de forma simples.
O MIOLO é um framework voltado para o desenvolvimento de sistemas WEB e foi
desenvolvido na linguagem PHP, sendo resultado da evolução da metodologia de
desenvolvimento de sistemas em software livre da Solis (Cooperativa de Soluções
Livres, uma cooperativa de serviços formada no início de 2003, apoiada pela
Univates, Centro Universitário, em Lajeado, RS). Em resumo, o MIOLO contempla todos os
pré-requisitos necessários em uma aplicação como o acesso a bases de dados, apresentação de
resultados e formulários de entradas de dados aos usuários, segurança e níveis de acesso, entre
outros.
2.2 HISTÓRICO
No início de 2001, Thomas Spriestersbach e Vilson Cristiano Gartner, iniciaram a
construção do framework com cinco versões RC (Release Candidate). Em 2003, ficou pronta
a versão 1.0 final do MIOLO pela Solis.
Ainda em 2003, a Universidade Federal de Juiz de Fora – UFJF, começou a utilizar o
MIOLO para desenvolvimento de sistemas corporativos e são feitas várias mudanças e
adaptações ao Framework. Em 2005, houve a unificação das mudanças e adaptações que a
UFJF (Universidade Federal de Juiz de Fora) fez com as idéias dos desenvolvedores da Solis
visando a versão dois do Framework. O MIOLO 2.0 agora se encontra na versão beta 4.
O MIOLO é usado como base para uma série de outros produtos desenvolvidos pela
Solis, como o Gnuteca, o Fred, o Scotty, o Sagu2, entre outros, implementado na linguagem
PHP e usando Orientação a Objetos.
26
A principal inovação do MIOLO na versão 2 em relação a primeira é a programação
Orientada a Objetos. Isso dificulta o trabalho dos programadores de MIOLO 1.0, ao tentar
adaptar o código feito para o MIOLO 2.0, fazendo o reescrever totalmente o código. Podemos
afirmar que a versão 2.0 do MIOLO é muito diferente da versão 1.0.
2.3 ARQUITETURA DO FRAMEWORK MIOLO
O MIOLO utiliza o conceito de modularização, ou seja, trabalha com módulos
distintos que juntos formam a aplicação. Nessa sistemática, o processo de criação de um novo
módulo para um sistema ou mesmo a integração de módulos/sistemas distintos, torna-se uma
tarefa muito simples. Isso possibilita inclusive que, utilizando a mesma senha e de acordo
com os direitos de acesso, um usuário possa interagir em diferentes sistemas no mesmo
ambiente de produção. Essa estrutura permite um grande reaproveitamento de
funcionalidades, contribuindo inclusive para padronização do código.
O MIOLO possibilita a divisão do trabalho em várias equipes durante o
desenvolvimento de um sistema, assim uma equipe que esteja com a função de criar a
estrutura de base de dados não necessita, obrigatoriamente manter um relação com a equipe
que projeta a interface do sistema, permitindo que se possa retirar o máximo de
aproveitamento dos colaboradores relacionados ao projeto desenvolvido.
Os sistemas são construídos através do desenvolvimento de módulos. O conjunto de
módulos é chamado aplicação. Assim, de forma geral, cada instalação do Framework está
associada a uma única aplicação, composta por um ou vários módulos integrados.
Um módulo é um componente de uma aplicação. De forma geral, um módulo reflete
um sub-domínio da aplicação, agregando as classes de negócio que estão fortemente
relacionadas e provendo o fluxo de execução (handlers) e a interface com o usuário (forms,
grids, reports) para se trabalhar com tais classes. Um módulo é caracterizado por um nome,
usado como subdiretório do diretório <miolo>/modules. Cada módulo possui seu próprio
arquivo de configuração e tem uma estrutura de diretório padrão. Essa estrutura é usada pelo
Framework para localizar os recursos.
Existem ainda os controles (Widgets) que são componentes de interface com o
usuário, usados na renderização das páginas html. Um controle pode agregar outros controles
e tem propriedades e eventos associados a ele.
27
A página é um controle específico (instanciado da classe Mpage) que serve de base
para a renderização de uma página HTML.
O tema é um controle específico (instanciado da classe Theme), que trabalha como um
container para os controles que também serão renderizados na página HTML. Cada tema
define “elementos”, e cada elemento agrega controles visuais específicos. Um tema é
associado a uma (ou várias) folha de estilos (um arquivo CSS) que define o posicionamento,
as dimensões e a aparência dos controles a serem renderizados. Podem ser definidos vários
temas (cada um com seu próprio diretório, no diretório <miolo>/classes/ui/themes), embora
geralmente cada módulo utilize apenas um tema. Como o MIOLO é uma aplicação de código
aberto e possui um grande número de colaboradores, novos temas vêm sendo inseridos e
qualquer usuário pode contribuir com novos temas.
O handler é considerada uma das instâncias mais importantes dentro da estrutura do
MIOLO. Ele é uma instância da classe MHandler e sua principal função é tratar a solicitação
feita pelo usuário através do browser. Em cada módulo (no diretório
<miolo>/modules/<modulo>/handler) é definida uma classe Handler<Modulo>, que é
instanciada pelo MIOLO quando é feita a análise da solicitação do usuário. O controle é então
passado para esta classe, que inclui o handler específico para tratar a solicitação. O handler
atua, assim, no papel de controller, fazendo a integração entre as regras de negócio e a
interface com o usuário.
Figura 2: Função controller do handler
28
Namespaces são apenas aliases6 para diretórios. O objetivo do uso de namespaces é a
possibilidade de mudança física dos arquivos, sem a necessidade de se alterar o código já
escrito. Os namespaces são usados basicamente no processo de importação (include) de
arquivos, em tempo de execução.
Outras funções importantes do MIOLO são: controles de interface com o usuário,
escritos em PHP e renderizados em HTML, autenticação de usuários, controle de permissão
de acesso, camada de abstração para acesso a bancos de dados realizado através da camada
DAO (Data Access Objects) e tem por objetivo encapsular as diversas extensões fornecidas
pelo PHP, permitindo usar uma única interface de programação, independente do banco de
dados que esta sendo utilizado, camada de persistência transparente de objetos, gerenciamento
de sessões e estado, manutenção de logs, mecanismos de trace e debug, tratamento da página
como um webform, no modelo event-driven, validação de entrada em formulários,
customização de layout e temas, usando CSS, geração de arquivos PDF e controle de erros.
2.4 IMPLEMENTAÇÃO DAS CAMADAS DO FRAMEWORK MIOLO
O MIOLO adota uma arquitetura em camadas, implementando o padrão MVC (Model-
View-Controller):
• View (Visão): É a camada de visualização da sua aplicação, onde ela apenas
apresenta o que foi obtido através do controle. Ou seja, é a interface que é apresentada ao
usuário e por onde o usuário vai interagir com o sistema.
• Controller (Controle): É responsável por receber as requisições enviadas pelo
usuário através da interface (visão). Toda a lógica da aplicação é feita no controle. É o
controle que faz o contato da interface com o modelo.
• Model (Modelo): É o modelo da sua aplicação, onde são definidos
propriedades e atributos dos seus personagens. Na maioria dos casos existe ainda uma camada
de persistência dos dados (DAO – Data Access Objects) sendo adequada para o
desenvolvimento de aplicações web.
6 Apelido; usado para...
29
Utiliza o php5, que é Orientado a Objetos, aplica padrões de projeto, que nomeiam,
abstraem e identificam os aspectos chave de uma estrutura de projeto comum, assim
possibilitando criar um projeto orientado a objetos reutilizável.
O Framework funciona como um conjunto de classes cooperantes que constroem um
projeto reutilizável, ditando sua própria arquitetura de aplicação. O programador constrói uma
aplicação criando subclasses das classes do Framework e ele enfatiza a reutilização de
projetos.
A figura abaixo apresenta a arquitetura básica do MIOLO.
Figura 3: Estrutura de Camadas do MIOLO
CAMADA DE INTEGRAÇÃO
Classe MIOLO: representa o Framework, expondo métodos que fazem a integração
entre as diversas camadas. Implementa o padrão Facade.
• User Interface (UI) – camada de apresentação
São as classes do Framework responsáveis pela geração de arquivos, renderização dos
controles HTML e da criação dos scripts Javascript enviados ao cliente, com base no tema em
uso. Engloba também as classes criadas pelos usuários para definir a interface da aplicação
geralmente nos diretórios forms, menus e reports de cada módulo;
Camada de apresentação (X)HTML, Javascript, CSS, componentes UI, temas
Camada de negócios Objetos que implementam as regras de negócio, encapsulam o acesso
aos dados.
Camada de integração MIOLO, fluxo de trabalho, acesso a recursos,...
Camada de recursos Banco de dados, sistemas externos
30
• Handlers – camada de integração
São as classes que representam a parte funcional da aplicação, criadas pelo
desenvolvedor para fazer o tratamento dos dados enviados pelo cliente. Acessa a camada de
negócios para desempenhar suas funções e usa a camada UI para definir a saída para o cliente.
Estão localizadas no diretório handlers de cada módulo;
• Business – camada de negócios
São as classes criadas pelo desenvolvedor para representar o domínio da aplicação (as
regras de negócio). São usadas pelas camadas UI e handlers, acessando o banco de dados
através da camada BD;
• BD – camada de recursos
São as classes do Framework responsáveis por abstrair o acesso às bases de dados,
tornando as classes da camada Business independentes do SGBD usado;
• Utils e Services – camada de recursos
São as classes do Framework responsáveis por oferecer recursos e funcionalidades
necessárias tanto pelo Framework quanto pelas aplicações dos usuários, encapsulando o
acesso a recursos da linguagem ou do sistema operacional.
Figura 4 - Implementação de camadas em MVC
Usuários
MVC – view
UI components
MVC – Model
Business
Data Access
Persistence
Util
ities
Sec
urity
Ser
vice
s
MIO
LO
Data Bases
Services
31
2.5 ESTRUTURA DE DIRETÓRIOS
A arquitetura física do framework apresenta várias divisões e subdivisões, o que
aumenta muito o seu poder de manutenibilidade e flexibilidade, tornando a função de cada
pasta e subpasta simples por usar uma nomenclatura de fácil compreensão, além disso,
consegue separar de maneira segura o que é interno ao framework e o que é subsistema, que
será tudo que se encontrar dentro da pasta modules:
A seguir uma relação do diretório de instalação do módulo MIOLO com uma breve
explicação de sua composição:
• classes – contém as classes que formam o kernel do MIOLO;
• classes/contrib – classes de terceiros, que podem ser usadas no Framework;
• classes/database – classes que implementam o acesso a banco de dados (a
camada DAO – Data Acess Objects);
• classes/doc – classes para geração da documentação;
• classes/extensions – classes que estendem a funcionalidade do Framework, por
herança ou composição de componentes existentes, mas que não fazem ainda parte do “core”
do Miolo;
• classes/etc – arquivos auxiliares, como o autoload.xml que define a localização
dos arquivos que implementam as classes;
• classes/ezpdf – classes da biblioteca ezPDF, para geração de arquivos PDF;
• classes/flow – classes relacionadas ao fluxo de execução de uma requisição;
• classes/model – classes relacionadas à camada Business;
• classes/persistence – classes que implementam o mecanismo de persistência de
objetos em bancos de dados;
• classes/pslib – classes utilizadas para geração de arquivos PostScript;
• classes/security – classes relacionadas às tarefas de segurança (autenticação,
autorização, criptografia, etc);
• classes/services – classes utilitárias e de serviços gerais;
• classes/ui – classes relacionadas à interface com o usuário (controles,
renderização html e relatórios em pdf);
• classes/util – classes utilitárias;
32
• modules – contém um subdiretório para cada módulo do sistema. Cada módulo
possui uma estrutura de diretórios pré-definida;
• var/db – contém um banco de dados Sqlite para armazenamento de dados
relativos à execução das aplicações;
• var/log – contém os arquivos de logs gerados pelo MIOLO e pelos sistemas;
• var/report – contém os arquivos PDF gerados pelas rotinas de reports;
• var/trace – contém os arquivos usados no processo de debug da aplicação;
• locale – contém o sistema usado para internacionalização;
• etc/miolo.conf – arquivo principal de configuração do MIOLO;
• html – contém as páginas do sistema, bem como os subdiretórios para imagens
e scripts. Deve ser o único diretório visível via web;
• docs – textos de documentação.
2.6 ARQUIVOS PRINCIPAIS
• <miolo>/html/index.html – É o arquivo acessado pelo servidor web e que
inicia o processo de criação do ambiente para o sistema. Neste arquivo é criado um frameset
com um frame (“content”) utilizado para criação do conteúdo das páginas do sistema
propriamente dito (visíveis para o usuário). Neste frame “content” é chamado o arquivo
index.php. O objetivo do uso de frames é evitar que as urls usadas pelo Framework sejam
exibidas no browser;
• <miolo>/html/index.php - O arquivo index.php (que pode ter um nome
diferente, caso a configuração em miolo.conf7 seja modificada) é o manipulador principal do
MIOLO, utilizado por todos os módulos e sempre definido nos links que são criados pelos
menus, formulários e funções de criação automáticas de links. A principal função do arquivo
index.php é instanciar um objeto MIOLO (que é a classe principal do Framework, atuando
como uma fachada) e executar o método HandlerRequest, que vai tratar a solicitação do
usuário (feita via browser);
• <miolo>/etc/miolo.conf - Arquivo no formato XML que mantém as
configurações do ambiente; 7 Arquivo de configuração do MIOLO
33
• <miolo>/classes/support.inc – Neste arquivo estão definidas as funções
globais do Framework;
• <miolo>/html/scripts/m_common.js - Esse arquivo contém as principais
funções Javascript utilizadas pelos componentes e pelo Framework;
• <miolo>/classes/miolo.class - Essa é a principal classe do MIOLO,
implementada com o padrão singleton8. Contém os principais métodos do Framework,
atuando como uma fachada (padrão façade) para acesso aos serviços implementados nas
demais classes.
8 Design pattern (padrão de projeto) que tem o objetivo garantir que existe apenas uma instância de uma certa classe a qualquer instante e em qualquer ponto de um sistema. (Fonte: http://www.javafree.org/wiki/Singleton)
3 ANÁLISE DO SISTEMA PROPOSTO
3.1 Domínio do sistema
Durante a pesquisa campal foram coletadas diversas informações bibliográficas sobre
as obras literárias nas diversas instituições de Campos. As informações mais relevantes e que
deverão ser catalogadas são:
• Das instituições: nome da instituição, endereço, telefone, e-mail, homepage, nome
do responsável, horário de funcionamento, característica do acervo e etc;
• Das obras: título, autor, editora, ano de publicação, assuntos, estado de
conservação. As obras são separadas por tipo de literatura: livros, periódicos, teses
e outros documentos.
O sistema que se pretende criar deverá organizar os dados coletados e disponibilizar a
pesquisa a essas publicações via internet. O cadastro das publicações deverá ser on-line, para
isso, o sistema disponibilizará uma área restrita aos funcionários responsáveis pela
manutenção do mesmo. Os funcionários responsáveis pela parte administrativa do sistema
devem entrar com login e senha para acessar a área restrita do site onde estão as opções de
manutenção dos dados como: cadastro, alteração e exclusão de registros.
No cadastro dos livros, os campos editores, autores e assuntos serão buscados em
tabelas complementares e, por esse motivo, deverão estar cadastrados previamente.
Antes de registrar um novo autor, uma nova editora ou um novo assunto, o sistema
deve verificar se o novo item a ser cadastrado já existe ou não para evitar duplicidade. Nos
casos onde os cadastros forem idênticos, o sistema deve acusar a duplicidade e abortar a
operação.
O objetivo principal do sistema é permitir a consulta on-line, portanto, o site deve
permitir aos usuários a consulta dos livros e teses através do nome dos autores, do título, do
assunto ou pela série.
O sistema deve oferecer pelo menos duas opções de consulta: a consulta geral, onde o
usuário entra com a palavra chave e o sistema retorna as publicações que contenham em
qualquer campo o termo utilizado na busca, e a consulta avançada, onde o usuário pode
selecionar se quer buscar pelo assunto, título, série ou autor.
O sistema deve permitir ao usuário selecionar um item retornado pela busca e
visualizar as informações completas da ficha ou em formato de referência bibliográfica. O
35
sistema deve ainda permitir ao usuário selecionar os itens e montar um relatório de impressão
desses itens.
O cadastro do periódico deve conter título, editor/instituição, periodicidade, idioma,
ISSN (International Standard Serial Number), nacionalidade, nota e a relação da coleção com
o volume, número, ano e mês.
A consulta de periódicos será feita pelo título do periódico ou pelo nome da
editora/instituição. O resultado mostrará o título, a editora/instituição e a opção de
visualização da coleção existente.
O sistema deve fornecer ao usuário informação sobre a instituição como: nome,
endereço, informar se é pública ou privada, telefone, e-mail, horário de funcionamento, nome
do diretor ou responsável.
Podemos notar que esse projeto se assemelha a um sistema de biblioteca, porém será um
sistema diferenciado uma vez que não proverá diversos serviços oferecidos por uma biblioteca
convencional como: empréstimo, reserva de publicações e etc. Vale lembrar ainda que este sistema
apenas servirá de orientação aos leitores/pesquisadores, indicando aos mesmos quais obras possuem
determinada Instituição e ou indicando onde o pesquisador poderá encontrar uma determinada obra. O
sistema indicará ainda os dados catalográficos da publicação, estado da mesma e, caso seja possível,
como o usuário deverá proceder para ter acesso ao material pesquisado.
3.2 Requisitos do sistema
3.2.1. Requisitos funcionais
Deve oferecer uma interface de administração da aplicação e outra para acesso dos
clientes (usuários);
A aplicação deve ser capaz de validar o usuário e senha e distinguir se eles são
simples usuários ou pertencem ao grupo de administrador do sistema;
Deve direcionar para a interface correta de acordo com o usuário que efetuar login.
A interface de administração da aplicação deve oferecer:
• Opção de menu para inserção de novos usuários;
• Opção de menu para alteração de usuários;
• Opção de menu para exclusão de usuários;
• Opção de menu para exibir todos os usuários cadastrados;
• Opção de menu para efetuar logout da aplicação;
36
• Permitir que seja possível gerar novo volume a partir de um já cadastrado,
evitando digitar tudo outra vez;
A interface de usuário deverá conter:
• Opção de menu para retornar ao momento inicial da aplicação;
• Opção para efetuar buscas por tipo de publicação;
• Opção montar automaticamente listas de assuntos, autores, instituições e
séries;
• Opção de impressão dos resultados das buscas;
• Permitir que seja exibido o resultado da busca no formato ABNT de referência
Bibliográfica.
3.2.2. Requisitos não-funcionais
• A interface deve ser simples e objetiva;
• A aplicação não deve conter cores carregadas que prejudiquem a visualização
dos dados. Usar preferencialmente cores leves e de tom claro;
• Ser desenvolvido usando uma linguagem que evite o uso de programas
auxiliares, por exemplo, facilitando o acesso a qualquer tipo de usuário;
• Ser leve e de fácil adaptação para que possa ser alocada em qualquer máquina
ou servidor;
3.3 Modelagem UML Neste projeto usaremos para a análise orientada a objetos a linguagem de modelagem
UML (Unified Modeling Language) para representar o foco do domínio do software que
pretendemos implementar.
Fundamentalmente a idéia da programação orientada a objeto é aproximar o mundo
real do virtual. Por isso usa o conceito de Objetos.
Através da UML e de seus diagramas é possível representar as classes de objetos e
seu comportamento dentro do sistema.
Os componentes de um modelo de casos de uso são:
• Ator - é um papel que tipicamente estimula/solicita ações/eventos do sistema e
37
recebe reações. Cada ator pode participar de vários casos de uso;
• Casos de uso - documento narrativo que descreve a seqüência de eventos feitos
por um ator no uso do sistema;
• Sistema - O sistema a ser modelado.
3.4 Casos de uso Os casos de uso têm por objetivo: decidir e descrever os requisitos funcionais do
sistema, fornecer uma descrição clara e consistente do que o sistema deve fazer e permitir
descobrir os requisitos funcionais das classes e operações do sistema (casos de uso NÃO são
requisitos).
O primeiro desafio foi identificar os casos de uso e relacioná-los. A seguir uma
relação dos casos de uso encontrados na fase de levantamento dos requisitos:
Relação dos casos de uso:
1- Efetuar Login;
2- Tratar Publicação;
3- Tratar Instituição;
4- Tratar Editoras;
5- Tratar Autor;
6- Tratar Assunto;
7- Consultar Publicação;
8- Consultar Instituição;
9- Imprimir Relatórios de Busca.
As descrições detalhadas dos casos de uso relacionados acima podem ser encontradas
nos apêndices deste trabalho.
3.5 Descrição dos Casos de Uso
CASO DE USO 1: EFETUAR LOGIN
38
Resumo: Esse caso de uso se inicia quando o usuário deseja acessar a área de restrita do site.
Ator: Funcionário.
Pré-condição: O usuário deverá estar on-line.
Pós-condição: O usuário acessa a área restrita.
FLUXO PRINCIPAL
Passo 1: O usuário navega pelo site e seleciona a opção “Área restrita”;
Passo 2: O sistema solicita o login e a senha do usuário;
Passo 3: O usuário informa login e senha;
Passo 4: O sistema valida os dados informados e exibe a área restrita.
FLUXO ALTERNATIVO
No passo 4, se os dados de login e senha informada não conferem, o sistema exibe a
mensagem: “Login e/ou senha estão incorretos”. O sistema retorna ao passo 2.
CASO DE USO 2: TRATAR FUNCIONÁRIO
Resumo: Este caso de uso inicia-se quando há a necessidade de cadastrar, atualizar ou excluir
um funcionário.
Ator: Funcionário.
Pré-condição: O funcionário atual do sistema deve estar logado.
CENÁRIO 1: CADASTRAR NOVO FUNCIONÁRIO
FLUXO PRINCIPAL
39
Passo 1: O funcionário seleciona no sistema a opção cadastro de funcionário;
Passo 2: O sistema exibe a tela de inclusão de dados de funcionário. O funcionário terá
acesso aos botões: salvar, limpar e cancelar;
Passo 3: O funcionário informa os dados do novo funcionário e clica no botão salvar;
Passo 4: O sistema valida e grava os dados emitindo a mensagem: “Dados cadastrados
com sucesso!”.
FLUXO ALTERNATIVO
No passo 1, se o funcionário não estiver logado: <include> Caso de uso “Efetuar
login”.
No passo 3, se o funcionário escolher a opção limpar, o sistema limpa os campos e
retorna o cursor para o primeiro campo do formulário.
No passo 3, se o funcionário escolher a opção “Cancelar”, o sistema aborta a operação,
fecha o formulário de cadastro e retorna ao passo 1.
No passo 4, o sistema verifica que alguns dados obrigatórios não foram preenchidos e
envia a mensagem: “Campos obrigatórios não foram preenchidos”.
No passo 4, o sistema não consegue enviar os dados ao banco de envia a mensagem:
“Erro ao conectar ao banco de dados”.
O sistema retorna ao passo 1.
CENÁRIO 2: ATUALIZAR FUNCIONÁRIO
FLUXO PRINCIPAL
Passo 1: O funcionário seleciona a atualizar cadastro de funcionário;
Passo 2: O sistema solicita o nome ou código a ser alterado;
40
Passo 3: O funcionário entra como nome ou código a ser atualizado;
Passo 4: O sistema retorna a ficha pesquisada para ser editada;
Passo 5: O funcionário atualiza os dados e clica na opção salvar;
Passo 6: O sistema valida e grava os dados emitindo a mensagem: “Dados atualizados
com sucesso!”.
FLUXO ALTERNATIVO
No passo 4, caso o sistema não encontre a ficha a ser alterada, o sistema emite a
mensagem: “Funcionário não encontrado”. O sistema retorna ao passo 3.
CENÁRIO 3: EXCLUIR FUNCIONÁRIO
Passo 1: O funcionário seleciona a opção excluir do cadastro de funcionário;
Passo 2: O sistema solicita o nome ou código a ser excluído;
Passo 3: O funcionário entra como nome ou código do funcionário;
Passo 4: O sistema retorna a ficha pesquisada e as opções: excluir e cancelar;
Passo 5: O funcionário verifica os dados e seleciona a opção excluir;
Passo 6: O sistema exclui o registro selecionado e envia a mensagem: “Dados
excluídos com sucesso!”.
FLUXO ALTERNATIVO
No passo 4, caso o sistema não encontre a ficha a ser excluída, o sistema emite a
mensagem: “Funcionário não encontrado”. O sistema retorna ao passo 3.
CASO DE USO 3: TRATAR PUBLICAÇÃO
41
Resumo: Esse caso inicia-se quando o funcionário deseja incluir, atualizar ou excluir um
livro.
Ator: Funcionário.
Pré-condição: os autores, editoras e assuntos, que serão arrolados ao novo item, devem estar
cadastrados.
O usuário deve estar logado no sistema.
CENÁRIO 1: INCLUIR UMA PUBLICAÇÃO (LIVRO E TESE)
FLUXO PRINCIPAL
Passo 1: O funcionário acessa a área de cadastro de publicação;
Passo 2: O sistema exibe o menu de opções: incluir, atualizar ou excluir;
Passo 3: O funcionário seleciona a opção incluir;
Passo 4: O sistema exibe a tela de inclusão de dados;
Passo 5: O funcionário informa os dados e seleciona a opção salvar;
Passo 6: O sistema valida os dados informados e grava no banco de dados;
Passo 8: O sistema envia mensagem: “Operação realizada com sucesso”.
FLUXO ALTERNATIVO
No passo 5: caso a editora do livro não esteja cadastrada: <extend> caso de uso
“Tratar editora”.
No passo 6, o sistema verifica que dados obrigatórios não foram preenchidos.
O sistema envia mensagem: “Campos obrigatórios não foram preenchidos”.
O sistema retorna ao passo 4.
42
No passo 6, o sistema não consegue se conectar ao banco de dados.
O sistema exibe mensagem: “Falha na conexão”.
O sistema aborta a operação.
O sistema retorna ao passo 1.
CENÁRIO 2: ATUALIZAR PUBLICAÇÃO
FLUXO PRINCIPAL
Passo 1: O funcionário acessa a área de cadastro de publicação;
Passo 2: O sistema exibe o menu de opções;
Passo 3: O funcionário seleciona a opção “Alterar”;
Passo 4: O sistema solicita o título a ser alterado;
Passo 5: O funcionário entra como título e manda buscar;
Passo 6: O sistema retorna a ficha da publicação existente no banco de dados;
Passo 7: O funcionário faz a correção dos dados e manda gravar;
Passo 8: O sistema valida os dados informados e grava no banco de dados;
Passo 9: O sistema envia mensagem: “Operação realizada com sucesso”.
FLUXO ALTERNATIVO
No passo 6, o sistema não localiza o título que se deseja alterar e emite a mensagem:
“Título não encontrado”. O sistema retorna ao passo 4.
No passo 8, o sistema verifica que dados obrigatórios não foram preenchidos. O
sistema envia mensagem: “Campos obrigatórios não foram preenchidos”.
O sistema retorna ao passo 7.
No passo 8, o sistema não consegue se conectar ao banco de dados. O sistema exibe
mensagem: “Falha na conexão”. O sistema aborta a operação.
43
CENÁRIO 3: EXCLUIR PUBLICAÇÃO
FLUXO PRINCIPAL
Passo 1: O funcionário acessa a área de cadastro de publicação;
Passo 2: O sistema exibe o menu de opções;
Passo 3: O funcionário seleciona a opção excluir;
Passo 4: O sistema solicita o nome ou o registro da publicação a ser excluída;
Passo 5: O funcionário entra com a publicação a ser excluída;
Passo 6: O sistema retorna a ficha do livro e pede a confirmação da exclusão;
Passo 7: O funcionário confirma a exclusão;
Passo 8: O sistema apaga o registro do banco de dados e emite a mensagem:
“Publicação excluída com sucesso!”.
FLUXO ALTERNATIVO
No passo 6, o sistema não localiza o nome informado e retorna a mensagem: “Livro
não encontrado!”.
CASO DE USO 4: TRATAR INSTITUIÇÃO
Resumo: Este caso de uso inicia-se quando o funcionário deseja cadastrar uma nova
instituição.
Ator: Funcionário.
Pré-condição: O usuário do sistema deve estar logado.
44
CENÁRIO 1: INCLUIR INSTITUIÇÃO
FLUXO PRINCIPAL
Passo 1: O funcionário solicita o acesso a área de cadastro de instituição;
Passo 2: O sistema exibe a tela de entrada de dados de instituição;
Passo 3: O funcionário entra com os dados da Instituição;
Passo 4: O sistema valida os dados da Instituição;
Passo 5: O sistema grava os dados da Instituição no banco de dados;
Passo 6: O sistema envia mensagem: “Operação realizada com sucesso”.
Fluxo alternativo
No passo 5, o sistema verifica que dados obrigatórios não foram preenchidos;
O sistema envia mensagem: “Campos obrigatórios não foram preenchidos”. O sistema
retorna ao passo 5.
No passo 6, o sistema não consegue se conectar ao banco de dados. O sistema exibe
mensagem: “Falha na conexão”. O sistema aborta a operação. O sistema retorna ao passo 1.
Caso de uso 5: Tratar Editoras
Resumo: Esse caso de uso inicia-se quando o usuário deseja incluir, alterar ou excluir uma
editora.
Ator: Funcionário.
Pré-condição: O usuário deve estar logado.
CENÁRIO 1: INCLUIR EDITORA
45
FLUXO PRINCIPAL
Passo 1: O funcionário solicita o acesso a área de cadastro de Editora;
Passo 2: O sistema exibe a tela de entrada de dados;
Passo 3: O funcionário entra com os dados da Editora;
Passo 4: O sistema valida os dados da Editora;
Passo 5: O sistema grava os dados da Editora no banco de dados;
Passo 6: O sistema envia mensagem: “Operação realizada com sucesso”.
FLUXO ALTERNATIVO
No passo 5, o sistema verifica que dados obrigatórios não foram preenchidos. O
sistema envia mensagem: “Campos obrigatórios não foram preenchidos”. O sistema retorna
ao passo 5.
No passo 6, o sistema não consegue se conectar ao banco de dados. O sistema exibe
mensagem: “Falha na conexão”. O sistema aborta a operação. O sistema retorna ao passo 1.
CASO DE USO 6: TRATAR AUTOR
Resumo: Esse caso de uso inicia-se quando o funcionário deseja incluir, alterar ou excluir um
autor.
Ator: Funcionário.
Pré-condição: O funcionário deve estar logado.
CENÁRIO 1: INCLUIR AUTOR
46
FLUXO PRINCIPAL
Passo 1: O funcionário solicita o acesso a área de cadastro de autor;
Passo 2: O sistema exibe a tela de entrada de dados;
Passo 3: O funcionário entra com os dados do autor: código*, nome*, qualificação (se
houver), ano de nascimento e de morte;
Passo 4: O sistema valida os dados do autor;
Passo 5: O sistema grava os dados do autor no banco de dados;
Passo 6: O sistema envia mensagem: “Operação realizada com sucesso”.
Fluxo alternativo
No passo 5, o sistema verifica que dados obrigatórios não foram preenchidos. O
sistema envia mensagem: “Campos obrigatórios não foram preenchidos”. O sistema retorna
ao passo 5.
No passo 6, o sistema não consegue se conectar ao banco de dados. O sistema exibe
mensagem: “Falha na conexão”. O sistema aborta a operação. O sistema retorna ao passo 1.
CASO DE USO 7: TRATAR ASSUNTO
Resumo: Este caso de uso inicia-se quando o funcionário deseja incluir, alterar ou excluir um
assunto.
Ator: Funcionário.
Pré-condição: O funcionário deve estar logado.
CENÁRIO 1: INCLUIR ASSUNTO
47
FLUXO PRINCIPAL
Passo 1: O funcionário solicita o acesso a área de cadastro de assunto;
Passo 2: O sistema exibe a tela de entrada de dados, onde alguns campos são
considerados obrigatórios: Código*, descrição*;
Passo 3: O funcionário entra com os dados do assunto;
Passo 4: O sistema valida os dados do assunto;
Passo 5: O sistema grava os dados do assunto no banco de dados;
Passo 6: O sistema envia mensagem: “Operação realizada com sucesso”.
Fluxo alternativo
No passo 5, o sistema verifica que dados obrigatórios não foram preenchidos. O
sistema envia mensagem: “Campos obrigatórios não foram preenchidos”. O sistema retorna
ao passo 5.
No passo 6, o sistema não consegue se conectar ao banco de dados. O sistema exibe
mensagem: “Falha na conexão”. O sistema aborta a operação. O sistema retorna ao passo 1.
CASO DE USO 8: REALIZAR CONSULTA
Resumo: Esse caso de uso inicia-se quando o usuário acessa o site para procurar uma
publicação (livro, periódico ou tese).
Atores: Funcionário e usuário.
Pré-condição: O usuário deverá estar on-line.
CENÁRIO 1: REALIZAR CONSULTA GERAL DE LIVROS E TESE S
48
FLUXO PRINCIPAL
Passo 1: O usuário acessa o site através da URL;
Passo 2: O usuário seleciona a opção consulta;
Passo 3: O sistema exibe o formulário para o envio da consulta;
Passo 4: O usuário preenche com o campo e envia a consulta;
Passo 5: O sistema localiza e exibe a quantidade e os títulos encontrados que
contenham a palavra-chave pesquisada.
FLUXO ALTERNATIVO
No passo 1, a URL pesquisada não está disponível.
No passo 4, o sistema verifica que o campo não está preenchido e solicita o
preenchimento. O sistema retorna ao passo 3.
No passo 5, o sistema não localiza a palavra-chave pesquisada e emite a mensagem:
“Não foram encontrados publicações para <palavra-chave>!”.
O sistema retorna ao passo 3.
CASO DE USO 9: CONSULTAR INSTITUIÇÃO
Resumo: Esse caso de uso inicia-se quando o usuário acessa o site para procurar as
instituições da região que disponibilizam acesso ao acervo;
Ator: U suário
Pré-condição: O usuário deve estar on-line.
FLUXO PRINCIPAL
49
Passo 1: O usuário acessa o site através da URL;
Passo 2: O usuário seleciona a opção consultar instituição;
Passo 3: O sistema exibe o formulário para o envio da consulta. O usuário pode
pesquisar pelo nome da instituição ou pela localidade;
Passo 4: O usuário preenche o campo, seleciona “nome ou localidade” e envia a
consulta;
Passo 5: O sistema localiza e exibe a quantidade e o resultado encontrado que
contenham a palavra-chave pesquisada.
FLUXO ALTERNATIVO
No passo 1, a URL pesquisada não está disponível.
No passo 4, o sistema verifica que o campo não está preenchido e solicita o
preenchimento. O sistema retorna ao passo 3.
No passo 4, se o usuário não indicar a direção da pesquisa, o sistema pesquisará tanto
o nome quanto à localidade.
No passo 5, o sistema não localiza a palavra-chave pesquisada e emite a mensagem: “Não
foram encontrados publicações para <palavra-chave>!”. O sistema retorna ao passo 3.
3.6 Diagrama de casos de uso
Os diagramas de casos de uso têm como objetivo auxiliar a comunicação entre os
analistas e o cliente. Um diagrama de Caso de uso descreve um cenário que mostra as
funcionalidades do sistema do ponto de vista do usuário. (SAMPAIO, Marcus Costa, sd)
A figura 5 representa através de um diagrama de casos de uso, as ações que podem
existir entre os usuários (que são tratados como atores pela UML) do sistema a ser
implantado.
50
Figura 5 - Diagrama de caso de uso
3.7 Diagrama de Classes O diagrama de classes tem como objetivo descrever os vários tipos de objetos que o
sistema pretende implementar e as relações entre eles. A figura 6 representa as classes de
objetos e relações entre elas através de um diagrama de classes.
51
Figura 6 – Diagrama de Classes
52
3.8 Diagramas de seqüência
As ilustrações abaixo representam os diagramas de seqüência para os casos de uso
efetuar login e para o caso de uso cadastrar publicação.
Figura 7 – Diagrama de seqüência efetuar login
Figura 8 – Diagrama de seqüência cadastro de publicação
53
3.9 Diagramas de atividades
As figuras 9 e 10 apresenta os diagramas de atividade para o caso de uso efetuar login
e para caso de uso cadastrar prublicação.
Figura 9 – Diagrama de atividade efetuar login
54
Figura 10 – Diagrama de atividade cadastrar publicação
3.10 Modelagem Entidade Relacionamento
Apesar de apresentarmos até aqui um estudo baseado em programação orientada a
objetos, achamos interessante apresentar a modelagem do banco de dados do sistema
construído com o software dbDesigner. O dbDesigner oferece uma interface amigável que
possibilita de forma visual a modelagem, a criação do projeto e a manutenção de base de
dados num único ambiente. A figura 7 representa o modelo do banco de dados do projeto
proposto.
55
Figura 11 – MER Modelo Entidade Relacionamento
4 TECNOLOGIAS UTILIZADAS
Várias tecnologias foram empregadas no desenvolvimento deste sistema desde a análise
até a implementação da camada de negócio com o framework MIOLO. Este capítulo apresenta
um levantamento teórico das principais tecnologias utilizadas, destacando suas principais
características.
4.1 Servidor Apache
Como pretendemos desenvolver uma aplicação web era necessário ter um servidor que
permitisse executar os códigos PHP, nos permitindo rodar o sistema e efetuar os testes. Nesse
momento optamos pelo Apache por ser um software livre, robusto e multiplataforma, além disso,
com uma vasta documentação distribuída pela internet, o que facilita encontrar ajuda e solução
para eventuais problemas mais rapidamente.
Apache é um servidor de domínio público desenvolvido em 1995, por programadores que
se basearam em um código já existente, o NCSA(National Center for Supercomputing
Applications), o qual foram acrescidos remendos (patches). Seu nome surgiu da similaridade
fonética com a expressão "a patchy server" (servidor remendado). O servidor Apache e multi-
plataforma (BSD, GNU/Linux , UNIX systems, Microsoft Windows e outras plataformas), que
tem como principais características: a escalabilidade, a flexibilidade e arobustez, podendo ser
configurado para diversas funções.
4.2 HTML
A linguagem HTML é uma linguagem de marcação usada principalmente para formatação
e publicação de conteúdos na Internet. Praticamente toda aplicação web faz uso das marcações
oferecidas pela linguagem HTML. No caso do framework MIOLO, as marcações HTML foram
usadas em conjuntos com outras linguagens como javascrip, PHP e CSS, para desenvolver os
57
temas e as interfaces do usuário, porém esses códigos são encapsulados pelo framework e o
desenvolvedor não precisa se preocupar com isso, bastando apenas definir previamente qual tema
pretende usar.
HTML (Hypertext Markup Language)- É uma linguagem de marcação padrão usada para
publicação de conteúdo na World Wide Web, baseada em SGML (Standard Generalized Markup
Language - Norma Padrão para Linguagem de Marcação) desenvolvida em 1992 por Tim
Berners Lee e Robert Caillau no CERN (Centro Europeu de Pesquisas de Física de Partículas).
Em 1993, foi criado a HTML+, com definições físicas da aparência, tabelas, formulários e
equações matemáticas. Em 1994, foram criados o HTML 2.0 (padrão para as características
principais) e o HTML 3.0 (uma extensão do HTML+, entendido como um rascunho de padrão).
Em 1995 e 1996, Netscape e Internet Explorer definem seus próprios padrões e surge o HTML
3.2, baseado nas implementações correntes. Entre 1997 e 1999, o HTML 4.0 é desenvolvido
separando a apresentação da estrutura com cascade style sheets (folhas de estilo em cascata), e
são feitas suaves modificações dessa versão nascendo então o HTML 4.01. E finalmente no ano
de 2000, o XHTML 1.0 é criado a partir de reformulações do HTML 4.01, agora compatíveis
com a especificação XML.
O HTML estrutura e estiliza informações, definindo blocos de texto como parágrafos,
cabeçalhos, listas, textos em negrito, sublinhado. Por ser escrito em texto ASCII (American
Standard Code for Information Interchange - Código Padrão Norte-americano para Intercâmbio
de Informações), pode ser desenvolvido e processado por uma variedade de ferramentas: desde
editores simples de texto a sofisticados editores visuais, baseados no conceito WYSIWYG2
(What You See Is What You Get - O que você vê é o que você tem). Os programas utilizados para
processar e exibir a página ao leitor são chamados de navegadores ou browsers.
4.3 CSS
CSS (Cascading Style Sheet - Folha de Estilo em Cascata) – é uma linguagem usada para
construção da camada de apresentação do site. Nessa camada de apresentação são feitos os
aspectos visuais do site, que não podem ser considerados como informação textual. CSS é usada
para adicionar estilos aos documentos Web. Uma grande vantagem no uso de CSS é a liberdade
58
que se tem ao planejar o layout das páginas independente de outras áreas de desenvolvimento.
Outra grande vantagem em se utilizar CSS para construção de layout, ao invés de tags HTML
visuais, é a facilidade em alterar o visual das páginas.
Outras vantagens relacionadas ao uso do CSS são: o favorecimento da acessibilidade, por
separar a estrutura dos documentos da sua apresentação, a fato de permitir um controle preciso de
espaçamento, alinhamento, posicionamento, de adicionar uma estilização final ao documento
HTML independente de tags com funções visuais, estar de acordo com as recomendações da
W3C, onde devemos usar cada tag de acordo com o propósito que foi definido a ela nas regras de
linguagem, o aumento da portabilidade dos documentos Web, a facilidade na manutenção e
reestruturação visual das páginas Web, a redução do tempo de carga dos documentos Web e o
controle sobre a apresentação do site a partir de um arquivo central.
4.4 Javascript Javascript é uma linguagem de programação criada pela Netscape em 1995, que a
princípio se chamava LiveScript, e era utilizada para criar programas encarregados de realizar
ações dentro do âmbito de uma página web. Javascript é uma linguagem com muitas
possibilidades que permite a programação de pequenos scripts, mas também de programas
maiores, orientados a objetos, com funções, estruturas complexas, etc.
No Miolo tanto o javascript quanto o CSS foram utilizados para a criação do núcleo do
framework e fornecimento de opções para os desenvolvedores, sem que esses tenham que se
preocupar como foram feitos esses scripts, preocupando-se apenas com a parte de negócio da
aplicação.
4.5 PHP
PHP ("PHP: Hypertext Preprocessor") é uma linguagem de programação orientada a
objetos criada em 1994 por Rasmus Lerdorf. Sua principal função é gerar conteúdos na Internet
(World Wide Web), implementando soluções web simples, velozes e eficientes. Com o passar dos
anos foram surgindo várias versões do PHP entre elas: PHP/FI, PHP3, PHP 4, porém finalmente
59
em junho de 2004, foi lançada a quinta versão do PHP, que introduz um novo modelo de
orientação a objetos e traz soluções para falhas existentes nas versões anteriores.
As principais características dessa nova versão são: a reformulação de construtores e
adição de destrutores - onde os construtores se encarregam de resumir as ações de iniciação dos
objetos, como quando, por exemplo, instanciamos um objeto, o construtor se encarrega dar
valores aos atributos desse objeto e os destrutores realizam as tarefas que devem ser executadas
quando um objeto deixar de existir, liberando então espaços na memória, a visibilidade, ou seja, a
visibilidade de uma propriedade ou método pode ser definida através de modificadores de acesso
que são habituais da programação orientada a objetos (POO) - esses modificadores são: public,
private e protected, onde itens declarados como public, podem ser acessados pelo objeto; private,
só estão acessíveis as classes filhas (herdadas); e protected, em que há limitação de acesso apenas
para a classe que define o atributo ou método, a possibilidade de uso de interfaces, onde as
interfaces são usadas na POO para definir um conjunto de métodos que implementam uma classe
(uma classe pode implementar diversas interfaces), os métodos e classes finais, em que o método
final não pode ser sobrescrito em uma nova classe que o herde, e classe final que impede que ela
seja herdada por outra classe e o operador instanceof, usado para saber se um objeto é instância
de alguma classe.
O GTK (GIMP toolkit9) é um conjunto de bibliotecas/ ferramentas desenvolvido por Peter
Mattis, Spencer Kimball e Josh MacDonald, usado para criação de interfaces/aplicações gráficas.
O GTK +, como é chamado é um conjunto de ferramentas composto por várias partes:
• glib(G library) - Composto por algumas rotinas de programação C, define os dados que
serão usados nas camadas superiores;
• gtk (Gimp Toolkit) - Contém a biblioteca de componentes, que é uma série de controles
como caixas de edição, listas, botões, entre outros, organizados em uma estrutura
orientada a objetos;
• gdk (GTK Drawing Kit) - Encapsula o Sistema de Janelas (X ou Windows) sob o Gtk.
Contém as rotinas para desenho da interface e para reagir a eventos do mouse ou do teclado;
9 Toolkit é um conjunto de elementos básicos para construção de software. Normalmente são implementados como uma biblioteca de rotinas ou uma plataforma para aplicativos.
60
• pango - Responsável por layout e renderização de texto internacionalizado. Forma o
núcleo de manipulação de textos e fontes no Gtk2. Utiliza o padrão Unicode e suporta a
maioria dos idiomas.
O PHP-GTK é uma “language binding”, criada em março de 2001, pelo usbequistanês
Andrei Zmievski. Essa linguagem recebe esse nome por se tratar de uma extensão da linguagem
PHP, que implementa o “binding” da linguagem GTK, ou seja, é um PHP com mais recursos. O
PHP-GTK é a primeira extensão da linguagem PHP que permite escrever aplicações client-side
com GUI (Graphical User Interface). Essa linguagem é totalmente orientada a objetos, e
simplifica o desenvolvimento de aplicações desktop multiplataformas.
4.6 Banco de dados Postgres
Uma das principais decisões que tivemos foi em relação ao banco de dados a ser utilizado,
apesar de miolo oferecer suporte a diversos bancos de dados. Nossa opção pelo Postgres se
justifica pela robustez, facilidade de uso, por ser open source e principalmente pela vasta
documentação disponível, além do mais, este é o banco de dados usado pela equipe do projeto
SIGA do CEFET Campos que vem trabalhando com o MIOLO.
O PostgreSQL é um sistema de banco de dados objeto-relacional, orientado a objetos,
desenvolvido pelo programador Michael Stonebraker no ano de 1986, na Universidade de
Berkeley, na Califórnia.Michael, que se baseou em outro projeto já existente conhecido como
Ingres. Suas características são comuns a de outros bancos de dados da grande porte, porém
pode-se destacar a versatilidade, segurança e a gratuidade.
Suas principais funcionalidades são: a compatibilidade multi-plataforma, ou seja, executa
em vários sistemas operacionais, como Windows, Mac OS X, Linux e outras variantes de Unix, a
compatibilidade com várias linguagens, entre elas, Java, PHP, Python, Ruby,e C/C++ , a Base de
dados de tamanho ilimitado, as tabelas com tamanho de até 32 TB, a quantidade de linhas de até
1.6 TB ilimitada, os campos de até 1 GB, o suporte a recursos como triggers, views, stored
procedures, SSL, MVCC, schemas,transactions, savepoints, referential integrity e expressões
regulares e as instruções em SQL.
61
4.7 MIOLO
O Framework MIOLO disponibiliza toda a infra-estrutura necessária para o
desenvolvimento de aplicações baseadas na web, permitindo que o desenvolvedor se preocupe
apenas com o domínio da aplicação e não com os detalhes de implementação. No MIOLO os
sistemas são construídos através do desenvolvimento de módulos. O conjunto de módulos
formam a aplicação. No capítulo 2 pode ser encontrado mais informações sobre o framework
MIOLO.
5 DESENVOLVIMENTO E APRESENTACAO DO PROTÓTIPO
O desenvolvimento de aplicações com o MIOLO possui as seguintes etapas:
• Modelagem das classes e do banco de dados:
Este processo é comum a qualquer aplicação, independente de qual framework ou até
mesmo linguagem a ser utilizada;
• Criação da estrutura do módulo, com seus subdiretórios:
No MIOLO, um módulo é um componente de uma aplicação. De forma geral, um
módulo reflete um sub-domínio da aplicação, agregando as classes de negócio que
estão fortemente relacionada e provendo o fluxo de execução (handlers) e a interface
com o usuário (form, grids, report) para se trabahar com tais clases. (MIOLO 2
UserGuide, 2008);
• Definição do tema a ser utilizado (um já existente, ou a criação de um novo tema);
• Criação de controles específicos para o módulo, caso seja necessário;
• Criação do arquivo de configuração do módulo em <miolo>/modules/
<modulo>/etc/module.conf;
• Criação da classe handler em <miolo>/modules/<modulo>/handler/ handler.class;
• Criação do handler principal em <miolo>/modules/<modulo>/handler/ main.inc;
• Criação das classes de negócio em <miolo>/modules/<modulo>/classes – caso
existam;
• Criação dos formulários em <miolo>/modules/<modulo>/forms – caso existam;
5.1 Gerador de código para MIOLO
O MIOLO oferece uma estrutura grande, permitindo que aplicações complexas
possam ser geradas. Apesar disto, para se trabalhar com MIOLO, muito trabalho deve ser
feito manualmente pelo desenvolvedor, como a criação de toda a estrutura de diretórios, a
criação do banco de dados com suas tabelas e relacionamentos e etc. Ou seja, cada classe de
negócio, de handler, formulário, mapeamento xml, links, grids e para exibição de consultas
que devem ser criadas manualmente. Para acelerar e facilitar ainda mais o desenvolvimento
63
com MIOLO, a equipe de desenvolvimento do framework já trabalha na elaboração de uma
interface de desenvolvimento chamada MioloIde. Até este momento não encontramos muitas
informações sobre o MioloIde disponíveis. Porém o grupo de trabalho do SIGA-CEFET vem
utilizando um gerador de códigos desenvolvido por um membro da própria equipe e que será
utilizado para gerar os códigos da aplicação proposta.
O Gerador de Código para o Framework MIOLO2 é o resultado de um projeto
desenvolvido pelos alunos do CEFET Campos, Flávio Tavares Caetano Lima e Ítalo dos
Santos Ferreira, como projeto de conclusão de curso, sobre a orientação do Professor Dr.
Marcelo Feres.
Esta ferramenta visa acelerar o processo de desenvolvimento de software que utilize o
Framework MIOLO2. Ela utiliza tecnologia java, portanto, é multiplataforma. O gerador de
códigos possibilita gerar códigos baseados nas classes de negócios e seus atributos, gerando
também toda a estrutura de pastas, armazenando todos os arquivos gerados no local correto,
seguindo o padrão de instanciação do MIOLO 2.
Segundo LIMA e FERREIRA:
O gerador de código agiliza muito o processo de desenvolvimento, visto que trabalhando com um Framework a programação passa a depender bastante da configuração de vários arquivos, que feitos de forma automática e correta, impede o programador experiente de cometer possíveis erros configurando tais arquivos ‘à mão’ e acelerar o aprendizado de programadores inexperientes, pois estes não se deteriam na fase incômoda de configuração do projeto, habilitando-se diretamente para uma fase mais avançada do projeto.
5.2 Apresentação do protótipo
O módulo gerado será chamado de Guia. A partir do código gerado, o passo seguinte
foi adicionar o módulo Guia no MIOLO, fazendo configurações de alguns arquivos como:
adicionar a raiz do módulo criado no diretório miolo/modules do MIOLO, com isso a
estrutura de diretórios do MIOLO ficará conforme mostrado na figura 12.
64
Figura 12 – Diretório e subdiretório do módulo Guia
Após a inserção do novo diretório no diretório de módulos do MIOLO devemos
configurar o arquivo miolo.conf, que é um arquivo xml, adicionando o caminho do banco de
dados do novo módulo na tag <db>. Logo abaixo podemos ver na figura 13 como fica a tag
db após adicionado os dados do novo módulo.
65
<db> <miolo> <system>sqlite</system> <host>localhost</host> <name>c:/xampp/htdocs/miolo_guia/var/db/miolo.sqlite</name> <user>miolo</user> <password>miolo</password> </miolo> <common> <system>postgres</system> <host>localhost</host> <name>siga</name> <user>siga</user> <password>senha</password> </common> <bguia> <system>postgres</system> <host>localhost</host> <name>guia</name> <user> guia </user> <password>senha</password> </bguia> <admin> <system>sqlite</system> <host>localhost</host> <name>c:/xampp/htdocs/miolo_guia/modules/admin/sql/admin.sqlite</name> <user>miolo</user> <password>miolo</password> </admin> </db>
Figura 13 – Trecho do arquivo miolo.comf Em seguida é necessário alterar o código do MIOLO para adicionar os links para fazer
com que o módulo Guia seja acessado pelo MIOLO. Para isso deve ser adicionados uma
chamada no arquivo responsável pelo Menu principal do módulo MIOLO ou adicionado um
ícone com um link no container do módulo principal do MIOLO ou as duas opções. Para
realizar essas tarefas basta alterar o código do main_menu.inc e do arquivo main.inc que fica
no módulo commom e as alterações serão automaticamente acrescentadas no container do
form proncipal.
A partir deste momento e com os links para colocar o novo módulo em execução, o
programador deve fazer os ajustes necessários para fazer o módulo rodar da maneira correta,
pois o gerador cria a estrutura para o módulo de MIOLO, mas não garante que este irá rodar
perfeitamente, uma vez que depende da forma como foi preenchido os dados no próprio
66
Gerador. Estando o módulo rodando de forma básica, o programador começa a se preocupar
unicamente com as regras do negócio.
A seguir as principais telas do sistema descrevendo suas funcionalidades.
Figura 14 – Tela de login
A figura 14 apresenta a tela de login que será sempre apresentado caso os usuários do
sistema tentem fazer acesso à área restrita do mesmo. Ao acessar na área restrita, o usuário
terá acesso ao módulo de manutenção do sistema e poderá efetuar cadastros, exclusão e
edição dos dados nas diversas tabelas do sistema. A princípio, o sistema está programado para
dois tipos de usuários: os internautas que poderão apenas realizar consultas, e para isso, não
precisarão estar cadastrados e o administrador do módulo Guia.
Após efetuado o login no sistema, o usuário poderá navegar pelos módulos existentes
no MIOLO de acordo com o nível de acesso que lhe foi concedido. O usuário do módulo Guia
terá acesso à tela mostrada na figura 15. A partir desta tela o administrador do módulo pode
acessar as telas de cadastro de publicações, instituições e das tabelas auxiliares.
67
Figura 15 – Tela de manutenção de dados do módulo Guia.
As telas de cadastro do módulo Guia seguem um padrão definido pelo tema escolhido.
Por esse motivo, apresentaremos aqui a tela de cadastro de publicações monográficas que
engloba livros, dicionários, enciclopédias e trabalhos monográficos de conclusão de cursos
nos diversos níveis.
Todo cadastro criado do sistema exibe uma tela de pesquisa que serve para que o
usuário pesquise antes se o objeto a ser cadastrado para verificar se o mesmo já existe
cadastrado evitando assim a tentativa de duplicar um objeto. Mesmo assim a tela traz um
botão de inserir para que o usuário possa abrir a tela de entrada de dados.
Caso o usuário queira editar um objeto cadastrado o processo é semelhante. Basta
acessar no módulo que ele deseja e através da pesquisa localizar o objeto que será alterado e
clicar em exibir dados. Então o sistema exibirá o formulário preenchido com os dados do
objeto selecionado.
A seguir os passos para realizar o cadastro de um livro. Primeiramente deve-se
cadastrar o idioma, a editora, os autores e os assuntos do livro.
Para cadastrar o idioma do livro, a editora que publicou o livro, os assuntos que o livro
trata é necessário acessar as tabelas auxiliares (Figura 16).
68
Figura 16 – Tabelas auxiliares
As tabelas auxiliares (Figura 16) foram criadas para agrupar todas as tabelas que serão
usadas no cadastro de publicações.
A figura 17 mostra o cadastro de um idioma. O cadastro de idioma é composto por
campos, descrição e sigla.
Figura 17 – Tela de cadastro de idioma
69
Figura 18 mostra a tela de cadastro de editora.
Figura 18 – Tela de entrada de dados de Editora
A figura 19 mostra a tela de entrada de dados para o cadastro de autor.
Figura 19 – Tela de cadastro autor
No cadastro de autor além do nome do autor é importante cadastrar as datas de nascimento e
morte, esses dados serão usados para compor os dados do autor nos relatórios que seguiram o formato
70
padrão da ABNT. É disponibilizado também um campo para onde o usuário poderá colocar outras
informações que se fizerem necessários sobre o autor.
A figura 20 mostra a tela de entrada de dados para o cadastro de assuntos.
Figura 20 – Tela de cadastro de assuntos
O cadastro de assunto o campo classificação deve ser preenchido pelo código de
catalogação que a biblioteca utiliza para organizar o acervo. Este código poderá seguir a
Classificação Decimal de Dewey – CDD ou a Classificação Decimal Universal – CDU.
Estando o idioma, a editora e os assuntos cadastrados nas tabelas auxiliares pode-se
começar o cadastro das publicações. Para efeitos de ilustração será efetuado o cadastro de um
livro. Para abrir a tela de cadastro de livros basta acessar o ícone publicação monográfica que
aparece na figura 15. A seguir a figura 21 exibe a primeira tela para cadastro de livros.
71
Figura 21 – Tela 1 para cadastro de livros.
Na primeira tela de cadastro de livros ou outros tipos de materiais monográficos,
primeiramente deve-se selecionar o tipo de publicação a ser cadastrada. Então o sistema
exibirá a tela para a inclusão dos dados conforme a opção selecionada. Figura 22.
Figura 22 – Tela 2 de cadastro de livros
72
O MIOLO oferece uma ferramenta de busca chamada Lookup que é um mecanismo
que, associado a um campo do formulário, faz a busca no banco de dados e preenche o campo
selecionado com o valor encontrado no banco de dados. A tela do lookup pode ser visto na
figura 23 e foi utilizada para o preenchimento dos dados da editora.
Figura 23 – Tela da função Loockup
Ao clicar o botão para selecionar a editora responsável pela obra a tela do lookup
sobrepõe a tela em uso. O usuário faz a busca pelo nome da editora e caso exista no banco de
dados o nome pesquisado aparece no grid do lookup, então deve-se clicar na editora desejada
e o nome da mesma será transferida para o formulário anterior, automatizando o
preenchimento e evitando a digitação livre no campo editora.
Estando todos os dados preenchidos o próximo passo é clicar no botão “Criar”
enviando os dados para serem gravados no banco. O sistema exibe a próxima tela (figura 24)
para o preenchimento dos dados dos autores, assuntos passa para a terceira parte do cadastro.
73
Figura 24 – Tela 3 de cadastro de livros
Neste momento o usuário tem as opções de cadastrar os autores do livro, caso existam, os
assuntos e ainda visualizar os dados no formulário caso queira fazer alguma edição.
A figura 25 é exibida após o usuário escolher a opção de cadastro de autores, nesta tela
será cadastrado os autor principal e os secundários da obra, para os autores secundários deve
ser indicado o tipo de responsabilidade que este tem com o livro que está sendo incluído. Por
exemplo, um autor poder ser classificado como organizador, editor técnico, tradutor e etc.
Figura 25 – Tela de cadastro de autores numa publicação
Neste momento a publicação 13 está selecionada, como pode ser visto na figura acima,
portanto basta selecionar o nome do autor em “autores disponíveis” e clicar no botão “incluir
74
na pubmonografica” que os dados do autor serão automaticamente transferidos para a
publicação selecionada. Os autores selecionados serão relacionados no grid da figura 26. Para
excluir um autor do cadastro da publicação basta selecioná-lo na grid e clicar em “excluir”.
O cadastro de assuntos procede da mesma forma do cadastro de autores. A figura 22
mostra a tela de cadastro de autores.
Figura 26 – Inclusão de assunto na publicação
A figura 27 mostra a tela de cadastro das instituições. O cadastro das o campo
composição do acervo é um campo longo para que o usuário possa descrever os detalhes do
acervo da biblioteca.
75
Figura 27 - Tela de entrada de dados para Instituição
6 CONCLUSÃO
Este trabalho apresentou as etapas de construção, com a utilização de um framework
novo no mercado, de um sistema de pesquisa de bibliografias sobre um tema específico, que é
publicações, onde o tema central é a história da cidade de Campos dos Goytacazes.
Pode-se afirmar que o objetivo do trabalho foi atingido gerando um site de busca para
auxiliar a pesquisa dos estudantes e um módulo de cadastro que possibilita a catalogação das
obras coletadas nas instituições da cidade.
A utilização de um framework foi essencial para a realização deste trabalho e a
escolha do MIOLO, se deve dentre tantas coisas, como já citado no capítulo dedicado
especialmente ao framework, ao fato de ser uma ferramenta estável, totalmente nacional e
que está sendo utilizada nas pesquisas do projeto SIGA, com núcleo no CEFET-Campos, que
desenvolvem um sistema de gerenciamento acadêmico, onde será contemplado pelo Siga um
módulo de biblioteca. Portanto, a experiência que obtivemos foi de grande valia.
O Framework MIOLO atendeu nossas expectativas, oferecendo uma estrutura
necessária para o desenvolvimento desta aplicação. Trazendo em seu núcleo, funcionalidades
que foram projetadas para o sistema, mesmo antes de termos o primeiro contato com o
MIOLO. Funcionalidades como gerenciamento de usuários, campos com preenchimento
selecionáveis diretamente do banco de dados, entre outros.
A internet já é uma realidade e muitas instituições já disponibilizam seu acervo na
internet, porém as obras constantes no site desenvolvido nesta monografia foram avaliadas e
são consideradas obras de relevância.
O site desenvolvido será de extrema utilidade aos pesquisadores, reunindo num só
lugar informações sobre as obras mais importantes da cidade, possibilitando aos usuários
obter informações sobre as mesmas. Com isso os usuários poderão saber, antecipadamente,
quais instituições da cidade dispõem em seus acervos as obras de seu interesse e quais os
procedimentos ele deverá seguir para ter acesso a essas obras, mesmo que esta instituição não
tenha um sistema de pesquisa on-line. Isto porque a primeira etapa desta monografia foi o
levantamento destas informações. Em suma, os estudantes ganharão tempo, visitando apenas
as instituições que têm em seu acervo as obras que são seus alvos de pesquisa.
77
6.1. TRABALHOS FUTUROS
O projeto apresentado é uma das funcionalidades de um sistema de biblioteca. Com
isso, poderão ser acrescentadas novas funcionalidades como: controle de empréstimos,
cadastro de usuários, controles de reservas e etc, ou seja, este sistema poderá ser utilizado
para a construção de um sistema completo de gerenciamento de biblioteca.
Ainda neste sistema de consulta deverá ser melhorada a rotina de controle de
periódicos, que possui muitas particularidades. É importante também criar rotinas de
estatísticas e relatório de uso como: publicações mais acessadas, número de acesso e etc.
Digitalização e disponibilização do conteúdo de obras que já sejam de domínio
público.
Como é um sistema criado para servir de consulta on-line, será necessário pesquisar
novos temas para tornar a interface com o usuário mais amigável, principalmente a tela
inicial, onde não é necessário que o usuário esteja logado para efetuar consultas e gerar listas
para impressão.
REFERÊNCIAS
ALMEIDA, Rubens Queirós de. Semana Solis - MIOLO. Disponível em: <http://www.dicas-l.com.br/dicas-l/20040831.php>. Acesso em: 12 jul. 2008. AMARAL, Luis Gustavo. CSS: Cascading Style Sheets. São Paulo: Novatec, 2006. 126 p. (Guia de consulta rápida). BROD, Cesar; GÄRTNER, Vilson Cristiano. MIOLO: Framework para desenvolvimento de aplicações complexas em Software Livre. Disponível em: <http://augustocampos.net/revista-do-linux/035/software.html>. Acesso em: 14 maio 2008. DAMIAN, Edgard B.. Javascript. São Paulo: Novatec, 2006. 151 p. (Guia de consulta rápida). EQUIPE GNUTECA. Gnuteca: sistema de gestão de acervo, empréstimo e colaboração para bibliotecas. Disponível em: <http://gnuteca.solis.coop.br/>. Acesso em: 15 jul. 2008. ESPAKE, Patrick. Introdução ao Symfony. Disponível em: <http://www.codigofonte.com.br/artigo/php/introducao-ao-symfony>. Acesso em: 26 jun. 2008. FARIA, Túlio. CakePHP: desenvolvimento web ágil com php. Disponível em: <http://www.tuliofaria.net/arquivos/CakePHP-Conisli2007.pdf>. Acesso em: 20 abr. 2008. FOWLER, Martin. UML essencial. Porto Alegre: Bookman, 2004. GARTNER, Vilson C.. Miolo PHP Framework: O que é MIOLO?. Disponível em: <http://www.codeplex.com/miolo>. Acesso em: 15 jul. 2008. LARMAN, Craig. Utilizando UML e padrões: uma introdução a análise e ao projeto orientados a objetos. Porto Alegre: Bookman, 2004. LIMA, Flávio Tavares Caetano. Implementação de um gerador de código para o Framework MIOLO. 2007. 127 f. Monografia (Graduação) - Curso de Análise e Desenvolvimento de Software, Cefetcampos, Campos dos Goytacazes, RJ, 2007. MANUAL CakePHP Disponível em: <http://www.manual.cakephp.com.br/doku.php>. Acesso em: 20 jun. 2008. MARTINS, James. Análise e projeto orientado a objeto. São Paulo: Mackron Books, 1995.
79
MINETTO, Elton Luís. Frameworks para desenvolvimento em PHP. São Paulo: Novatec, 2007. Disponível em: <http://www.novateceditora.com.br/livros/Frameworks/capitulo9788575221242.pdf>. Acesso em: 04 jun. 2008. MINETTO, Elton Luis; MASETO, Jhony Maiki. Análise avaliativa entre Frameworks PHP. Php Magazine, [s.l.], n. 2, p.9-15, mar. 2007. Mensal. Disponível em: <www.phpmagazine.com.br>. Acesso em: 12 mar. 2008. MIOLO: Framework para Desenvolvimento de Sistemas em PHP com POO . Site Oficial. Disponível em: <www.miolo.org.br>. Acesso em: 01 jul. 2008. NIEDERAUER, Jiliano. Desenvolvendo websites com PHP. São Paulo: Novatec, 2004. PHILIPPE, Jacques. O que é um Framework? Disponível em: <http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/frame/oque.htm>. Acesso em: 24 mar. 2008. PHILIPPE, Jacques. Vantagens e desvantagens do uso de Frameworks. Disponível em: <http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/frame/porque.htm>. Acesso em: 24 mar. 2008. SYMFONY-PROJECT Framework de PHP 5 Disponível em: <http://www.symfony-project.com>. Acesso em: 02 maio 2008. UTILIZANDO o Framework MIOLO para desenvolvimento de aplicações web Disponível em: <http://www.cefetcampos.br/servicos/eventos/v-circuito-de-tecnologia-da-informacao-edicao-2008/Utilizando%20o%20Framework%20Miolo-PHP%20para%20Desenvolvimento%20de%20Aplicacoes%20Web.pdf>. Acesso em: 04 jun. 2008. WIKIPÉDIA (Comp.). Framework. Disponível em: <http://pt.wikipedia.org/wiki/Framework>. Acesso em: 04 jun. 2008. WIKPÉDIA: a enciclopédia livre. Disponível em: <http://pt.wikipedia.org/wiki/Framework>. Acesso em: 02 maio 2008.
APÊNDICES
81
APÊNDICE A: Formulário de coleta de dados para publicação monográfica
82
Figura 27 – Modelo de formulário de coleta de dados bibliográfico de livros
Top Related