CURSO SUPERIOR DE TECNOLOGIA EM …bd.centro.iff.edu.br/bitstream/123456789/268/3/Documento.pdf ·...

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




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)




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


.................................................................................................................................

Profº. José Elias da Silva Justo

Pós-graduado em Administração em Redes Linux - UFLA


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”.


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.


CENÁRIO 2: ATUALIZAR PUBLICAÇÃO

FLUXO PRINCIPAL


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;


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”.


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 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;


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.


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;


FLUXO ALTERNATIVO


sistema envia mensagem: “Campos obrigatórios não foram preenchidos”. O sistema retorna

ao passo 5.



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;


Fluxo alternativo



ao passo 5.



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;


Fluxo alternativo



ao passo 5.



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>!”.


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

CURSO SUPERIOR DE TECNOLOGIA EM …bd.centro.iff.edu.br/bitstream/123456789/268/3/Documento.pdf ·...

Documents

Transcript of CURSO SUPERIOR DE TECNOLOGIA EM …bd.centro.iff.edu.br/bitstream/123456789/268/3/Documento.pdf ·...