Embed Size (px)
Citation preview
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ CURSO SUPERIOR DE TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE
SISTEMAS
ANA PAULA APARECIDA SCHAITLER
COMPLEMENTOS EM UM SISTEMA WEB DE GESTÃO DE TRABALHOS DE CONCLUSÃO DE CURSO E ESTÁGIO CURRICULAR
TRABALHO DE CONCLUSÃO DE CURSO
PATO BRANCO 2018
2
ANA PAULA APARECIDA SCHAITLER
COMPLEMENTOS EM UM SISTEMA WEB DE GESTÃO DE TRABALHOS DE CONCLUSÃO DE CURSO E ESTÁGIO CURRICULAR
Trabalho de Conclusão de Curso de graduação, apresentado à disciplina de Trabalho de Conclusão de Curso, do Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas, da Universidade Tecnológica Federal do Paraná, Câmpus Pato Branco, como requisito parcial para obtenção do título de Tecnólogo. Orientador: Prof. João Guilherme Brasil Pichetti
PATO BRANCO 2018
3
4
RESUMO
SCHAITLER, Ana Paula Aparecida. Complementos em um sistema web de gestão de trabalhos de conclusão de curso e estágio curricular. 2018. 67f. Monografia (Trabalho de Conclusão de Curso) - Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas, Universidade Tecnológica Federal do Paraná, Câmpus Pato Branco. Pato Branco, 2018. Nas Universidades, sejam públicas ou privadas, é comum que os acadêmicos realizem trabalhos de conclusão de curso, estágios supervisionados ou monografias que são avaliadas por bancas compostas por professores que determinam uma nota para o projeto avaliado. É ainda, relativamente comum, que o registro das notas seja realizado com o auxílio de fichas manuais, cujas notas são informadas pelos avaliadores, tornando o processo sujeito a falhas e pouco prático em termos de gerenciamento. Visando prover uma solução para facilitar e auxiliar o processo de trabalhos acadêmicos apresentados perante bancas avaliadores, foi desenvolvida uma primeira versão de um sistema pelo egresso João Guilherme Brasil Pichetti do curso de Tecnologia em Análise e Desenvolvimento de Sistemas, Universidade Tecnológica Federal do Paraná, Câmpus Pato Branco. Como resultado deste trabalho foram realizadas modificações e complementos no sistema já desenvolvido visando atender as funcionalidades necessárias pelos responsáveis das atividades, seja TCC ou estágio supervisionado. Palavras-chave: RIA. Aplicação web. Desenvolvimento Java. Estágio supervisionado. Trabalho de conclusão de curso.
5
ABSTRACT
SCHAITLER, Ana Paula Aparecida. Complements in a web system for the management of course conclusion work and supervised internships. 2018. 67f. Monografia (Trabalho de Conclusão de Curso) - Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas, Universidade Tecnológica Federal do Paraná, Câmpus Pato Branco. Pato Branco, 2018. In Universities, public or private, it is common for academics to carry out studies of course completion and reports of supervised internships that are evaluated by teachers and professionals and its determines a grade for the project evaluated. It is also common that the notes are recorded in forms, making the process subject to failure and difficulty to manage. Aiming to provide a solution to help the process to evaluate academic presentations, a first version of the system was developed by João Guilherme Brasil Pichetti when student of the course in Technology in Analysis and Development of Systems of Federal University of Technology – Paraná, Campus Pato Branco. As a result of this work the system was adjusted and complemented aiming to meet the functionalities required by the responsible for the activities to evaluate academic works, such as supervised internships and course conclusion works. Keywords: RIA. Web application. Java language. Supervised internship. Course conclusion work.
6
LISTA DE FIGURAS
Figura 1 - Modelo conceitual de Domínio do sistema........................................................... 22
Figura 2 - Diagrama de Caso de uso..................................................................................... 24
Figura 3 - Diagrama de Classe da análise do projeto ............................................................ 29
Figura 4 - Diagrama de Entidade e Relacionamento ............................................................. 29
Figura 5 - Tela de Login....................................................................................................... 30
Figura 6 - Tela para Cadastro de Usuário Aluno................................................................... 30
Figura 7 - Campos Obrigatórios no cadastro......................................................................... 31
Figura 8 - Tela Inicial .......................................................................................................... 31
Figura 9 - Cadastro de Curso................................................................................................ 32
Figura 10 - Cadastro de Tipo de Projeto ............................................................................... 32
Figura 11 - Lista de Cargos .................................................................................................. 33
Figura 12 - Cadastro de Cargos ............................................................................................ 33
Figura 13 - Erro ao inserir cargo sem informação de nome................................................... 33
Figura 14 - Confirmação ao salvar cargo.............................................................................. 34
Figura 15 - Lista de Projetos ................................................................................................ 34
Figura 16 - Cadastro de Projeto............................................................................................ 35
Figura 17 - Cadastro de Projeto - Tipo de Projeto é Estágio.................................................. 35
Figura 18 - Cadastro de Projeto - Tipo de Projeto não é Estágio ........................................... 36
Figura 19 - Cadastro de Estágio - Parte 1 ............................................................................. 36
Figura 20 - Cadastro de Estágio - Parte 2 ............................................................................. 37
Figura 21 - Cadastro de Horários – Estágio .......................................................................... 37
Figura 22 - Visualizar dados da Postagem............................................................................ 38
Figura 23 - Plano de Estágio ................................................................................................ 39
Figura 24 - Ata de Estágios .................................................................................................. 40
Figura 25 - Ata Trabalhos de Conclusão de Curso................................................................ 41
Figura 26 - Lista de Item de Avaliação................................................................................. 42
Figura 27 - Cadastro de Item de Avaliação........................................................................... 42
Figura 28 - Cadastro de Avaliação por Item ......................................................................... 43
Figura 29 - Cadastro de Avaliação por Nota Geral ............................................................... 43
Figura 30 - Menu Lateral ..................................................................................................... 44
Figura 31 - Filtros para relatório das Bancas Apresentadas................................................... 44
Figura 32 - Relatório de bancas apresentadas ....................................................................... 45
Figura 33 - Filtro para gerar Declaração............................................................................... 45
Figura 34 - Declaração de Participação de Bancas................................................................ 46
7
LISTA DE QUADROS
Quadro 1 - Lista de ferramentas e tecnologias utilizadas ...................................................... 18 Quadro 2 - Requisitos Funcionais......................................................................................... 23 Quadro 3 - Expansão caso de uso: Manter Cargos ................................................................ 25 Quadro 4 - Expansão de caso de uso: Gerar Declaração de Participação em Bancas ............. 25 Quadro 5 - Expansão de Caso de Uso: Lançar Nota Geral .................................................... 26 Quadro 6 - Expansão de Caso de Uso: Manter Aluno ........................................................... 26 Quadro 7 - Expansão de Caso de Uso: Manter Plano de Estágio........................................... 27 Quadro 8 - Expansão de Caso de Uso: Gerar Relatório......................................................... 27 Quadro 9 - Expansão de Caso de Uso: Visualizar Agenda de Avaliações ............................. 28
8
LISTAGEM DE CÓDIGO
Listagem 1 - pom.xml .......................................................................................................... 49
Listagem 2 - cadastrar.xhtml ................................................................................................ 50
Listagem 3 - CadastrarController.java .................................................................................. 52
Listagem 4 - projeto.xhtml ................................................................................................... 57
Listagem 5 - projeto.xhtml ................................................................................................... 59
Listagem 6 - ProjetoController.java...................................................................................... 60
Listagem 7 - ProjetoController.java...................................................................................... 61
Listagem 8 - avaliacao.xhtml ............................................................................................... 63
Listagem 9 – AvaliacaoController........................................................................................ 64
9
LISTA DE SIGLAS E ACRONIMOS
CSS Cascading Style Sheets
DAINF Departamento Acadêmico de Informática
HTML HypeText Markup Language
HTTP HyperText Transfer Protocol
JSF Java Server Faces
MVC Model-View-Controller
PDF Portable Document Format
POM Project Object Model
RIA Rich Internet Application
SI Sistemas de Informação
TCC Trabalho de Conclusão de Curso
TCP/IP Transmission Control Protocol/Internet Protocol
URL Uniform Resource Locator
UTFPR Universidade Tecnológica Federal do Paraná
XHTML eXtensible Hypertext Markup Language
XML eXtensible Markup Language
1
SUMÁRIO
1 INTRODUÇÃO .......................................................................................................11
1.1 CONSIDERAÇÕES INICIAIS ..............................................................................11
1.2 OBJETIVOS ........................................................................................................12
1.2.1 Objetivo Geral ..................................................................................................12
1.2.2 Objetivos Específicos .......................................................................................12
1.3 JUSTIFICATIVA ..................................................................................................13
1.4 ESTRUTURA DO TRABALHO............................................................................14
2 REFERENCIAL TEÓRICO.....................................................................................15
2.1 WEB TRADICIONAL ...........................................................................................15
2.2 RICH INTERNET APPLICATION ........................................................................16
3 MATERIAIS E MÉTODO........................................................................................18
3.1 MATERIAIS .........................................................................................................18
3.2 MÉTODO.............................................................................................................19
4 RESULTADOS.......................................................................................................21
4.1 ESCOPO DO SISTEMA......................................................................................21
4.2 MODELAGEM DO SISTEMA..............................................................................22
4.3 APRESENTAÇÃO DO SISTEMA........................................................................30
4.4 IMPLEMENTAÇÃO DO SISTEMA ......................................................................46
CONCLUSÃO ...........................................................................................................65
REFERÊNCIAS.........................................................................................................67
1
1 INTRODUÇÃO
Este capítulo apresenta as considerações iniciais, os objetivos e a justificativa da
realização deste trabalho. No final do capítulo é apresentada a organização do texto por meio
de uma breve descrição dos seus capítulos subsequentes.
1.1 CONSIDERAÇÕES INICIAIS
Uma Universidade é caracterizada pela sua multiplicidade de funções relacionadas
ao ensino, à pesquisa, à extensão e à gestão interna que produzem uma grande quantidade de
dados que devem ser armazenados e disponibilizados para o desenvolvimento das atividades.
Esses dados são relacionados aos alunos, professores, projetos, processos administrativos e
acadêmicos. As informações obtidas desses dados são utilizadas para as atividades
operacionais e para a tomada de decisão.
Devido ao volume desses dados e da disponibilidade de recursos tecnológicos
existentes, o controle e o gerenciamento desses dados têm sido realizado com o auxílio de
ferramentas e tecnologias como os Sistemas de Informação (SI). Essas ferramentas são
capazes de armazenar esses dados em um banco de dados e disponibilizá-los de forma
organizada, rápida e eficiente para o usuário.
Para Maccari e Sauaia (2005), os SI devem resolver operações específicas como
auxílio na tomada de decisão, permitir o acesso às informações por meio de relatórios mais
rápidos e precisos, promover melhorias na estrutura organizacional e ganhos no desempenho
das atividades desenvolvidas pelos usuários.
Em uma Universidade podem existir SI diversos, com finalidades específicas, como,
por exemplo, sistema acadêmico que controla e gerencia as atividades de ensino, sistemas de
concessão de diárias e passagens que gerenciam as requisições realizadas pelos servidores,
sistema de gerenciamento de acervo bibliográfico, entre outros.
Com relação às atividades de ensino, os dados produzidos podem ser provenientes de
diversas atividades, como, por exemplo, dos Trabalhos de Conclusão de Curso (TCC) e de
atividades de estágio curricular obrigatório e não obrigatório. Esses dados se referem aos
projetos e relatórios desenvolvidos, alunos e professores envolvidos, banca avaliadora, defesa
e às avaliações realizadas. Além de armazenar dados, um SI pode auxiliar no controle e no
gerenciamento dessas atividades, como, gerenciar o processo de apresentação de trabalhos
1
acadêmicos perante banca, com o agendamento da banca, envio aos avaliadores e devolutiva
das monografias e dos relatórios de estágio, o registro de notas e pareceres de avaliação, entre
outros. Além disso, pode auxiliar a gestão administrativa das bancas de defesa por meio da
emissão de documentos, como atas e declarações.
Nesse contexto, este trabalho propõe a complementação de um sistema web de
gerenciamento de TCCs e de estágios da Universidade Tecnológica Federal do Paraná,
Câmpus Pato Branco. O SI a ser complementado foi desenvolvido por João Guilherme Brasil
Pichetti egresso do Departamento Acadêmico de Informática (DAINF) da Universidade
Tecnológica Federal do Paraná, Câmpus Pato Branco. O sistema atual apresenta uma versão
viável de uso, porém, é necessário que sejam implementadas outras funcionalidades para que
ele possa ser utilizado para atender todas as funcionalidades envolvidas nas bancas e
avaliações de estágio e de TCC.
1.2 OBJETIVOS
A seguir são apresentados o objetivo geral e específicos do sistema proposto neste
trabalho.
1.2.1 Objetivo Geral
Complementar um sistema web de gestão de Trabalhos de Conclusão de Curso e
Estágio Curricular.
1.2.2 Objetivos Específicos
Para alcançar o objetivo geral, serão estabelecidos os seguintes objetivos específicos:
� Registrar, gerenciar e gerar planos de estágio;
� Gerar atas com os dados de apresentações de trabalho que são realizadas perante
banca;
� Gerar declarações de defesa para a banca avaliadora;
� Proporcionar a emissão de relatórios.
1
1.3 JUSTIFICATIVA
O uso de fichas impressas, formulários em texto e de planilhas eletrônicas para
realizar a avaliação de trabalhos acadêmicos apresentados perante banca é uma forma
comumente adotada quando não há um sistema ou aplicativo para ser utilizado para esse fim.
O uso de fichas e planilhas auxilia na atribuição da nota, mas não é prático ou eficiente como
forma de controle para os professores responsáveis por atividades como estágio
supervisionado e trabalho de conclusão de curso. Outro aspecto importante dessas atividades é
o controle de envio da versão do texto para a banca e da realização das alterações sugeridas
pela banca para o aluno.
O DAINF da Universidade Tecnológica Federal do Paraná, Câmpus Pato Branco,
visando uma solução de software para auxiliar na condução do processo de avaliação desse
tipo de trabalho, planejou o desenvolvimento de um sistema web para ser utilizado pelos
alunos, membros das bancas (professores e profissionais), orientadores dos trabalhos e
professores responsáveis por essas atividades. Considerando que o sistema possui muitos
requisitos e diversas regras de negócio, uma versão parcial e viável como produto foi
implementada João Guilherme Brasil Pichetti, quando aluno do DAINF e essa versão foi, por
meio deste trabalho, complementada por meio da implementação e/ou modificações de
requisitos.
Uma nova análise foi realizada por um grupo de professores e requisitos adicionais
foram definidos para o sistema. A necessidade desses requisitos se justifica pela inclusão do
controle e preenchimento do plano de estágio obrigatório e não obrigatório, pela geração de
termos de apresentação (defesa) e declaração aos participantes das bancas, entre outros.
Algumas regras de negócio foram redefinidas e complementadas, como, a de não haver
necessidade de validação do cadastro de um usuário com perfil de aluno. Isso porque o aluno
pode apenas realizar postagens e ele tem acesso somente às postagens (texto de relatório de
estágio, proposta e texto de trabalho de conclusão de curso) realizadas por ele. Também foi
simplificada a ficha de avaliação, possibilitando ao avaliador (professor, profissional) atribuir
uma única nota ao invés de preencher cada um dos itens da avaliação, é outro exemplo de
mudança na regra de negócio anteriormente implementada.
O desenvolvimento desse tipo de aplicativo, em termos de funcionalidades, se
justifica para automatizar, agilizar e gerenciar as tarefas envolvidas na composição das
1
bancas, agendamento das apresentações e controle do ciclo de vida de cada tipo de trabalho.
Além de permitir o preenchimento de planos de estágio e proporcionar diversos controles,
como o de bancas, ainda não atribuídas e a emissão dos diversos relatórios e documentos
envolvidos nesses trabalhos acadêmicos.
1.4 ESTRUTURA DO TRABALHO
Este texto está organizado em capítulos. Este é o primeiro e apresenta as
considerações iniciais, o objetivo e a justificativa do trabalho. O Capítulo 2 apresenta o
referencial teórico que se refere ao desenvolvimento de aplicações web utilizando o conceito
Rich Internet Applications (RIA). No Capítulo 3 estão os materiais e o método utilizados para
a modelagem e a implementação do sistema. Os resultados da realização deste trabalho são
apresentados no Capítulo 4. Por fim está a conclusão, seguida das referências utilizadas na
composição do texto.
1
2 REFERENCIAL TEÓRICO
Este capítulo apresenta conceitos que fundamentam as tecnologias utilizadas para
implementar o sistema desenvolvido como resultado desse trabalho. Utilizando tecnologias
que caracterizam a interface do sistema como rica, o referencial teórico está fundamentado em
Rich Internet Application (RIA).
2.1 WEB TRADICIONAL
Segundo Kurniawan (2002), os termos Internet Application (aplicativo de internet) ou
web application foram cunhados quando foi introduzido o conteúdo dinâmico, sendo uma
aplicação web um site cujo conteúdo é gerado dinamicamente antes de ser enviado ao
navegador.
Ainda segundo Kurniawan (2002), as aplicações web consistem em vários clientes e
servidores conectados através da internet. Os servidores são utilizados para receber uma
solicitação realizada pelo cliente e retornar algo, normalmente um HyperText Language
Markup (HTML) com Cascading Style Sheets (CSS), uma imagem, um arquivo Portable
Document Format (PDF) ou um código de erro, caso a solicitação não possa ser processada.
O cliente, por sua vez, permite ao usuário realizar solicitações ao servidor e exibir o resultado
da solicitação do pedido.
O usuário realiza solicitações através de uma Uniform Resource Locator (URL): um
endereço único próprio, informando o protocolo que será utilizado; o servidor utilizando o
nome do servidor físico que está sendo buscado; a porta, utilizada para identificar a aplicação
não sendo necessário informar, utilizando como padrão a porta 80; o caminho no servidor do
recurso que está sendo solicitado; e o recurso, o nome do conteúdo que o cliente está
procurando (BASHAM, 2002).
Quando o servidor responde à solicitação, geralmente encaminha algum tipo de
conteúdo ao navegador para exibir ao usuário. Esse conteúdo é composto por instruções
escritas em HTML informando o navegador de como deve ser apresentada a resposta ao
usuário.
A maioria das trocas de mensagens realizadas entre clientes e servidores ocorre através
do protocolo HyperText Transfer Protocol (HTTP) possibilitando solicitação e respostas
simples. O HTTP utiliza conexões Transmission Control Protocol/Internet Protocol (TCP/IP)
1
confiáveis (BASHAM, 2002).
Segundo Kurniawan (2002) uma solicitação HTTP consiste em três principais
elementos para ocorrer o fluxo de solicitação: o método, que será a ação a ser executada, a
página que será executada e os parâmetros do formulário.
O método informa ao servidor o tipo de solicitação que está sendo realizada pelo
usuário e como o restante da mensagem será formatada. Os métodos mais comuns são o GET,
que pede ao servidor que consiga um recurso e o mande de volta ao cliente; e o POST que é
utilizado para solicitar algo e enviar os dados de um formulário para o servidor (BASHAM,
2010).
Uma resposta HTTP é composta por um cabeçalho que informa ao navegador o
protocolo que está sendo utilizado, se a solicitação obteve êxito sendo retornado ao usuário o
status da solicitação realizada, e qual o tipo de conteúdo está incluído no corpo, como, por
exemplo, HTML ou outro conteúdo que será processado.
2.2 RICH INTERNET APPLICATION
A popularidade das aplicações web teve um crescimento em 1993, quando o navegador
Mosaic foi apresentado, e continuou crescendo durante a década de 1990 (DEITEL, 2008).
Ainda, de acordo com esse autor, em 2003, havia uma mudança visível no modo como as
pessoas e os negócios estavam usando a web e desenvolvendo aplicações baseadas na web.
Observando a necessidade de tecnologias inovadoras com recursos mais interativos,
disponibilizando informações complexas de maneira dinâmica e compreensível tendo em
vista a facilidade de uso pelo usuário, surgiram as Rich Internet Application (RIA).
De acordo com Allaire (2002), as RIAs são definidas como a combinação das
funcionalidades de interface de usuário de aplicativos de software de desktop com o amplo
alcance e implantação de baixo custo dos aplicativos da web e o melhor da interatividade, e
comunicação multimídia. O resultado: uma aplicação que fornece uma forma mais intuitiva,
responsiva e eficaz para a experiência do usuário (DUHL, 2003, p. 10).
As RIAs são aplicativos cliente-servidor diferenciando na quantidade de
processamento feito no servidor e no cliente. Diferente das aplicações web tradicionais, as
RIAs implementam uma camada intermediaria de código, entre o usuário e o servidor. É
carregado normalmente no início da aplicação e pode ser acrescido de outras atualizações de
código conforme essas atualizações são baixadas. A camada intermediária atua como uma
extensão do navegador e é responsável pela renderização da interface e a comunicação com o
1
servidor, executa funções que r7eforçam os aspectos da interface do usuário, e melhoram a
resposta conforme as interações do usuário.
Utilizando as aplicações RIA para desenvolvimento é possível verificar algumas
particularidades (BOZZON, 2006): a redução de comunicação com o servidor e o
processamento de dados no lado cliente da aplicação; existência de vários níveis de
persistência para os dados que compõem a aplicação, tanto no lado do cliente quanto no
servidor; e a utilização pode ocorrer em modos on-line e off-line.
1
3 MATERIAIS E MÉTODO
Este capítulo apresenta os materiais e o método utilizados para a realização deste
trabalho. Os materiais estão relacionados às tecnologias e às ferramentas utilizadas para
modelar e implementar o aplicativo e o método apresenta a sequência das principais
atividades realizadas para o levantamento dos requisitos, a modelagem e a implementação dos
requisitos.
3.1 MATERIAIS
O Quadro 1 apresenta a listagem das principais ferramentas e tecnologias que serão
utilizadas no desenvolvimento do sistema proposto.
Ferramenta / Tecnologia
Versão
Referência Finalidade
Astah Community
8.0.0 http://astah.net Modelagem UML
Linguagem Java JDK 1.8 http://www.oracle.com Linguagem de programação
IntelliJ IDEA 2018.2.5 https://www.jetbrains.com/idea/ Ambiente de desenvolvimento
Spring Boot 2 https://spring.io/ Framework para automatizar a configuração inicial do projeto
Apache Maven 4.0.0 https://maven.apache.org/ Ferramenta para gerenciamento do projeto
MySql 8.0 https://www.mysql.com Banco de dados MySql WorkBench
8.0 https://www.mysql.com/products/workbench/ Administrador de Banco de dados
PrimeFaces 5.2 https://www.primefaces.org/ Biblioteca de componentes para web
JavaServer Faces (JSF)
2.2.9 http://www.javaserverfaces.org/ Framework para
web
Quadro 1 - Lista de ferramentas e tecnologias utilizadas
a) JavaServer Faces
JavaServer Faces foi desenvolvido pelo Java Community Process, sendo mantido e
operado por membros do Grupo de Peritos JSR-314 e por contribuidores dedicados à
comunidade. Inclui um conjunto de APIs para representar componentes de interface do
1
usuário e gerenciar seu estado, manipular eventos e validar entradas, definir navegação de
páginas e suportar internacionalização e acessibilidade (ORACLE, 2017a).
JSF foi projetado para ser flexível, permitindo criar aplicações Java para web
utilizando componentes visuais pré-definidos, de forma que o desenvolvedor não se preocupe
com JavaScript e HTML, basta adicionar os componentes e eles serão renderizados e exibidos
em formato HTML. O estado dos componentes é sempre armazenado automaticamente,
criando a característica stateful. Efetua a separação entre camadas de apresentação e de
aplicação com base no modelo Model-View-Controller (MVC), separando a camada de
visualização dos conjuntos de classes de modelo (JAVASERVER, 2018).
As implementações mais populares são a Oracle Mojarra (ORACLE, 2017B) e a
MyFaces da Apache Softwares Foundation, possuindo várias extensões com o mesmo ciclo e
modelo de especificação, como: PrimeFaces, RichFaces e IceFaces.
b) Spring
O Spring é um framework com código aberto, desenvolvido por Rod Johnson, em
2002. É capaz de aumentar a produtividade no desenvolvimento de aplicações web,
contribuindo para um desenvolvimento que atenda aos principais padrões de desenvolvimento
simplificando o desenvolvimento na programação Java (SPRING, 2018)
Spring Boot facilita a criação de aplicativos baseados em Spring autônomos e de
produção que pode ser executada. Os principais objetivos são fornecer um início de projeto
rápido e direto para o usuário, apresentar uma visão opinativa sobre as configurações
efetuadas no projeto, fornecer uma grande quantidade de requisitos não funcionais e
configurados para desenvolvedores, como métricas, segurança, entre outros, e minimizar a
quantidade de arquivos XML (SPRING, 2018).
3.2 MÉTODO
A seguir são descritas as etapas definidas para o desenvolvimento das alterações e
inclusões que serão realizadas na aplicação e as principais atividades de cada processo
utilizando como base o modelo sequencial linear descrito por Pressman (2008) para
denominar as fases do processo.
a) Requisitos
2
O levantamento dos requisitos foi realizado tendo como base as necessidades dos
cursos do Departamento Acadêmico de Informática da UTFPR, Câmpus Pato Branco. Os
docentes responsáveis pelas atividades de estágio e conclusão de curso desse Departamento
forneceram os requisitos para as modificações a serem realizadas no sistema.
b) Análise e projeto do sistema
A modelagem dos requisitos foi realizada visando complementar uma versão prévia do
sistema. Os requisitos auxiliam na modelagem do sistema e na criação dos casos de uso, as
modificações que devem ser realizadas e quais os problemas encontrados que devem ser
solucionados e como devem ser solucionados.
c) Implementação
A implementação foi realizada utilizando as ferramentas indicadas no Quadro 1.
Foram implementados os requisitos levantados, mantendo a usabilidade do projeto.
d) Testes
Os testes foram realizados de maneira informal e à medida que as interações ocorriam.
Sendo realizado teste de verificação de código, funcionalidades e interações com o sistema
pela autora desse trabalho.
2
4 RESULTADOS
Este capítulo apresenta o que foi obtido como resultado do trabalho, que é a
modelagem e a implementação do sistema.
4.1 ESCOPO DO SISTEMA
O que foi desenvolvido visa complementar funcionalidades em um sistema web de
gestão de atividades de TCC e de estágio curricular. O TCC e o relatório de estágio curricular
são atividades que os alunos devem desenvolver como requisito para concluir um curso
(Universidade Tecnológica Federal do Paraná, 2018). Para isso, o aluno deve escrever uma
monografia que é um documento que relata sobre o trabalho desenvolvido. Os relatórios de
estágio curricular obrigatório são documentos que visam relatar as atividades desenvolvidas
pelo acadêmico durante o período de realização do estágio. Ambos os trabalhos são
submetidos a uma banca avaliadora. Os acadêmicos devem apresentar o trabalho realizado
perante essa banca que tem a função de avaliá-lo em termos de escrita, dos resultados obtidos
e da apresentação. O aluno deve entregar seu trabalho para a banca com um prazo de
antecedência definido pelos responsáveis pelas atividades de TCC ou de estágio.
A banca tem a função de avaliar os trabalhos e atribuir uma nota após a apresentação
do aluno. Na avaliação, os professores que compõe e banca podem sugerir melhorias nos
trabalhos e o aluno fica condicionado a fazer as devidas correções para que seja aprovado e a
nota lançada no sistema acadêmico. Atualmente essa avaliação ocorre por meio de fichas
impressas ou planilhas eletrônicas. Os trabalhos são recebidos por e-mail e a devolutiva
também ocorre por e-mail.
Os responsáveis pelas atividades de TCC e estágio têm a função de controlar o
processo de envio, devolutiva, realizar cálculo das médias, lançamento de notas, cadastro de
alunos e projetos e a geração da ata de defesa para que seja anexada na versão final do
relatório ou da monografia. Atualmente, no DAINF todas essas atividades são gerenciadas por
e-mail ou mediante fichas de avaliação impressas.
Visando melhorar esses procedimentos, foi desenvolvido um sistema web que faz a
gestão dessas atividades. No entanto, para que o sistema seja efetivamente utilizado, é
necessário que novas funcionalidades sejam implementadas. Dentre essas funcionalidades,
este trabalho propõe que o sistema permita: o cadastro do plano de estágio que o aluno deve
2
preencher para iniciar seu estágio, a geração de documentos como a ata da defesa que deve ser
anexada na versão final do relatório de estágio ou monografia, a geração de declarações de
participação para os membros da banca avaliadora e a emissão de relatórios.
Assim, o sistema possibilitará que professores responsáveis pelas atividades de TCC
e estágio possam realizar as atividades de gestão, os professores que fazem parte da banca
examinadora possam fazer o download dos trabalhos e o lançamento da nota e os alunos
possam enviar os trabalhos e visualizar suas notas.
4.2 MODELAGEM DO SISTEMA
O diagrama conceitual de domínio é apresentado na Figura 1. Essa figura tem o
objetivo de apresentar uma visão geral do sistema. Os conceitos apresentados não representam
classes e/ou tabelas do banco de dados, mas uma visão geral do contexto e escopo do sistema.
Figura 1 - Modelo conceitual de Domínio do sistema Fonte: adaptado de Pichetti (2015, p. 19).
A apresentação realizada pelo aluno pode ser uma monografia, TCC ou Estágio. A
apresentação é realizada para uma banca que faz a avaliação do aluno de acordo com critérios
predefinidos. Um dos membros da banca é o orientador do aluno, os outros avaliadores são
professores ou profissionais, podendo haver coorientador que participará ou não da banca de
avaliação. Posterior à apresentação, é lançada a nota do aluno, realizada a geração da ata da
apresentação e dos comprovantes de participação aos membros da banca e aos alunos que
assistiram à apresentação.
No Quadro 2 estão listados os requisitos funcionais identificados para realizar as
2
alterações e inclusões no sistema.
Identificação Nome Funcionalidade
RF01 Manter plano de estágio
Os dados do estágio do aluno.
RF02 Gerar ata A ata contém os dados da apresentação do TCC e/ou do estágio pelo aluno perante uma banca.
RF03 Gerar declaração de participação para banca.
A declaração contém os dados da defesa do TCC e/ou do estágio para o professor orientador e os professores da banca.
RF04 Lançar nota geral Lançamento de uma nota geral para avaliar um projeto.
RF05 Manter a informação de coordenador e coordenação
Modificar a classe Curso para que contenha as informações de coordenador e coordenação do curso
RF06 Manter cargos Dados referentes aos cargos utilizados no plano de estágio
RF07 Manter aluno Permitir que o aluno cadastre-se automaticamente RF08 Gerar relatório O relatório fornecerá informações de bancas,
professores, alunos e datas de projetos defendidos RF09 Visualizar agenda de
avaliações Informar aos avaliadores quais projetos ele deve avaliar e as bancas que deve participar
Quadro 2 - Requisitos Funcionais
O diagrama na Figura 2 apresenta as funcionalidades essenciais que serão adicionadas
ao projeto realizado pelos seus atores que são: aluno, avaliadores e professor responsável. O
professor responsável informa os dados de cargos, realiza a geração de atas das apresentações
e declaração de participação aos avaliadores da banca. O aluno poderá se cadastrar no
sistema, cadastrar seu plano de estágio e cadastrar a informação de cargo, caso não tenha a
opção de cargo desejada no momento de cadastro. Aos avaliadores será possível realizar o
cadastro de nota da apresentação do aluno, sem ser necessário cadastrar nota para cada item
de avaliação.
2
Figura 2 - Diagrama de Caso de uso
No Quadro 3 será realizada a descrição do caso de uso manter cadastros.
Caso de uso: Manter cadastros Descrição: Esse caso de uso refere-se às operações de inclusão, alteração, exclusão e consulta das informações de cargos e áreas utilizadas na criação do plano de estágio. Evento Iniciador: Necessidade de incluir, excluir, consultar ou alterar cadastros. Atores: Professor Responsável Pré-condição: Dados necessários disponíveis. Sequência de Eventos: 1. Ator seleciona formulário pretendido. 2. Sistema apresenta o formulário. 3. Ator realiza a operação desejada: incluir, excluir, consultar, alterar. 4. Sistema verifica se os dados para a operação estão consistentes e realiza a operação. Pós-Condição: Realização da operação de inclusão, exclusão, consulta, alteração. Nome do fluxo alternativo (extensão) Descrição Linha 4: Exclusão de registro com dados de tabelas vinculadas ativos.
4.1 Se solicitada exclusão de registro que possui tabelas vinculadas com dados ativos, é informada mensagem que não é possível realizar a exclusão. Sistema informa o usuário e permanece em estado anterior à realização da operação na Linha 4.
Linha 4: Inconsistência dos dados 4.2 No momento de salvar as informações o sistema faz a validação se o usuário informou os dados
2
necessários. Sistema repassa uma mensagem informando o usuário da inconsistência e permanece em estado anterior ao da Linha 4.
Quadro 3 - Expansão caso de uso: Manter Cargos
No Quadro 4 será realizada a expansão do caso de uso gerar declaração de
participação em banca.
Caso de uso: Gerar Declaração de participação em banca Descrição: Esse caso de uso refere-se à geração de declaração aos participantes da banca Evento Iniciador: Necessidade de comprovação de participação de bancas. Atores: Professor Responsável Pré-condição: Apresentação realizada deve estar cadastrada Sequência de Eventos: 1. Ator seleciona formulário de declaração de participação em banca 2. Sistema apresenta o formulário com filtro para geração da informação. 3. Ator informa os dados solicitados. 4. Sistema verifica se os dados para a operação estão consistentes e gera a declaração para os responsáveis. Pós-Condição: Geração das declarações às pessoas envolvidas.
Nome do fluxo alternativo (extensão) Descrição Linha 4: Filtros não encontram dados 4.1 Sistema verifica os filtros informados e não encontra
dados. Retorno de mensagem ao usuário que os filtros não retornaram informação.
Linha 4: Filtros informados estão incorretos
4.2 Sistema valida os filtros informados para verificação se estão no formato correto. Retorno de mensagem ao usuário que os filtros informados estão incorretos.
Quadro 4 - Expansão de caso de uso: Gerar Declaração de Participação em Bancas
No Quadro 5 será realizada a expansão do caso de uso lançar nota geral.
Caso de uso: Lançar nota geral Descrição: Esse caso de uso se refere à inclusão da nota geral do aluno sem a necessidade de informar nota para cada item de avaliação. Evento Iniciador: Necessidade de informar a nota do aluno de uma vez, sem a necessidade de incluir por itens de avaliação Atores: Avaliador Pré-condição: O aluno deverá ter apresentado o projeto para a banca Sequência de Eventos: 1. Ator seleciona formulário de notas 2. Sistema apresenta o formulário.
2
3. Ator realiza a inclusão da nota geral no sistema. 4. Sistema verifica se o dado para a operação está consistente e salva a informação. Pós-Condição: Realização do cadastro da nota geral
Nome do fluxo alternativo (extensão) Descrição Linha 4: Dados inconsistentes 4.1 Dado informado pelo usuário está
inconsistente com o formato esperado. Sistema emite mensagem ao usuário informando sobre o erro e permanece na tela atual.
Quadro 5 - Expansão de Caso de Uso: Lançar Nota Geral
No Quadro 6 será realizada a expansão do caso de uso manter aluno. Caso de uso: Manter Aluno Descrição: Esse caso de uso se refere à inclusão dos dados do aluno realizada pelo ele. Evento Iniciador: Necessidade de incluir informações Atores: Aluno Pré-condição: Aluno estar cadastrado no sistema acadêmico Sequência de Eventos: 1. Ator seleciona formulário de alunos 2. Sistema apresenta o formulário. 3. Ator realiza a inclusão das suas informações. 4. Sistema verifica se os dados para a operação estão consistentes e salva as informações do aluno Pós-Condição: Realização da operação de inclusão. Nome do fluxo alternativo (extensão)
Descrição
Linha 4: Dados inconsistentes 4.1 Dados informados pelo usuário não estão corretos. Sistema retorna mensagem avisando o usuário sobre o erro, mantendo o conteúdo na tela acessada pelo usuário.
Quadro 6 - Expansão de Caso de Uso: Manter Aluno
No Quadro 7 está realizada a expansão do caso de uso manter plano de estágio.
2
Caso de uso: Manter Plano de Estágio Descrição: Esse caso de uso se refere à inclusão dos dados do plano de estágio do aluno. Evento Iniciador: Esse caso de uso se refere à inclusão, alteração e exclusão das alterações dos dados. Atores: Aluno Pré-condição: Aluno estar cadastrado no sistema acadêmico Sequência de Eventos: 1. Ator seleciona formulário de projetos e seleciona Plano de Estágio 2. Sistema apresenta o formulário. 3. Ator realiza a inclusão das suas informações. 4. Sistema verifica se os dados para a operação estão consistentes e encaminha a informação para o professor responsável. Pós-Condição: Realização da operação de inclusão Nome do fluxo alternativo (extensão) Descrição Linha 4: Dados inconsistentes 4.1 Dados informados pelo usuário não estão corretos.
Sistema retorna mensagem avisando o usuário sobre o erro, mantendo o conteúdo na tela acessada pelo usuário.
Quadro 7 - Expansão de Caso de Uso: Manter Plano de Estágio
A expansão do caso de uso gerar relatório está no Quadro 8.
Caso de uso: Gerar Relatório Descrição: Geração de relatório com as informações dos projetos apresentados, quantidade de alunos que apresentaram projetos, professores participantes da banca, entre outras informações. Evento Iniciador: Esse caso de uso se refere à listagem das informações das apresentações dos projetos. Atores: Professor Responsável Pré-condição: Informações cadastradas no sistema Sequência de Eventos: 1. Ator seleciona formulário de geração dos relatórios 2. Sistema apresenta o formulário com filtro para geração do relatório 3. Ator informa o filtro para gerar o relatório 4. Sistema verifica os filtros informados pelo usuário e retorna o relatório das informações Pós-Condição: Realização da operação de inclusão Nome do fluxo alternativo (extensão) Descrição Linha 4: Filtros informados estão incorretos 4.1 Filtros de datas podem ter recebidos datas em
formatos diferentes ou dias não existentes no referido mês. Sistema retorna mensagem ao usuário sobre o filtro informado.
Quadro 8 - Expansão de Caso de Uso: Gerar Relatório
A expansão do caso de uso Visualizar agenda de avaliações está no Quadro 9.
2
Caso de uso: Visualizar agenda de avaliações Descrição: Apresentação em uma agenda com a informação dos projetos que o avalidor deve avaliar e as bancas que deve participar. Evento Iniciador: Esse caso de uso se refere a uma agenda das informações das apresentações de projetos avaliados pelos avaliadores Atores: Avaliadores Pré-condição: Informações cadastradas no sistema Sequência de Eventos: 1. Ator faz login no sistema 2. Sistema apresenta uma agenda na tela inicial para o avaliador com as avaliações Pós-Condição: Agenda das avaliações para os avaliadores
Nome do fluxo alternativo (extensão) Descrição Linha 4: Não possui agendamentos 4.1 Não há informações de agendamentos para a
agenda, é retornado uma agenda em branco para o avaliador.
Quadro 9 - Expansão de Caso de Uso: Visualizar Agenda de Avaliações
Na Figura 3 está o diagrama de classe do sistema da análise do projeto. No diagrama
estão as classes já existentes no trabalho anterior, além das classes adicionadas neste trabalho.
Um plano de estágio será adicionado pelo aluno no sistema com as informações pertinentes
para validação do professor responsável. O professor responsável deve cadastrar as
informações de cargos e áreas pertinentes aos alunos no momento do cadastro da informação
do plano de estágio.
2
Figura 3 - Diagrama de Classe da análise do projeto Fonte: Próprio autor
Na Figura 4 é possível visualizar o Diagrama de Entidade e Relacionamento (DER) do
banco de dados com todas as tabelas do banco de dados após as modificações realizadas.
Figura 4 - Diagrama de Entidade e Relacionamento Fonte: Próprio autor
3
4.3 APRESENTAÇÃO DO SISTEMA
A tela de login do sistema é apresentada na Figura 5. Por meio dessa tela é possível
realizar o acesso ao sistema.
Figura 5 - Tela de Login Fonte: Próprio autor
Ao clicar na opção “Cadastrar-se”, o sistema abre uma nova tela, na qual o usuário
realiza seu cadastro e recebe a permissão para ver os menus como ALUNO e é restringido a
visualização de alguns menus. Na Figura 6 é possível verificar os dados que devem ser
informados ao realizar o cadastro do sistema.
Figura 6 - Tela para Cadastro de Usuário Aluno Fonte: Próprio autor
Para efetuar o cadastro é necessário informar nome, Registro Acadêmico (RA), login,
senha e confirmação da senha. Caso os campos obrigatórios não sejam informados o sistema
retorna erro para o usuário, conforme apresentado na Figura 7.
3
Figura 7 - Campos Obrigatórios no cadastro Fonte: Próprio autor
Após efetuar o cadastro o usuário é redirecionado para a tela de login para que possa
efetuar o acesso. Ao acessar o sistema um administrador o usuário tem acesso à tela que pode
ser verificada na Figura 8.
Figura 8 - Tela Inicial Fonte: Próprio autor
Ainda na Figura 8 é possível verificar os agendamentos que foram realizados para as
apresentações que o usuário autenticado participará.
O leiaute de apresentação do sistema consiste em um topo com o logo da
Universidade, com um menu ocupando o canto esquerdo da tela e a agenda de apresentação
do usuário ocupando o centro da tela.
Foram realizadas alterações no cadastro de curso para que seja informado qual a
coordenação do curso e quem é o coordenador. Ambos campos obrigatórios, sendo necessário
3
que o usuário, no momento do cadastro, informe esses dados. A apresentação da tela pode ser
visualizada na Figura 9.
Figura 9 - Cadastro de Curso Fonte: Próprio autor
No cadastro de tipo de projeto, foi adicionado um checkbox para que seja informado se
o tipo do projeto é estágio ou não, a modificação pode ser visualizada na Figura 10. Outra
informação adicionada no cadastro de tipo de projeto é o número de ata sendo utilizada para
gerar as atas de estágios.
Figura 10 - Cadastro de Tipo de Projeto Fonte: Próprio autor
O cadastro de cargos foi adicionado para que no momento do cadastro dos projetos do
tipo estágio seja informado o cargo de um cadastro utilizado pelo sistema. Na Figura 11 é
apresentada a tela de listagem dos cargos cadastrados no sistema.
3
Figura 11 - Lista de Cargos Fonte: Próprio autor Na lista de cargos é exibido o nome e a descrição dos cargos que estão cadastrados. Há
a opção para que sejam cadastrados novos cargos, editados e excluídos os que já estejam
cadastrados. Na Figura 12, é possível visualizar formulário de cadastro de um cargo no
sistema.
Figura 12 - Cadastro de Cargos Fonte: Próprio autor O cadastro de cargos tem como obrigatória a informação do nome do cargo e se não
informado é retornado um informe de erro para o usuário, como pode ser verificado na Figura
13.
Figura 13 - Erro ao inserir cargo sem informação de nome Fonte: Próprio autor
3
Ao salvar um cargo com os campos obrigatórios informados é retornada mensagem de
confirmação ao usuário, como pode ser verificado na Figura 14.
Figura 14 - Confirmação ao salvar cargo Fonte: Próprio autor
No cadastro de projetos foi realizada a modificação para aceitar as informações de
estágios. Na Figura 15 é possível verificar como ocorre a listagem de projetos, sendo
mostrada a informação do título do projeto, o curso e o tipo de projeto.
Figura 15 - Lista de Projetos Fonte: Próprio autor
Quando clicado em “Novo Projeto” é retornado um modal para o cadastrado de um
novo projeto, como pode ser visualizado na Figura 16. É apresentada uma guia com o título
“Projeto”, para informar o curso, tipo de projeto, título da monografia, descrição, orientador,
coorientador e o aluno, sendo possível adicionar mais de um aluno no projeto cadastrado.
3
Figura 16 - Cadastro de Projeto Fonte: Próprio autor
Quando selecionado o tipo de projeto, caso sem a opção de estágio marcada no seu
cadastro, a guia com o título “Estágios” fica desabilitada, sendo possível visualizar na Figura
17.
Figura 17 - Cadastro de Projeto - Tipo de Projeto é Estágio Fonte: Próprio autor
Caso o tipo de projeto tenha a opção estágio marcada, a guia “Estágio” do modal é
3
habilitada, conforme demonstrado na Figura 18.
Figura 18 - Cadastro de Projeto - Tipo de Projeto não é Estágio Fonte: Próprio autor
No cadastro de Estágio, foram adicionadas as informações pertinentes ao projeto de
estágio. Na Figura 19 é possível visualizar a primeira parte do cadastro de estágio, sendo
possível visualizar os campos que fazem parte desse cadastro.
Figura 19 - Cadastro de Estágio: Parte 1 Fonte: Próprio autor Há três tipos de estágios, o estágio obrigatório, estágio não obrigatório e a validação,
3
conforme o tipo de estágio informado, os campos de subtipo de estágio e tipo de validação são
ajustados. O campo subtipo de estágio só ficará habilitado se o tipo do estágio for obrigatório.
Assim como para o tipo de estágio, existem três subtipos de estágio, o efetivo, o estagiário e o
estudo dirigido. O campo tipo de validação ficará habilitado em duas condições, se o tipo do
estágio for validação, ou se o tipo do estágio for obrigatório e o subtipo do estágio for efetivo.
A informação do cargo pode ser escolhida conforme o que está cadastrado ou o
usuário pode realizar o cadastro do cargo no momento que estiver realizando o cadastro do
projeto.
Na Figura 20 é apresentada a segunda parte do cadastro de projeto, quando o tipo de
projeto é Estágio.
Figura 20 - Cadastro de Estágio - Parte 2 Fonte: Próprio autor
Nessa segunda parte do cadastro de estágio é informado o horário em que o estágio foi
realizado, ao clicar no botão “+ Adicionar Horário” é adicionada uma linha na tabela para que
sejam informados os horários que o aluno realizou o estágio na empresa. Na Figura 21 é
possível verificar o cadastro dos horários.
Figura 21 - Cadastro de Horários – Estágio Fonte: Próprio autor Após o cadastro do projeto é possível que o usuário gere a informação de plano de
estágio, conforme Figura 22.
3
Figura 22 - Visualizar dados da Postagem Fonte: Próprio autor
Ao clicar em Download, ao lado de “Plano de Estágio”, é realizado o donwload de um
arquivo em formato PDF com as informações de Plano de Estágio, conforme Figura 23.
3
Figura 23 - Plano de Estágio Fonte: Próprio autor
No mesmo modal que o usuário pode gerar o plano de estágio é possível gerar a ata de
apresentação do estágio ou Trabalho de Conclusão de Curso apresentado. Quando é estágio é
gerada a ata que pode ser visualizada na Figura 24.
4
Figura 24 - Ata de Estágios Fonte: Próprio autor
Quando o tipo de projeto não é um estágio é gerada uma ata para as monografias que
pode ser visualizada na Figura 25.
4
Figura 25 - Ata Trabalhos de Conclusão de Curso Fonte: Próprio autor
No cadastro de itens de avaliação da banca, foi feita uma modificação para que não
seja mais informado o grupo de itens. Na Figura 26 é possível verificar como são listadas as
informações de itens de avaliação da banca.
4
Figura 26 - Lista de Item de Avaliação Fonte: Próprio autor Na Figura 27 é possível verificar o formulário de cadastro do item de avaliação no
sistema.
Figura 27 - Cadastro de Item de Avaliação Fonte: Próprio autor
No momento de cadastrar a avaliação no sistema é possível que o avaliador
informe a nota, considerando os itens de avaliação cadastrados no modelo de avaliação,
conforme Figura 28.
4
Figura 28 - Cadastro de Avaliação por Item Fonte: Próprio autor
O avaliador pode lançar a nota geral, sem precisar informar as notas parciais
conforme os itens de avaliação, cadastrados no modelo de avaliação, conforme pode ser
visualizado na Figura 29.
Figura 29 - Cadastro de Avaliação por Nota Geral Fonte: Próprio autor
Foi modificado o sistema para que seja possível a geração de relatório das bancas
4
apresentadas, é possível verificar que há uma opção no menu lateral para que seja gerado o
relatório de bancas e as declarações de participação em bancas, conforme Figura 30.
Figura 30 - Menu Lateral Fonte: Próprio autor
Ao selecionar a opção Relatório de Banca, o sistema abre uma tela para que o usuário
informe o período, o ano, o tipo de projeto e o curso, utilizados no filtro do relatório. Tal tela
pode ser visualizada na Figura 31.
Figura 31 - Filtros para relatório das Bancas Apresentadas Fonte: Próprio autor
Após informar os filtros e clicar em “Gerar”, é gerado o relatório que pode ser
4
visualizado na Figura 32 com as relações de bancas apresentadas conforme o filtro informado
pelo usuário. O relatório contém a informação do aluno, título do projeto apresentado, data e
horário da realização da apresentação e local onde foi realizada a apresentação.
Figura 32 - Relatório de bancas apresentadas Fonte: Próprio autor Ao selecionar a opção de declaração, o sistema abre uma tela para que o usuário
informe o período, o ano, o professor, o tipo de projeto e curso, para que seja gerada a
declaração das bancas do professor selecionado. Conforme pode ser visualizado na Figura 33.
Figura 33 - Filtro para gerar Declaração Fonte: Próprio autor
Após informar os filtros, é gerada a declaração de participação do professor com todas
as bancas que o professor participou, conforme Figura 34. A declaração que é gerada contém
a informação do curso e tipo de projeto que o professor participou das bancas, os alunos, os
projetos que foram defendidos, a data de realização da defesa dos projetos e qual a função que
o mesmo exerceu em cada banca, orientador ou convidado.
4
Figura 34 - Declaração de Participação de Bancas Fonte: Próprio autor
4.4 IMPLEMENTAÇÃO DO SISTEMA
O sistema foi implementado utilizando o Integrated Development Environment (IDE)
IntelliJ IDEA e o Maven. O Maven é ferramenta de gerenciamento, construção e
implementação de projetos criada pela Fundação Apache. Sua configuração básica de é um
arquivo XML, chamado Project Object Model (POM) que deve ficar na raiz do projeto. Nele
4
são declaradas a estrutura, as dependências e as características do projeto. A Listagem 1
mostra o código do arquivo pom.xml.
<?xml version="1.0"encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>br.edu.utfpr.pb.schaitler</groupId> <artifactId>tcc</artifactId> <version>1.0</version>
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.2.4.RELEASE</version> </parent>
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <start-class>br.edu.utfpr.pb.schaitler.Application</start-class> <java.version>1.8</java.version> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties>
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>
4
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.11</version> </dependency> <dependency> <groupId>com.sun.faces</groupId> <artifactId>jsf-api</artifactId> <version>2.2.10</version> </dependency> <dependency> <groupId>com.sun.faces</groupId> <artifactId>jsf-impl</artifactId> <version>2.2.10</version> </dependency> <dependency> <groupId>org.primefaces.extensions</groupId> <artifactId>primefaces-extensions</artifactId> <version>3.2.0</version> </dependency> <dependency> <groupId>org.primefaces</groupId> <artifactId>primefaces</artifactId> <version>5.2</version> </dependency> <dependency> <groupId>org.primefaces.themes</groupId> <artifactId>bootstrap</artifactId> <version>1.0.10</version> </dependency> <dependency> <groupId>org.webjars</groupId> <artifactId>font-awesome</artifactId> <version>4.4.0</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-taglibs</artifactId> </dependency> <dependency> <groupId>org.springframework.webflow</groupId> <artifactId>spring-faces</artifactId> <version>2.4.0.RELEASE</version> </dependency> <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.1</version> </dependency> <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.4</version> </dependency> <dependency> <groupId>net.sf.jasperreports</groupId> <artifactId>jasperreports</artifactId> <version>6.3.0</version> </dependency> <dependency> <groupId>net.sf.jasperreports</groupId>
4
<artifactId>jasperreports-fonts</artifactId> <version>6.0.0</version> </dependency> <dependency> <groupId>com.sun.xml.ws</groupId> <artifactId>jaxws-rt</artifactId> <version>2.1.4</version> </dependency> </dependencies>
<repositories> <repository> <id>prime-repo</id> <name>PrimeFaces Maven Repository</name> <url>http://repository.primefaces.org</url> <layout>default</layout> </repository> </repositories> </project>
Listagem 1 - pom.xml
As dependências contidas no arquivo POM, são todas as bibliotecas externas que o
projeto depende para ser construído. Essas dependências são gerenciadas pelo próprio Maven.
Na tela de login é possível verificar que existe um link para o cadastro de usuário.
Esse cadastro é para usuários alunos, é possível verificar na Listagem 2 o componente
“dialog” do Primeface, utilizado para apresentar a tela para informar os dados do usuário em
um formato “modal”. O appendTo é utilizado para que o “dialog” seja listado dentro do
“body” não sendo sobreposto na página.
<?xml version="1.0"encoding="UTF-8"?> <ui:composition xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:h="http://java.sun.com/jsf/html" xmlns:p="http://primefaces.org/ui" xmlns:pe="http://primefaces.org/ui/extensions" xmlns:f="http://java.sun.com/jsf/core" xmlns:j="http://xmlns.jcp.org/jsf/composite/components" template="/resources/templates/base.xhtml"> <p:dialog id="dlgCadastrar"widgetVar="dlgCadastrar" header="#{msg['usuario.cadastrar']}"modal="true" resizable="false"closable="false"appendTo="@(body)"> <h:form id="form"> <h:panelGrid id="pnlForm"columns="2"cellspacing="5"> <p:outputLabel value="#{msg['comum.nome']}"for="nome"/> <p:inputText id="nome"value="#{alunoController.instancia.usuario.nome}" maxlength="60"size="70"required="true" requiredMessage="#{msg['comum.nome.required']}"/>
<p:outputLabel value="#{msg['aluno.ra']}"for="ra"/> <pe:inputNumber id="ra"value="#{alunoController.instancia.ra}" maxValue="99999999"decimalPlaces="0" required="true"requiredMessage="#{msg['aluno.ra.required']}" validatorMessage="#{msg['aluno.ra.validateLongRange']}"> <f:validateLongRange minimum="1"/> </pe:inputNumber>
<p:outputLabel value="#{msg['comum.mostrar']}"for="filtroAtivo"/>
5
<p:selectOneMenu id="filtroAtivo"value="#{usuarioController.filtroAtivo}"> <f:selectItem itemValue="0"itemLabel="#{msg['comum.ativos']}"/> </p:selectOneMenu>
<p:outputLabel value="#{msg['usuario.login']}"for="login"/> <p:inputText id="login"value="#{alunoController.instancia.usuario.login}" maxlength="30"size="40"required="true" requiredMessage="#{msg['usuario.login.required']}"/>
<p:outputLabel value="#{msg['usuario.email']}"for="email"/> <p:inputText id="email"value="#{alunoController.instancia.usuario.email}" type="email"maxlength="60"size="70"/>
<p:outputLabel value="#{msg['usuario.telefone']}"for="telefone"/> <p:inputText id="telefone"value="#{alunoController.instancia.usuario.telefone}" maxlength="14"size="20"/>
<p:outputLabel value="#{msg['usuario.senha']}"for="senha"/> <p:password id="senha"value="#{alunoController.instancia.usuario.senha}" maxlength="30"size="40"required="true" validatorMessage="#{msg['usuario.confirmacao.validator']}" requiredMessage="#{msg['usuario.senha.required']}" match="confirmacao"/>
<p:outputLabel value="#{msg['usuario.confirmacao']}"for="confirmacao"/> <p:password id="confirmacao"value="#{alunoController.instancia.usuario.senha}" maxlength="30"size="40"required="true" requiredMessage="#{msg['usuario.confirmacao.required']}"/> </h:panelGrid>
<div align="right"> <p:commandButton value="#{msg['comum.salvar']}"icon="fa fa-check" actionListener="#{alunoControler.salvarCadastrar}" update=":#{p:component('tblDados')}"process="@form"> <p:resetInput target="@form"/> </p:commandButton> <p:commandButton value="#{msg['comum.cancelar']}"icon="fa fa-close" actionListener="#{alunoControler.cancelarSalvar}" update=":#{p:component('tblDados')}"process="@this"> <p:resetInput target="@form"/> </p:commandButton> </div> </h:form> </p:dialog> </ui:composition>
Listagem 2 - cadastrar.xhtml
Na Listagem 2 é possível verificar o componente “confirmDialog”, também do
Primefaces, que irá renderizar mensagens de confirmação ao usuário. A opção de salvar
usuário repassa os dados informados pelo usuário para que sejam armazenados no banco e
retorna para a tela de login para que seja possível realizar o acesso ao sistema. Caso haja
algum problema no cadastro, é retornada mensagem ao usuário. Outra opção para o usuário
nessa tela é a de cancelar, que apenas retornará o usuário para a tela de login.
5
A Listagem 3 mostra o Controller completo, com os métodos para salvar o usuário no
banco e a navageção entre as telas, conforme resultado das operações.
@Controller
@Scope("view") public class CadastrarController implements Serializable {
private Usuario usuario = new Usuario(); private Aluno aluno = new Aluno(); private Permissao permissao = new Permissao(); private FacesService faces;
private List<Aluno>alunos = new ArrayList<>(); private List<Permissao>permissoes = new ArrayList<>();
@Autowired
private AlunoRepository alunoRepository;
@Autowired
private UsuarioRepository usuarioRepository;
@Autowired
private PermissaoRepository permissaoRepository;
@Autowired
protected CadastrarController(AlunoRepository alunoRepository
, FacesService faces, UsuarioRepository usuarioRepository){
this.alunoRepository = alunoRepository; this.usuarioRepository = usuarioRepository; this.faces = faces; alunos = new ArrayList<>();
}
public boolean dadosValidos() { return true;
}
@Transactional
public void salvar() throws IOException { FacesContext context = FacesContext.getCurrentInstance();
FacesMessage msg = new FacesMessage("Salvo com sucesso"); if (dadosValidos()) { try {
prePersist();
usuarioRepository.save(usuario); usuario.setAlunos(alunos); aluno.setUsuario(usuario); alunoRepository.save(aluno); context.addMessage(null, msg ); } catch (Exception ex) {
ex.printStackTrace();
context.addMessage(null, new
FacesMessage(ex.getMessage()) );
} finally {
FacesContext.getCurrentInstance().getExternalContext().redirect("login");
}
}
}
@PrePersist
public void prePersist() {
5
if (usuario != null) { usuario.setAtivo(true); usuario.setPermissoes(permissoes); usuario.criptografarSenha(); alunos.add(aluno); permissoes.add(getPermissao());
}
}
public void cancelar() { aluno = null; usuario = null; try {
FacesContext.getCurrentInstance().getExternalContext().redirect("login"); } catch (Exception e){
e.getStackTrace();
}
}
public Permissao getPermissao() { return permissaoRepository.findByPermissao("ROLE_ALUNO");
}
public void setPermissao(Permissao permissao) { this.permissao = permissao;
}
public List<Permissao> getPermissoes() { return permissoes;
}
public void setPermissoes(List<Permissao> permissoes) { this.permissoes = permissoes;
}
public Usuario getUsuario() { return usuario;
}
public void setUsuario(Usuario usuario) { this.usuario = usuario;
}
public Aluno getAluno() { return aluno;
}
public void setAluno(Aluno aluno) { this.aluno = aluno;
}
public List<Aluno> getAlunos() { return alunos;
}
public void setAlunos(List<Aluno> alunos) { this.alunos = alunos;
}
}
Listagem 3 - CadastrarController.java
5
A classe de Controller “CadastrarController” possui a anotação “Scoped” definida
como view. Dessa forma, a classe será criada enquanto a página que faz referência ficar aberta
no navegador. É por meio do Controller que a camada de visão se comunica com a camada de
modelo.
[...]
<p:tab id="tabEstagio"title="Estágio" disabled="#{projetoController.instancia.tipoProjeto.estagio == true}"> <p:scrollPanel mode="native"style="height: 300px; border: 0;"> <h:panelGrid columns="4"cellspacing="5"> <p:outputLabel value="#{msg['projeto.estagio.tipoEstagio']}"for="tipoestagio"/> <p:selectOneMenu id="tipoestagio" value="#{projetoController.planoEstagio.tipoEstagio}" required="true" requiredMessage="#{msg['projeto.estagio.tipoEstagio.required']}" style="width: 250px;"> <p:ajax listener="#{projetoController.onTipoEstagioChange}"process="@this" update="subTipoEstagio tipoValidacao"/> <f:selectItem itemLabel="Informar o Tipo de Estágio"itemValue="" noSelectionOption="true"/> <f:selectItems value="#{projetoController.tipoEstagio}"/> </p:selectOneMenu>
<p:outputLabel value="#{msg['projeto.estagio.periodo']}"for="periodo"/> <p:inputText id="periodo"value="#{projetoController.planoEstagio.periodo}" required="true"size="90" requiredMessage="#{msg['projeto.estagio.periodo.required']}" maxlength="100"style="width: 30px;"/>
<p:outputLabel value="#{msg['projeto.estagio.subTipoEstagio']}" for="subTipoEstagio"/> <p:selectOneMenu id="subTipoEstagio" value="#{projetoController.planoEstagio.subTipoEstagio}" style="width: 250px;"> <p:ajax listener="#{projetoController.onSubTipoEstagioChange}"process="@this" update="tipoValidacao"/> <f:selectItem itemLabel="Informar o Sub Tipo de Estágio"itemValue="" noSelectionOption="true"/> <f:selectItems value="#{projetoController.subTipoEstagio}"/> </p:selectOneMenu>
<p:outputLabel value="#{msg['projeto.estagio.tipoValidacao']}"for="tipoValidacao"/> <p:selectOneMenu id="tipoValidacao" value="#{projetoController.planoEstagio.tipoValidacao}" style="width: 250px;"> <f:selectItem itemLabel="Informar o Tipo de Validação"itemValue="" noSelectionOption="true"/> <f:selectItems value="#{projetoController.tipoValidacao}"/> </p:selectOneMenu> </h:panelGrid>
<h:panelGrid columns="2"cellspacing="5"> <p:outputLabel value="#{msg['projeto.estagio.empresa']}"for="empresa"/> <p:inputText id="empresa"value="#{projetoController.planoEstagio.empresa}" required="true"
5
requiredMessage="#{msg['projeto.estagio.empresa.required']}" maxlength="100"size="90"/>
<p:outputLabel value="#{msg['projeto.estagio.enderecoEmpresa']}" for="enderecoEmpresa"/> <p:inputText id="enderecoEmpresa" value="#{projetoController.planoEstagio.enderecoEmpresa}" required="true" requiredMessage="#{msg['projeto.estagio.enderecoEmpresa.required']}" maxlength="100"size="90"/>
<p:outputLabel value="#{msg['projeto.estagio.supervisor']}"for="supervisor"/> <p:inputText id="supervisor"value="#{projetoController.planoEstagio.supervisor}" required="true" requiredMessage="#{msg['projeto.estagio.supervisor.required']}" maxlength="100"size="90"/> </h:panelGrid>
<h:panelGrid columns="6"cellspacing="5"> <p:outputLabel value="#{msg['projeto.estagio.cargoSupervisor']}" for="cargoSupervisor"/> <p:selectOneMenu id="cargoSupervisor" value="#{projetoController.planoEstagio.cargoSupervisor}" required="true" requiredMessage="#{msg['projeto.estagio.cargoSupervisor.required']}" converter="#{cargoConverter}"style="width: 250px;"> <f:selectItem itemLabel="#{msg['projeto.estagio.cargoSupervisor.required']}" noSelectionOption="true"/> <f:selectItems value="#{projetoController.cargo}"var="cargo" itemLabel="#{cargo.nome}"itemValue="#{cargo}"/> </p:selectOneMenu>
<p:link outcome="cargo"value="Cadastrar Cargo"target="_blank"/>
<p:outputLabel value="#{msg['projeto.estagio.telefoneSupervisor']}" for="telefoneSupervisor"/> <p:inputText id="telefoneSupervisor" value="#{projetoController.planoEstagio.telefoneSupervisor}" required="true" requiredMessage="#{msg['projeto.estagio.telefoneSupervisor.required']}" maxlength="100"size="20"/>
</h:panelGrid>
<h:panelGrid columns="6"cellspacing="5"> <p:outputLabel value="#{msg['projeto.estagio.email']}"for="emailSupervisor"/> <p:inputText id="emailSupervisor" value="#{projetoController.planoEstagio.emailSupervisor}" required="true" requiredMessage="#{msg['projeto.estagio.email.required']}" maxlength="100" size="20"/>
<p:outputLabel value="#{msg['projeto.estagio.totalSemanal']}"for="totalSemanal"/> <p:inputText id="totalSemanal" value="#{projetoController.planoEstagio.horasSemanais}" required="true" requiredMessage="#{msg['projeto.estagio.totalSemanal.required']}" size="20"
5
style="width: 50px;"/>
<p:outputLabel value="#{msg['projeto.estagio.totalHorasEstagio']}" for="totalHorasEstagio"/> <p:inputText id="totalHorasEstagio" value="#{projetoController.planoEstagio.horasTotais}"required="true" requiredMessage="#{msg['projeto.estagio.totalHorasEstagio.required']}" size="20"style="width: 50px;"/> </h:panelGrid> <h:panelGrid columns="4"cellspacing="5"> <p:outputLabel value="#{msg['projeto.estagio.dataInicial']}"for="dataInicio"/> <p:calendar id="dataInicio"effect="explode" value="#{projetoController.planoEstagio.dataInicio}" pattern="dd/MM/yyyy" required="true" locale="pt"placeholder="99/99/9999" converterMessage="#{msg['projeto.estagio.dataInicial.converter']}" requiredMessage="#{msg['projeto.estagio.dataInicial.required']}"/>
<p:outputLabel value="#{msg['projeto.estagio.dataFinal']}"for="dataFinal"/> <p:calendar id="dataFinal"effect="explode" value="#{projetoController.planoEstagio.dataFinal}"pattern="dd/MM/yyyy" required="true" locale="pt"placeholder="99/99/9999" converterMessage="#{msg['projeto.estagio.dataFinal.converter']}" requiredMessage="#{msg['projeto.estagio.dataFinal.required']}"/>
<p:outputLabel value="#{msg['projeto.estagio.termo']}"for="termo"/> <p:inputText id="termo"value="#{projetoController.planoEstagio.termoCompromisso}" required="true" requiredMessage="#{msg['projeto.estagio.termo.required']}" maxlength="100" size="20"/>
<p:outputLabel value="#{msg['projeto.estagio.emissorTermo']}"for="emissorTermo"/> <p:selectOneMenu id="emissorTermo"value="#{projetoController.planoEstagio.emissor}" style="width: 100px"editable="true"> <f:selectItem itemLabel="UTFPR"itemValue="UTFPR"/> <f:selectItem itemLabel="Outros"itemValue="Outros"/> </p:selectOneMenu>
</h:panelGrid> <h:panelGrid columns="1"cellspacing="5"> <p:outputLabel value="#{msg['projeto.estagio.atvDesempenhadas']}" for="atvDesempenhadas"/> <p:inputTextarea id="atvDesempenhadas" value="#{projetoController.planoEstagio.atvDesempenhadas}" required="true"rows="5"cols="120" requiredMessage="#{msg['projeto.estagio.atvDesempenhadas.required']}"/> </h:panelGrid> <p:dataTable id="tblHorarios" value="#{projetoController.planoEstagio.planoEstagioHorarios}" var="horario" emptyMessage="Adicione um horário"rowIndexVar="indice" style="width: 500px;"> <f:facet name="header">#{msg['planoEstagioHorario.listagem.descricao']}</f:facet> <p:column headerText="#{msg['planoEstagioHorario.diaSemana']}">
5
<p:selectOneMenu id="diaSemana"value="#{horario.diaSemana}"style="width:50px" required="true" requiredMessage="#{msg['planoEstagioHorario.diaSemana.required']}"> <f:selectItem itemLabel="2ª"itemValue="2ª"/> <f:selectItem itemLabel="3ª"itemValue="3ª"/> <f:selectItem itemLabel="4ª"itemValue="4ª"/> <f:selectItem itemLabel="5ª"itemValue="5ª"/> <f:selectItem itemLabel="6ª"itemValue="6ª"/> <f:selectItem itemLabel="Sab"itemValue="Sab"/> </p:selectOneMenu> </p:column> <p:column headerText="#{msg['planoEstagioHorario.primeiroTurnoInicio']}" width="60px"> <p:calendar id="primeiroTurnoInicio"value="#{horario.primeiroTurnoInicio}" pattern="HH:mm"timeOnly="true"locale="pt" converterMessage="#{msg['planoEstagioHorario.primeiroTurnoInicio.converter']}" required="true" requiredMessage="#{msg['planoEstagioHorario.primeiroTurnoInicio']}" styleClass="dataTimeDim"/> </p:column> <p:column headerText="#{msg['planoEstagioHorario.primeiroTurnoFim']}"> <p:calendar id="primeiroTurnoFim"value="#{horario.primeiroTurnoFim}" pattern="HH:mm"timeOnly="true"locale="pt" converterMessage="#{msg['planoEstagioHorario.primeiroTurnoFim.converter']}" required="true" requiredMessage="#{msg['planoEstagioHorario.primeiroTurnoFim.required']}" styleClass="dataTimeDim"/> </p:column> <p:column headerText="#{msg['planoEstagioHorario.segundoTurnoInicio']}"> <p:calendar id="segundoTurnoInicio"value="#{horario.segundoTurnoInicio}" pattern="HH:mm"timeOnly="true"locale="pt" converterMessage="#{msg['planoEstagioHorario.segundoTurnoInicio.converter']}" required="true" requiredMessage="#{msg['planohEstagioHorario.segundoTurnoInicio.required']}" styleClass="dataTimeDim"/> </p:column> <p:column headerText="#{msg['planoEstagioHorario.segundoTurnoFim']}"> <p:calendar id="segundoTurnoFim"value="#{horario.segundoTurnoFim}" pattern="HH:mm" timeOnly="true"locale="pt" converterMessage="#{msg['planoEstagioHorario.segundoTurnoFim.converter']}" required="true" requiredMessage="#{msg['planoEstagioHorario.segundoTurnoFim.required']}" styleClass="dataTimeDim"/> </p:column> <p:column width="15"> <p:commandButton actionListener="#{projetoController.remHorario(indice)}" process="tblHorarios"update="@this"immediate="true" rendered="#{indice >0}" title="#{msg['remover']}"icon="fa fa-trash" oncomplete="PF('dlgForm').initPosition();"/> </p:column> <f:facet name="footer"> <p:commandButton value="#{msg['planoEstagioHorario.inserir']}" icon="ui-icon-plus" action="#{projetoController.addHorario}"process="tblHorarios" update="tblHorarios" oncomplete="PF('dlgForm').initPosition();"/> </f:facet>
</p:dataTable>
5
</p:scrollPanel> </p:tab>
[...]
Listagem 4 - projeto.xhtml
Na Listagem 4 é apresentada a modificação realizada no arquivo projeto.xhtml. Todos
os componentes desta tela foram movidos para dentro de um “tabview”, componente do
Primefaces que apresenta a informação em guias. A guia que corresponde à informação de
estágio ficará desabilitada caso o usuário informe o tipo de projeto que não seja estágio, no
momento do cadastro.
Na guia referente aos dados do estágio, foi adicionado um “datatable”, componente do
Primefaces que lista informações em formato de tabela. Esse componente foi utilizado para
listar os horários em que o usuário efetuou o estágio. O “commandButton” é utilizado para
adicionar uma nova linha na tabela para o cadastro da informação de horários. O componente
“scrollPanel” apresenta barras de rolagem na guia de estágio para que o usuário tenha mais
facilidade ao acessar o cadastro, podendo rolar a página para que consiga visualizar todos os
componentes, sem precisar ajustar a visualização do modal.
Para listar as informações de tipo de validação e subtipo de estágio é necessário que
seja informado o tipo de estágio, o campo subtipo de estágio ficará habilitado apenas se o tipo
de estágio for obrigatório. Já o campo tipo de validação ficará habilitado se o tipo do estágio
for validação ou se o tipo do estágio for obrigatório e o subtipo for efetivo.
[...] <p:panelGrid id="pnlDadosProjeto"> <p:row> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.titulo']}"/> </p:column> <p:column> <h:outputText value="#{projetoController.instancia.titulo}"/> </p:column> </p:row>
<p:row> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.orientador']}"/> </p:column> <p:column> <h:outputText value="#{projetoController.instancia.orientador.usuario.nome}"/> </p:column> </p:row>
<p:row> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.curso']}"/> </p:column> <p:column>
5
<h:outputText value="#{projetoController.instancia.curso.nome}"/> </p:column> </p:row>
<p:row> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.tipoProjeto']}"/> </p:column> <p:column> <h:outputText value="#{projetoController.instancia.tipoProjeto.nome}"/> </p:column> </p:row>
<p:row disabled="#{projetoController.instancia.tipoProjeto.estagio == false}"> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.downloadPlano']}"/> </p:column> <p:column> <h:form> <p:link> <p:commandButton icon="fa fa-file"value="Download"ajax="false" onclick="PrimeFaces.monitorDownload(start, stop);"> <f:setPropertyActionListener target="#{projetoController.tipoRelatorio}" value="1"/> <p:fileDownload value="#{projetoController.arquivoRetorno}"/> </p:commandButton> </p:link> </h:form> </p:column> </p:row>
<p:row> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.ata']}"/> </p:column> <p:column> <h:form> <p:link> <p:commandButton icon="fa fa-file"value="Download Ata"ajax="false" onclick="PrimeFaces.monitorDownload(start, stop);"> <f:setPropertyActionListener target="#{projetoController.tipoRelatorio}" value="2"/> <p:fileDownload value="#{projetoController.arquivoRetorno}"/> </p:commandButton> </p:link> </h:form> </p:column> </p:row>
<p:row> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['projeto.relatoriofinal']}"/> </p:column> <p:column> <h:form> <h:panelGrid columns="2"> <p:commandLink value="#{projetoController.instancia.relatorioFinal.nomeArquivo}" ajax="false">
5
<p:fileDownload value="#{projetoController.instancia.relatorioFinal.arquivo}"/> </p:commandLink> <p:commandButton title="#{msg['comum.excluir']}"icon="fa fa-trash" actionListener="#{projetoController.excluirRelatorioFinal()}" update=":#{p:component('pnlDadosProjeto')}" rendered="#{projetoController.podeExcluirRelatorioFinal()}"> <p:confirm header="#{msg['comum.atencao']}"icon="fa fa-exclamation-triangle " message="#{msg['arquivo.excluir.confirmar']}"/> </p:commandButton> </h:panelGrid> </h:form> </p:column> </p:row>
<p:row rendered="#{sec:areAnyGranted('ROLE_ALUNO')}"> <p:column styleClass="ui-widget-header"> <h:outputText value="#{msg['alunoprojeto.suanota']}"/> </p:column> <p:column> <h:outputText value="#{projetoController.mediaDoAluno}"/> </p:column> </p:row>
<f:facet name="footer"> <p:row> <p:column colspan="2" rendered="#{projetoController.podePostarRelatorioFinal()}"> <div align="center"> <p:commandButton value="#{msg['projeto.relatoriofinal.inserir']}" icon="fa fa-upload"process="@this" actionListener="#{projetoController.prepararPostarRelatorioFinal}"/> </div> </p:column> </p:row> </f:facet> </p:panelGrid>
[...] Listagem 5 - projeto.xhtml
Na Listagem 5 são apresentadas as opções para realizar download os arquivos de ata e
de plano de estágio, gerados pelo sistema. Foi utilizado o componente “fileDownload”, do
Primefaces, que permite transmitir conteúdos binários. Para isso, é necessário que esse
componente seja anexado a um botão ou link para que ocorra o download dos arquivos. Além
disso, foi utilizado um componente que monitora o progresso do download do arquivo
possuindo duas funções: iniciar e parar.
Na Listagem 6 é apresentada a classe ProjetoController com as modificações
realizadas no método salvar.
@Override
public void salvar() { if (getInstancia().getTipoProjeto().getEstagio() == true ){
Integer ataNumero = getInstancia().getTipoProjeto().getAta() + 1;
6
planoEstagio.setNumAta(ataNumero); TipoProjeto tipoProjeto = new TipoProjeto();
tipoProjeto =
tipoProjetoRepository.findOne(getInstancia().getTipoProjeto().getId());
tipoProjeto.setAta(ataNumero);
planoEstagios.add(planoEstagio); getInstancia().setAlunos(alunosProjeto); getInstancia().setPlanoEstagios(planoEstagios); } else { getInstancia().setAlunos(alunosProjeto);
}
getInstancia().prePersist();
super.salvar();
}
Listagem 6 - ProjetoController.java
Na Listagem 6 é verificado se o tipo de projeto é estágio, se sim, o número de ata
cadastrado no tipo de projeto é incrementado e adicionado ao campo “numAta” do projeto.
Posteriormente é adicionado o objeto planoEstagio em um array da classe PlanoEstagio e, na
sequência, esse array e o de alunos são adicionados ao projeto para que sejam persistidos no
banco de dados.
Para retornar o plano de estágio e as atas foi criado o campo arquivoRetorno do tipo
StreamedContent para a geração do arquivo para download. Na Listagem 7 é apresentada essa
implementação naclasse ProjetoController.
public StreamedContent getArquivoRetorno() throws SQLException { FacesContext context = FacesContext.getCurrentInstance();
Projeto instancia =
getDomainRepository().findById(getInstancia().getId());
String nomeRelatorioJasper = ""; String nomeRelatorioSaida = "";
switch (this.tipoRelatorio) { case 1 : nomeRelatorioJasper = "TCC_PlanoEstagio"; nomeRelatorioSaida = "PlanoEstagio"; break; case 2 : if (instancia.getTipoProjeto().getEstagio() == false || instancia.getTipoProjeto().getEstagio() == null){ nomeRelatorioJasper = "TCC_Ata"; nomeRelatorioSaida = "Ata"; } else { nomeRelatorioJasper = "TCC_AtaEstagios"; nomeRelatorioSaida = "AtaEstagios";
}
break; default: break;
}
6
RelatorioUtil relatorioUtil = new RelatorioUtil(); HashMap parametrosRelatorio = new HashMap();
parametrosRelatorio.put("PROJETOID", getInstancia().getId());
try { this.arquivoRetorno = relatorioUtil.geraRelatorio(parametrosRelatorio,
nomeRelatorioJasper,
nomeRelatorioSaida, dataSource.getConnection()) } catch (UtilException e) { context.addMessage(null, new FacesMessage(e.getMessage()) ); return null; } catch (NullPointerException e) { context.addMessage(null, new FacesMessage("Não há dados para gerar o relatório")); return null;
}
return this.arquivoRetorno;
}
Listagem 7 - ProjetoController.java
Na Listagem 7, pode-se viaualizar que é retornada uma instância do projeto
selecionado para a geração dos arquivos. São criadas duas variáveis do tipo String, uma
contém a informação do título do relatório Jasper e a outra contém o título do arquivo de
retorno. Quando essa função é chamada na página “projeto.xhtml” é repassada uma variável
informando qual o tipo do relatório que deve ser gerado, caso o retorno dessa variável seja 1
será gerado o plano de estágio, caso seja 2 será gerada uma ata.
Na geração da ata é validado se o tipo de projeto é estágio, se sim, é retornada a ata
referente aos projetos de estágio, se não, é retornada a ata referente às monografias. Para gerar
o relatório, o sistema faz uso do método “gerarRelatorio”, contido na classe “RelatorioUtil”,
passando por parâmetro o código do projeto, o nome do relatório compilado, o nome do
arquivo de saída e um objeto de conexão com o banco. Em seguida, é gerado o relatório, caso
não tenha dados, uma mensagem é retornada ao usuário. Em caso de erro é retornado ao
usuário o erro encontrado.
Na Listagem 8 é apresentada a visão da avaliação do projeto pelo avaliador. <?xml version="1.0"encoding="UTF-8"?> <ui:composition xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:h="http://java.sun.com/jsf/html" xmlns:p="http://primefaces.org/ui" xmlns:f="http://java.sun.com/jsf/core" template="/resources/templates/base.xhtml"> <ui:define name="conteudo"> <p:panel header="#{msg['avaliacaopendente.listagem.descricao']}"styleClass="sem-borda"> <p:dataTable id="tblDados"var="data" value="#{avaliacaoController.lista}" resizableColumns="true" emptyMessage="#{msg['avaliacaopendente.listagem.tabela.vazia']}"
6
rows="10" rowsPerPageTemplate="10,15,20" paginatorPosition="bottom" paginator="true" paginatorTemplate="{FirstPageLink} {PreviousPageLink} {PageLinks} {NextPageLink} {LastPageLink} {RowsPerPageDropdown}"> <p:columns value="#{avaliacaoController.colunas}" var="coluna" headerText="#{msg[coluna.codDesc]}" sortBy="#{data[coluna.campoSort]}" width="#{coluna.largura}"> <h:outputText value="#{data[coluna.campo]}"/> </p:columns> <p:column headerText="#{msg['comum.acoes']}"width="75"> <p:commandButton title="#{msg['comum.avaliar']}" icon="fa fa-check" actionListener="#{avaliacaoController.avaliar(data.id)}" update=":#{p:component('dlgForm')}"/> </p:column> </p:dataTable>
<p:dialog id="dlgForm"widgetVar="dlgForm" header="#{msg[avaliacaoController.descricaoForm]}" modal="true"resizable="false" closable="false"appendTo="@(body)"> <h:form> <h:panelGrid columns="2"cellspacing="10"> <h:outputText value="#{msg['apresentacao.projeto']}"/> <h:outputText value="#{avaliacaoController.instancia.apresentacao.projeto.titulo}"/> <h:outputText value="#{msg['apresentacao.dataRealizacao']}"/> <h:outputText value="#{avaliacaoController.instancia.apresentacao.dataRealizacao}"> <f:convertDateTime pattern="dd/MM/yyyy"/> </h:outputText> <h:outputText value="#{msg['apresentacao.horaInicial']}"/> <h:outputText value="#{avaliacaoController.instancia.apresentacao.horaInicial}"/> <h:outputText value="#{msg['apresentacao.horaFinal']}"/> <h:outputText value="#{avaliacaoController.instancia.apresentacao.horaFinal}"/>
<h:panelGrid columns="2"style="margin-bottom:10px"cellpadding="5"> <p:outputLabel for="lancar"value="Lançar Nota:"/> <p:selectOneRadio id="lancar"value="#{avaliacaoController.lancNota}"> <f:selectItem itemLabel="Nota por Itens"itemValue="1"/> <f:selectItem itemLabel="Nota Geral"itemValue="2"/> <p:ajax event="change"process="@this"update="form @form"/> </p:selectOneRadio> </h:panelGrid> </h:panelGrid> </h:form>
<h:form id="form"> <p:outputPanel rendered="#{avaliacaoController.lancNota.equals('1')}"> <p:dataTable value="#{avaliacaoController.instancia.alunosAvaliados}" var="alunoAvaliado"style="width: 600px;"> <f:facet name="header"> <h:outputText value="Formulário de Avaliação"/> </f:facet>
6
<p:column headerText="#{msg['avaliacao.item']}"/> <p:column headerText="#{msg['avaliacao.peso']}"/> <p:column headerText="#{msg['avaliacao.nota']} *"/> <p:column headerText="#{msg['avaliacao.observacao']}"/> <p:subTable value="#{alunoAvaliado.avaliacoes}"var="avaliacao"> <f:facet name="header"> <h:outputText value="#{alunoAvaliado.alunoProjeto.aluno.usuario.nome}"/> </f:facet> <p:column headerText="#{msg['avaliacao.item']}"> <h:outputText value="#{avaliacao.item.item.nome}"/> </p:column> <p:column headerText="#{msg['avaliacao.peso']}"> <h:outputText value="#{avaliacao.peso}"/> </p:column> <p:column headerText="#{msg['avaliacao.nota']} *"> <p:inputText value="#{avaliacao.nota}"style="width: 90px;"/> </p:column> <p:column headerText="#{msg['avaliacao.observacao']}"> <p:inputText value="#{avaliacao.observacao}"style="width: 100px;"/> </p:column> </p:subTable> </p:dataTable> </p:outputPanel> <p:outputPanel rendered="#{avaliacaoController.lancNota == '2'}"> <p:dataTable value="#{avaliacaoController.instancia.alunosAvaliados}" var="alunoAvaliado"style="width: 700px;"> <f:facet name="header"> <h:outputText value="Formulário de Avaliação"/> </f:facet> <p:column headerText="#{msg['avaliacao.aluno']}"> <h:outputText value="#{alunoAvaliado.alunoProjeto.aluno.usuario.nome}"/> </p:column> <p:column headerText="#{msg['avaliacao.nota']} *"> <p:inputText value="#{alunoAvaliado.nota}"style="width: 90px;"/> </p:column> <p:column headerText="#{msg['avaliacao.observacao']}"> <p:inputText value="#{alunoAvaliado.observacao}"style="width: 100px;"/> </p:column> </p:dataTable> </p:outputPanel> <p:separator/> <p:commandButton value="#{msg['comum.salvar']}"icon="ui-icon-check" actionListener="#{avaliacaoController.salvar}" update=":#{p:component('tblDados')}"process="@form"> <p:resetInput target="@form"/> </p:commandButton> <p:spacer width="10"/> <p:commandButton value="#{msg['comum.cancelar']}"icon="ui-icon-close" actionListener="#{avaliacaoController.cancelar}" update=":#{p:component('tblDados')}"process="@this"> <p:resetInput target="@form"/> </p:commandButton> </h:form> </p:dialog> </p:panel> </ui:define> </ui:composition>
Listagem 8 - avaliacao.xhtml
A avaliação leva em consideração como o avaliador vai avaliar o projeto. Caso o
6
avaliador queira avaliar informando uma nota geral é renderezida uma tabela com as
informações de alunos, notas e observações a serem informadas. Caso ele queira informar a
nota por item, o sistema renderiza uma tabela com todos os itens de avaliação e seus
respectivos pesos, para cada aluno do projeto e, então, o usuário informa a nota e a
observação.
O modo como vai ser avaliado é definido pelo componente selectOneRadio, do
PrimeFaces, que guarda a informação em um campo String para repassar os dados para
validar o formulário.
Na Listagem 9 é apresentadoo método “notasValidas” da classe AvaliacaoController,
mostrando o ajuste feito para validar as notas lançadas na página “avaliacao.xhtml”.
private boolean notasValidas() { for (AlunoProjetoAvaliador alunoAvaliado : instancia.getAlunosAvaliados()) { if (lancNota == "1") { for (Avaliacao avaliacao : alunoAvaliado.getAvaliacoes()) { if (avaliacao.getNota() == null || avaliacao.getNota() <0 ||
avaliacao.getNota() >10) {
return false;
}
}
} else { if (alunoAvaliado.getNota() == null || alunoAvaliado.getNota() <0 ||
alunoAvaliado.getNota() >10) {
return false;
}
for (Avaliacao avaliacao : alunoAvaliado.getAvaliacoes()) {
avaliacao.setNota(alunoAvaliado.getNota());
avaliacao.setObservacao(alunoAvaliado.getObservacao());
}
}
}
return true;
}
Listagem 9 – AvaliacaoController
O método verifica se o lançamento da nota é geral (“lancNota” igual a 2) ou se o
lançamento da nota é por itens (“lancNota” igual a 1). Caso seja a opção geral, a nota e a
observação informadas são repassadasa todos os itens de avaliação.
6
5 CONCLUSÃO
O objetivo deste trabalho foi melhorar o sistema desenvolvido pelo egresso João
Guilherme Brasil Pichetti complementando a aplicação desenvolvida.
As melhorias realizadas visaram o controle por parte dos docentes, da instituição e dos
próprios alunos em relação a datas, materiais necessários para as entregas e, principalmente, a
publicação do relatório final para a análise das bancas de estágio.
A implementação foi desenvolvida na plataforma web, visando manter a estrutura
original, a facilidade de acesso e manutenção, utilizando recursos que a caracterizam como
uma RIA. Para esse desenvolvimento foram utilizadas diversas ferramentas e tecnologias.
Uma dessas tecnologias é o Spring Boot. Essa ferramenta facilita o desenvolvimento de
aplicações Java, pois sua configuração é feita por meio de classes Java e anotações e por ser
um dos frameworks mais utilizados, encontra-se muita documentação e exemplos de
utilização.
Outra ferramenta é o Primefaces, biblioteca que implementa a especificação do JSF. O
JSF busca unir as principais vantagens entre aplicações desktop e aplicações web, utilizando
componentes ricos, sem a necessidade da utilização de JavaScript e HTML. O Primefaces
possui uma aceitação muito boa pela comunidade e uma vasta documentação (que pode ser
encontrada, inclusive, na página oficial http://primefaces.org/), facilitando o desenvolvimento
e a solução de possíveis problemas, além de criar facilitadores para as futuras manutenções na
aplicação.
Uma desvantagem, que pode preocupar desenvolvedores de aplicações desktop, é o
uso de eventos, que os componentes realizam utilizando Ajax. Utilizar dois ou mais eventos
Ajax do mesmo componente pode resultar em uma ação inesperada, exemplo no projeto atual
é a criação de projetos com seu tipo estruturado para estágio, no qual o sistema renderiza toda
a página do cadastro do projeto para apresentação das informações de estágio. Esse é um
problema que ainda necessita de uma solução adequada, pois atualmente foi mantido o uso do
padrão disabled, mesmo este não sendo um padrão adequado para o uso na aplicação.
Como parte das melhorias implementadas na continuidade desse trabalho esta versão
atendeu o aviso das avaliações pendentes por meio de uma agenda na tela principal da
aplicação, mostrando as datas de defesas já realizadas e as próximas bancas dos docentes. A
versão também atendeu a geração de atas de forma automática, as avaliações por nota geral e
individual (por itens), o cadastro do próprio aluno na aplicação e o controle dos relatórios de
6
estágio. Além de gerar um relatório das bancas apresentadas por período, tipo de projeto e
curso e declaração para os professores participantes das bancas.
Como trabalhos futuros ressaltam-se a implementação de algumas funcionalidades
como o envio de e-mail para a banca e aluno, a geração da declaração de participação para os
alunos (trabalho) e o cadastro da proposta de TCC.
6
REFERÊNCIAS
BASHAM, Bryah. Use a cabeça! Servlets & JSP TM. Rio de Janeiro: Editora Alta Books, 2010.
BOZZON et al. Conceptual modeling and code generation for Rich Internet Applications. International Conference on Web Engineering (ICWE’06), 2006.
DEITEL, Paul J; DEITEL, Harvey M. Ajax, Rich Internet Applications e desenvolvimento web para programadores. São Paulo: Editora Pearson Prentice Hall, 2008.
DUHL J. Rich Internet Applications. IDC white papers, 2003.
JAVASERVER, JavaServer Faces.org, 2018. Disponível em: <http://www.javaserverfaces.org/>. Acesso em: 5 mai. 2018.
KURNIAWAM, Budi. Java para web com Servlets, JSP e EJB. Rio de Janeiro: Editora Ciência Moderna, 2002.
MACCARI, Emerson A; SAUAIA, Antonio Carlos A. Aderência de sistemas de informação na tomada de decisão: um estudo multicaso com jogos da empresa. Disponível em: <http://www.scielo.br/scielo.php?pid=S1807-7752006000300007&script=sci_arttext>. Acesso em: 1 abr. 2018.
ORACLE, JavaServer Faces technology, 2017a. Disponível em: < http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html>. Acesso em: 5 mai. 2018.
ORACLE, Mojarra JavaServer Faces, 2017b. Disponível em: <https://javaserverfaces.github.io>. Acesso em: 5 mai. 2018.
PRESSMAN, Roger S. Engenharia de software. Rio de Janeiro: Editora McGraw-Hill, 2002.
SPRING, Spring, 2018. Disponível em: < https://spring.io/>. Acesso em: 5 mai. 2018.
UTFPR, Universidade Tecnológica Federal do Paraná. 2018. Disponível em: <http://www.utfpr.edu.br/patobranco/estrutura-universitaria/diretorias/dirgrad/cursos/coagr/estagio-curricular-1>. Acesso em: 2 abr. 2018.
