UNIVERSIDADE REGIONAL DO NOROESTE DO
ESTADO DO RIO GRANDE DO SUL - UNIJUÍ
ROMILDO JUNIOR BESSEGATO
DISTRIBUIÇÃO DE SERVIÇOS DA ARQUITETURA AGROMOBILE
UTILIZANDO WEBSERVICES
Santa Rosa
2014
2
ROMILDO JUNIOR BESSEGATO
DISTRIBUIÇÃO DE SERVIÇOS DA ARQUITETURA AGROMOBILE
UTILIZANDO WEBSERVICES
Trabalho de Conclusão de Curso do Curso
de Ciência da Computação da Universidade
Regional do Noroeste do Estado do Rio
Grande do Sul.
Orientador: Dr. Gerson Battisti
Santa Rosa
2014
3
Dedico este trabalho aos meus familiares, que sempre estiveram ao
meu lado, me apoiando, me incentivando e ajudando em todos os
momentos e tanto contribuíram para minha formação. Dedico
também a minha esposa que foi amiga, conselheira e sempre me
encorajou a seguir em frente.
4
AGRADECIMENTOS
Primeiramente agradeço a Deus por estar sempre iluminando os meus
caminhos. Aos meus pais e irmãs, pelas palavras de incentivo e por estarem comigo
em todos os momentos.
Ao meu orientador Gerson Battisti por sempre estar à disposição para tirar
minhas dúvidas, pelo apoio durante o trabalho e por aprimorar os meus
conhecimentos com desenvolvimento de WebServices.
Agradeço aos meus colegas que estiveram comigo durante estes anos e
pelas amizades que conquistamos. Á todos os professores do curso de Ciência da
Computação, pelos conhecimentos sabiamente transmitidos e pelas informações
passadas que foram adquiridas através de suas experiências, especialmente ao
Vinicius Maran mentor do projeto AgroMobile.
5
RESUMO
A partir de um projeto em desenvolvimento na Universidade Regional do
Noroeste do Estado do Rio Grande do Sul (UNIJUI), o qual visa uma arquitetura de
software para auxílio na agricultura de precisão, a beneficiar pequenos e médios
produtores, a arquitetura AgroMobile baseia-se em diversos módulos desde o
sensoriamento, a modelagem do conhecimento, as interfaces para usuários e o
gerenciamento baseado em WebServices. Este trabalho objetiva desenvolver a
parte do gerenciamento, os quais farão a interligação entre todos os módulos a fim
de estabelecer o pleno funcionamento. Estas interligações são baseadas em
WebServices desenvolvidos em Java no padrão RESTful com o tráfego de dados
em JSON para se tornar uma interligação ágil e funcional.
Palavras chave: Agricultura de Precisão, WebServices, RESTful.
.
6
ABSTRACT
From a project under development at the Northwest Regional University of the
State of Rio Grande do Sul (UNIJUI), which targets a software architecture to aid in
precision agriculture, small and medium producers qualify, AgroMobile architecture is
based in several modules from the sensing, modeling of knowledge, the user
interfaces and management based on WebServices. This work aims to develop the
part of management, which will make the interconnection between all modules in
order to establish the full operation. These interconnections are based on
WebServices developed in Java on standard RESTful with JSON data traffic in order
to become an agile and functional interconnection.
Keywords: Precision Farming, WebServices, RESTful.
.
7
LISTA DE ABREVIATURAS E SIGLAS
API
Application Programming Interface
Embrapa
Empresa Brasileira de Pesquisa Agropecuária
GPS
Sistema de Posicionamento Global
HTML
HyperText Markup Language
HTTP
Hypertext Transfer Protocol
JSON
JavaScript Object Notation
PH
Potêncial Hidrogeniônico
REST
Representational State Transfer
RSSF
Rede de Sensores Sem Fio
SOAP
Simple Object Access Protocol
URL
Uniform Resource Locator
UTF-8
8-bit Unicode Transformation Format
XML
eXtensible Markup Language
8
LISTA DE FIGURAS
Figura 1 - A) Diagrama de um nó de rede de sensores; B) Protótipo do nó da RSSF.
.................................................................................................................................. 16
Figura 2 - Diagrama de Sequência do Coletor Definido ............................................ 17
Figura 3 - Invocação Arquitetura WebServices ......................................................... 21
Figura 4 - Exemplo de Arquivo XML .......................................................................... 23
Figura 5 - Exemplo de arquivo JSON ........................................................................ 24
Figura 6 - Diagrama Lógico da Modelagem da Informação ...................................... 26
Figura 7 - Arquitetura de software ............................................................................. 26
Figura 8 - Diagrama de Pacotes dos WebServices. .................................................. 28
Figura 9 - Classe ApplicationConfig .......................................................................... 29
Figura 10 - Métodos genéricos da classe AbstractFacade ........................................ 29
Figura 11 - Diagrama de Classes do Pacote Entidades ............................................ 30
Figura 12 - Classe Técnico do Pacote Entidades...................................................... 31
Figura 13 - Diagrama de Classes Pacote Recursos .................................................. 32
Figura 14 - Exemplo do Inicio da Classe Fachada. ................................................... 32
Figura 15 - Exemplo Método Create (POST) ............................................................ 33
Figura 16 - Exemplo Método Edit (PUT) ................................................................... 33
Figura 17 - Exemplo Método Remove (DELETE)...................................................... 34
Figura 18 - Exemplo Método Find (GET) .................................................................. 34
Figura 19 - Esquema do Protótipo............................................................................. 35
Figura 20 - Estrutura lógica da tabela leituras. .......................................................... 35
Figura 21 - Classe NewJerseyClient no Cliente. ....................................................... 36
Figura 22 - Método Mount no Cliente. ...................................................................... 36
Figura 23 - Retorno do Cliente ao Fazer POST no Recurso Leituras ....................... 37
Figura 24 - Consulta via HTTP GET no Recurso Leituras ......................................... 37
9
LISTA DE TABELAS
Tabela 1: Anotações e sua Funcionalidade .............................................................. 27
10
SUMÁRIO
INTRODUÇÃO ............................................................................................. 11
1
O PROJETO AGROMOBILE ................................................................. 13
1.1 Módulos da Arquitetura ....................................................................... 14
1.2 Sensoriamento ..................................................................................... 15
1.3 Representação do Conhecimento ...................................................... 17
2
WEBSERVICES ..................................................................................... 20
3
DISTRIBUIÇÃO DE SERVIÇOS DA ARQUITETURA AGROMOBILE
UTILIZANDO WEBSERVICES..................................................................... 25
3.1 Informações do Projeto AgroMobile com WebServices ................... 25
3.2 Desenvolvimento dos WebServices ................................................... 27
3.2.1 Pacote Config .................................................................................... 28
3.2.2 Pacote entidades ............................................................................... 30
3.2.3 Pacote Recursos................................................................................ 31
3.3 Protótipo para AgroMobile .................................................................. 34
CONCLUSÃO............................................................................................... 38
REFERÊNCIAS ............................................................................................ 39
APÊNDICE A – Classes do Pacote Config .................................................. 41
APÊNDICE B – Classes do Pacote Entidades ............................................. 44
APÊNDICE C – Classes do Pacote Recursos ............................................ 138
11
INTRODUÇÃO
A agricultura tem evoluído muito nos últimos anos, e com o avanço da
tecnologia há um foco especial de estudos na área da agricultura de precisão. Este é
um tema abrangente, pois não se limita a algumas culturas e nem a algumas
regiões. É um sistema (baseado em um conjunto de processos) de manejo integrado
de informações e tecnologias, fundamentado nos conceitos de que as variabilidades
de espaço e tempo influenciam diretamente nos rendimentos dos cultivos
(CAMPANHOLA, 2004).
A agricultura de precisão visa auxiliar o gerenciamento mais detalhado dos
sistemas de produção agrícola, não somente das aplicações de insumos ou de
mapeamentos diversos, mas de todos os processos envolvidos na produção.
Segundo a Empresa Brasileira de Pesquisa Agropecuária (Embrapa), um dos pontos
que convergem em excelência de resultados para a agricultura de precisão é a
Tecnologia da Informação.
Atualmente, existem vários sistemas que fornecem auxílio à agricultura de
precisão, porem há uma resistência dos produtores na utilização destes sistemas,
pois eles são feitos para especialistas da área, e não para leigos, além de seu custo
ser elevado, possibilitando acesso a poucos.
O projeto AgroMobile busca minimizar essa desigualdade através do
desenvolvimento de uma arquitetura que auxilia os assistentes técnicos como
técnicos agrícolas e engenheiros agrônomos, com a utilização de ferramentas de
fácil manuseio, sejam elas website ou softwares instalados em dispositivos móveis
com Sistema de Posicionamento Global (GPS) para a agricultura de precisão.
Desta forma, os mesmos terão um acompanhamento preciso nas áreas de
produção, para que seja detectada qualquer ameaça e/ou aplicada à correção
necessária em determinado ponto da lavoura, tornando assim um gerenciamento
preciso e com as dosagens certas para tal problema, gerando um melhor cultivo e
um aumento significativo na produção.
A dependência da automação para a agricultura de precisão segundo
Boemo:
A agricultura de precisão também necessita cada vez mais de
acesso a um grande número de dados o que é possível devido aos avanços
obtidos no processamento computacional (2011).
12
Buscando beneficiar o maior número de produtores, o projeto AgroMobile,
em desenvolvimento na Universidade Regional do Estado do Rio Grande do Sul
(Unijuí), tem como principal objetivo propor uma arquitetura de software onde
possam ser feitas recomendações aos produtores utilizando informações de
sensores e tecnologias da computação móvel e pervasiva (KIRSCHNER; MARAN,
2012).
Esta arquitetura é composta por diversos serviços. Estes serviços são
separados por funcionalidades, tais como: coleta de dados, engine, modelos de
dados, entre outros. Para que seja possível que estes serviços sejam interligados e
distribuídos (devido a quantidade de informação gerada e processada pela
arquitetura), é necessário que existam interfaces na forma de WebServices para os
serviços da arquitetura.
Sendo assim, como parte da arquitetura AgroMobile, o objetivo é utilizar os
conceitos e tecnologias da área de sistemas distribuídos, desenvolvimento Java
Web, padrão RESTful e definir um conjunto de interfaces WebServices com padrões
para a troca de mensagens, que possam se comunicar com as demais partes da
arquitetura AgroMobile, tais como: a interface Web ou o aplicativo Android utilizado
pelos usuários, o coletor responsável pelas informações dos sensores na lavoura e
também com a ontologia que modela o conhecimento do domínio de agricultura de
precisão. Com isso é formada uma camada de software capaz de gerenciar toda
essa arquitetura, visando seu total funcionamento, gerando as sugestões mais
apropriadas para a solicitação ou vir a alertar ao usuário por algum evento anormal
inesperado.
13
1 O PROJETO AGROMOBILE
O Projeto AgroMobile, a partir de estudos relacionados nas áreas de
Computação Móvel, Ubíqua e Aplicada na Agricultura de Precisão, tem como
objetivo o desenvolvimento de uma arquitetura de software, e com essas
ferramentas auxiliar engenheiros agrônomos na tomada de decisões mais precisas
quanto às dosagens certas de insumos, coleta de amostras, fornecendo também um
histórico para o melhor aproveitamento e melhor produção agrícola, informações
necessárias para se ter um bom gerenciamento dos negócios.
Com a mudança no padrão agrícola brasileiro, a agricultura não está mais
sendo vista como uma atividade primária isolada, sendo cada vez mais associada
aos setores industriais e comerciais. Países importadores de produtos primários
exigem uma variedade cada vez maior de critérios de qualidade antes de comprar
alimentos, causando grandes impactos na cadeia de produção de alimentos,
especialmente entre pequenos e médios agricultores, os quais são pouco integrados
a organizações ou circuitos de comercialização (ASSAD et al., 2004).
Buscando atender a esta demanda, com tecnologia de ponta e custo baixo,
o AgroMobile beneficia produtores de pequeno e médio porte que não possuem
recursos suficientes para adquirir sistemas proprietários encontrados hoje no
mercado. Através da utilização desta ferramenta, estes agricultores terão um melhor
controle e produção de suas lavouras, além de contribuir com a preservação do
meio ambiente, este sendo considerado por Assad et al. (2004) um dos principais
desafios da atividade agrícola.
Esta arquitetura tem como principal finalidade alertar e sugerir medidas
preventivas para os Engenheiros Agrônomos e Técnicos Agrícolas. De acordo com
as
informações do
ambiente
de
produção
(a
lavoura),
estes
receberão
recomendações do sistema quando qualquer anomalia for identificada, sugerindo
uma determinada ação a ser tomada para o problema. Assim, ele terá posse de
várias informações importantes, como umidade, variações de temperatura, Potencial
Hidrogeniônico (PH) do solo, entre outras.
A partir de sensores localizados nas lavouras o agricultor terá informações
precisas de sua área, ao passo que qualquer anomalia identificada possa gerar um
alerta e uma sugestão para tal problema a fim de minimizar o impacto na sua
14
produção. Essas informações serão disparadas para seu dispositivo móvel o qual
possuirá a aplicação desenvolvida ou ao utilizar o website.
Para isto, necessita-se de uma rede de sensores para uma informação
precisa e atualizada, da definição de uma ontologia a ser aplicada para embasar o
conhecimento e assim gerar as sugestões apropriadas, uma aplicação para
dispositivos móveis a fim de fazer a intermediação entre o hardware e o produtor ou
um website para acessar por qualquer plataforma, tudo isso para que ele possa ter o
controle e o ponto exato do evento alertado tomando assim sua decisão.
1.1 Módulos da Arquitetura
A arquitetura AgroMobile é dividida em 6 módulos, sendo eles: Rede de
Sensores; Coletores; Aplicativo de Interface para Dispositivos Móveis e WebSite;
Servidor de Serviços para a Arquitetura (Gerenciamento) e a Representação do
Conhecimento através de ontologias.
 Rede de Sensores: na rede de sensoriamento serão criados nós com
sensores utilizando a plataforma Arduino, os quais constantemente
estarão lendo informações em tempo real e enviando estes pacotes
de informações aos atuadores para que estes possam tratá-las e
verificar se existe algum fator de risco;
 Coletor: os coletores são responsáveis pelo recebimento e filtragem
das informações enviadas pelos nós de sensores, que posteriormente
serão enviadas para os WebServices. São desenvolvidos na
linguagem de programação Java e fisicamente estarão junto ao
ambiente de produção (na lavoura);
 Aplicativo Móvel: desenvolvido em Java para sistemas Android, este
aplicativo fará o auxilio e comunicação com o usuário (Engenheiros e
Técnicos), nele terá todas as informações que poderão vir a ser
consultadas de determinadas áreas mapeadas com o GPS e também
receberá os alertas e sugestões levantadas pela arquitetura;
15
 Interface WEB: tem as mesmas funcionalidades do aplicativo para
Android, sendo uma segunda opção para o usuário, a fim de poder
ser utilizada em qualquer plataforma e em qualquer dispositivo.
 Servidor de Serviços: os WebServices terão um papel fundamental
na arquitetura com um todo, pois eles que darão a possibilidade de
interligação
dos módulos.
Serão
desenvolvidas interfaces de
comunicação em Java utilizando a arquitetura RESTful com o tráfego
de dados no formato JavaScript Object Notation (JSON) que se
comunicará com os coletores, aplicativos móveis, interface Web e as
ontologias;
 Representação do Conhecimento: o conhecimento do domínio da
Agricultura de Precisão será desenvolvido através de uma ontologia,
a qual foi definida através da ferramenta Protége e modelada através
da linguagem OWL-DL (Aurélio et al., 2013).
1.2 Sensoriamento
O módulo de sensoriamento da arquitetura AgroMobile é formado por uma
rede de sensores específicos, destinados às suas funções que são manipuladas
através de um algoritmo de gerenciamento. Estes sensores enviam as leituras para
os coletores (softwares que filtram as informações dos sensores) que por sua vez se
comunicam como os servidores (MORGENSTERN et al., 2013).
Estes sensores são interligados por uma Rede de Sensores Sem Fio
(RSSF), a qual consegue fazer o compartilhamento de dados de cada nó e com que
cada sensor se comunique com o agregador de dados (coletor) enviando suas
informações.
Os sensores utilizados neste projeto são acoplados sob a plataforma
Arduino juntamente com diversos itens essenciais para seu funcionamento. Dentre
estes sensores existem o sensor de PH do solo, o sensor de umidade e temperatura
modelo DHT11, sensor de umidade modelo BSoil-01, módulo de GPS, placa de
fotovoltaica e o módulo transmissor e receptor de rádio frequência. A Figura 1
apresenta o diagrama de um nó da rede de sensores e o protótipo de um nó da
RSSF.
16
Figura 1 - A) Diagrama de um nó de rede de sensores; B) Protótipo do nó da RSSF.
A)
B)
Fonte: MORGENSTERN et al. (2013).
Os sensores numerados apresentados no diagrama de um nó de rede de
sensores, na Figura 2: parte A, possuem as seguintes funções:
1. Sensor de PH do Solo: faz a coleta de dados referente ao PH do solo;
2. Sensor de Umidade e Temperatura (DHT11): faz e medição da
temperatura, sendo que possui uma versão interna ao solo e outra
externa;
3. GPS: responsável pelo mapeamento e localização;
4. Sensor modelo BSoil-01: informa a quantidade de umidade do solo ao
seu redor;
5. Placa de Alimentação Solar: responsável por captar radiações solares
e convertê-las em energia para recarregar as baterias;
6. Módulo Transmissor e Receptor de Rádio Frequência: fazem a
comunicação entre os nós em uma determinada frequência a qual deve
ser diferenciada para o envio e recebimento.
A integração com o restante da arquitetura fica de responsabilidade do
coletor de dados o qual foi desenvolvido em Java e sua função é o recebimento dos
dados, envio de confirmação de recebimento dos mesmos, filtragem das
informações coletadas pelos sensores, fragmentação da mensagem, armazenando
17
em um banco de dados local para que o servidor os acesse quando necessitar. A
Figura 2 apresenta o fluxograma do agregador de dados.
Figura 2 - Diagrama de Sequência do Coletor Definido
Fonte: MORGENSTERN et al. (2013)
1.3 Representação do Conhecimento
O domínio de estudo deve ser representado de forma a auxiliar na
compreensão de cada aspecto do mesmo. Assim, as ontologias se aplicam de forma
a organizar as informações dos mais diferentes domínios, trazendo uma série de
vantagens no uso da representação do conhecimento (AURÉLIO et al., 2013). Uma
melhor definição de ontologia é dada por Gruber (1995), o qual afirma que uma
ontologia é uma especificação de uma conceituação, ou seja, uma descrição de
conceitos e relações que existem em um domínio de interesse.
Segundo Duarte et al. (2000), ontologias são úteis para apoiar a
especificação e implementação de qualquer sistema de computação complexo.
Dentre os propósitos para a construção de uma ontologia é possível destacar o
auxílio na compreensão de certa área de conhecimento e o auxílio na obtenção de
um consenso sobre determinado assunto.
Dentro do projeto AgroMobile está sendo desenvolvida uma ontologia
utilizando a ferramenta Protégé para fazer a modelagem semântica de informações
compreendidas no domínio da Agricultura de Precisão, através da linguagem
OWL-DL (Aurélio et al., 2013). A ontologia se encontra atualmente em fase de
18
especificação e aquisição de conhecimento. A sua modelagem está sendo realizada
seguindo a metodologia Methontology, a qual é considerada a mais popular para o
desenvolvimento de ontologias, o que torna o processo mais fácil e cria certo
padrão. A especificação da ontologia servirá como base para todo o resto da
modelagem, pois através da documentação utilizando de linguagem natural, é
possível captar o objetivo da ontologia e seus demais propósitos. Já o processo de
aquisição de conhecimento é marcado pela pesquisa às possíveis fontes
disponíveis, tais como entrevistas com especialistas no domínio, consulta a livros,
além de ontologias já existentes, entre outros.
Esta ontologia será utilizada como base para as etapas posteriores à
modelagem conceitual proposta, pois através dela serão modelados os serviços e
demais componentes do sistema de apoio à decisão.
Como cita o artigo de Aurélio et al. (2013), a metodologia utilizada para
iniciar o desenvolvimento da ontologia é baseada em conhecimentos adquiridos
através de estudos a outras ontologias já propostas na área de Agricultura de
Precisão. Para modelar o ambiente rural, foram extraídos dados do Manual de
Adubação e de Calagem para os estados do Rio Grande do Sul e Santa Catarina
(2004), além de informações sobre eventos, principalmente climáticos, que podem
interferir diretamente no domínio de agricultura de precisão.
A cultura inicialmente utilizada para a criação da ontologia é a soja, sendo
que a definição pode ser aplicada também em outras ontologias, para outras
culturas. Foram definidas algumas superclasses, as quais desencadeiam uma vasta
lista de subclasses que se relacionam ao representar os elementos do contexto, os
quais podem influenciar no projeto AgroMobile. Os principais elementos do contexto
são os seguintes:
 Áreas e Glebas (Area, Gleba): englobam as informações geográficas
da agricultura de precisão, através de conceitos como coordenadas e
referências geográficas.
 Clima (Weather): descreve possíveis eventos climáticos que podem
atuar sobre o ambiente na qual a arquitetura AgroMobile atua;
 Safra, Planejamento, Produtor e Técnicos (Harvest, Planning,
Producer, Technician): classes responsáveis pela organização
19
durante o ciclo da safra, desde o princípio até o final, com o auxílio de
técnicos e o envolvimento dos produtores;
 Grãos (Grain): definição da cultura a ser utilizada no plantio;
 Solo (Soil): composto por vários fatores determinantes, como
nutrientes, PH, entre outros que são indispensáveis durante as
análises para determinados fins;
 Critérios de Recomendações de Calagem e Adubagem (Criteria of
Recommendation
of
Liming
and
Composting):
são
geradas
recomendações para realização de determinados serviços, conforme
os critérios a serem analisados, de acordo com o que está
acontecendo ou aconteceu no ambiente;
 Serviço (Service): considerada uma das classes mais importantes pela
sua utilização, é nela que estão contidos os serviços a serem
realizados no domínio de Agricultura de Precisão através da
arquitetura AgroMobile.
As classes citadas contém atributos específicos e individuais que podem
armazenar tanto objetos concretos quanto abstratos, mas são os relacionamentos
que fazem a ligação entre as classes e dão clareza para identificar um ambiente
real.
Através das regras de inferência que serão definidas na ontologia, será
possível propor serviços específicos da agricultura de precisão para determinados
relacionamentos criados.
20
2 WEBSERVICES
Nos últimos anos a tecnologia WebServices vem despertando a atenção de
analistas e arquitetos de programação, pois modifica o modo de como os sistemas
são
desenvolvidos,
prometendo
excelentes
ganhos
como
produtividade,
portabilidade e independência.
Tendo como finalidade principal prover serviços, uma empresa pode
automatizar diversas áreas com serviços web, sem a necessidade de uma pessoa
física para intermediar a negociação. Podemos citar como exemplo uma empresa na
qual o seu cliente já tem em mãos os dados principais para fazer um pedido de
compras, como preço, descrição, código, entre outros. O mesmo pode acessar um
serviço web disponibilizado pela empresa e diretamente fazer seu pedido sem que
haja esta intermediação.
Com este intuito foi criado os WebServices, para construção de aplicações
automatizadas que nada mais são do que serviços disponibilizados na internet.
Porém, vale lembrar que a criação de interfaces gráficas para usuários não faz parte
deste conceito de WebServices, ficando a cargo de outro setor da programação.
Esta arquitetura pode ser definida como uma arquitetura de software que
relaciona os componentes de um sistema em um ambiente distribuído onde são
disponibilizados serviços que podem ser acessados dinamicamente através de uma
rede (AMORIM, 2004 apud SILVA, 2004). A tecnologia WebServices propõe a
exposição das transações e das regras de negócios por meio de protocolos que
podem ser acessados e entendidos por qualquer linguagem de programação, em
qualquer sistema operacional, rodando em qualquer dispositivo (COSTA, 2002 apud
SILVA, 2004).
Para Zavalik (2004) o objetivo dos WebServices é obter interoperabilidade
entre aplicações através do uso de padrões Web.
A utilização de WebService é uma das maneiras mais comuns de integrar
aplicações diferentes, possuindo diferentes tipos de arquiteturas para esta finalidade
podemos destacar o Simple Object Access Protocol (SOAP) e o Representational
State Transfer (REST) sendo este mais simples comparado com o anterior.
O SOAP (2003) é um protocolo que se destina à troca de informações
estruturadas em um ambiente distribuído e descentralizado. Definido no W3C é
21
baseado em eXtensible Markup Language (XML) e contém alguns elementos, tais
como:
 Envelope: Identifica o documento XML como uma mensagem SOAP e
é responsável por definir o conteúdo da mensagem;
 Header (opcional): Contém os dados do cabeçalho;
 Body: Contém as informações de chamada e de resposta ao servidor;
 Fault: Contém as informações dos erros ocorridos no envio da
mensagem. Esse elemento só aparece nas mensagens de resposta
do servidor.
Na Figura 3, podemos ver a representação gráfica deste protocolo,
mostrando a troca de mensagens entre o cliente (Client Wrapper) e o servidor
(Server Wrapper) que disponibilizam a transparência para as aplicações e seguindo
o protocolo SOAP sobre Hypertext Transfer Protocol (HTTP) só trafega XML.
Figura 3 - Invocação Arquitetura WebServices
Fonte: SUMRA (2003)
Já o termo REST (Representacional State Transfer), originou-se da
dissertação de doutorado de Roy Fielding, publicada em 2000.
Segundo Fielding (apud OLIVEIRA, 2009), REST é “um conjunto de
princípios arquiteturais que quando aplicadas como um todo enfatiza a
escalabilidade da interação entre componentes para reduzir a latência de interação,
garantir segurança e encapsular sistemas legados”.
Fielding classifica com os seguintes princípios seu termo REST:
22
 Cliente / Servidor;
 Apoiar sistemas de cache;
 Sistemas em camadas (suportar escalabilidade);
 Estado nulo (cada requisição de um cliente ao servidor deve conter
todas as informações necessárias para entender a requisição);
 Stateless (comunicação sem controle de estado);
 Sistema uniforme utilizando 4 métodos padronizados:
o GET – operação de leitura;
o PUT – relacionada e inserção ou alteração;
o POST – cria um objeto no servidor;
o DELETE – operação de remoção;
Conforme Tilkov (apud OLIVEIRA, 2009), o REST é “um conjunto de
princípios que definem como os padrões Web, como o HTTP e URIs devem ser
utilizados”. Tilkov conclui dizendo que “a principal promessa do REST é que se você
aderir aos princípios durante o projeto de sua aplicação, você irá acabar com um
sistema que explora a arquitetura Web em seu benefício”.
Neste modelo de arquitetura o que mais importa são as URLs do sistema e
os resources. Um recurso (resources) ou uma entidade é um objeto contendo
informações que será representada por meio de um XML ou JSON. Geralmente a
URL para acessar este recurso será a mesma, o que muda é o método HTTP (GET,
PUT, POST DELETE) o qual vai definir o resultado da requisição.
Para utilizar qualquer um dos padrões citados acima é necessário conhecer
as linguagens de marcação XML e JSON, pois o padrão de SOAP utiliza-se de
text/XML e a arquitetura REST de text/JSON.
A XML (eXtensible Markup Language) é uma linguagem de marcação para
propósitos especiais, usada para descrever e organizar dados para aplicações.
Diferentemente da Linguagem de Marcação de Hipertexto (HTML), suas etiquetas
não são pré-definidas. O desenvolvedor poderá criar suas próprias etiquetas (BRAY,
et al., 2008), capaz de descrever diversos tipos de dados, podendo ser utilizada para
formatação de textos, armazenamento em banco de dados, armazenamento de
propriedades de áudio e vídeo, imagens vetoriais, entre outros.
Como a XML segue um método hierárquico de formatação, ou seja, possui
tags-pai, tags-filho e assim por diante, está bem consolidada nas diversas
23
tecnologias que temos hoje as quais já diferenciam o que são tags do que é
conteúdo propriamente dito.
O cabeçalho e a tag-root é o conteúdo mínimo para ser considerado um
arquivo XML. O cabeçalho é onde se encontra a versão (Version) a qual implica no
modo de leitura dos interpretadores e juntamente temos o tipo de padrão de
caracteres utilizados em seu conteúdo (Encoding), sendo que o UTF-8 é o padrão
popular internacional e o ISO-8859-1 é o padrão nacional. A tag-root consiste em
uma tag que engloba todas as outras tags do arquivo e tem a função de especificar
onde é o começo e o fim deste XML.
Na Figura 4, podemos ver um exemplo de arquivo no formato XML, onde
“<população>” é a tag-root, aberta no inicio do arquivo e fechada no final com
“</população>” englobando todas as demais tags dentro dela.
Figura 4 - Exemplo de Arquivo XML
Fonte: Própria (2014)
Já a Notação de Objetos JavaScript (JSON) conforme Crockford (2006), é
um formato para representação textual de dados, em objetos. Suas principais
características vantajosas são os fatos de ser leve e simplificada. Baseada em
JavaScript, consegue descrever diferentes tipos de dados como por exemplo objetos
e arrays. Por consumir menos banda e ser mais intuitiva que XML torna-se ideal
para transferência de dados, sendo comum sua utilização em projetos de
WebServices baseados em RESTful.
Neste formato, diferentemente de XML o qual se trabalha com tags, usamos
uma coleção de pares constituídos por um nome e um valor respectivamente, ou
24
uma lista ordenada de valores (array), tornando assim este formato mais simples
para ler e escrever e muito mais ágil na transferência de dados.
Na Figura 5, temos um exemplo de arquivo no formato JSON, o qual possui
uma lista de dados chamado “MinhaLista” e dentro dela temos os dados de “nome” e
“fone”, que por sua vez são os objetos desta lista.
Figura 5 - Exemplo de arquivo JSON
Fonte: Própria (2014)
25
3 DISTRIBUIÇÃO DE SERVIÇOS DA ARQUITETURA AGROMOBILE
UTILIZANDO WEBSERVICES
Neste capitulo será apresentada a arquitetura AgroMobile, bem como o
objetivo principal deste trabalho que é o desenvolvimento de WebService para
interligação da mesma exemplificando o código-fonte do software. Também é
apresentado um protótipo do projeto para comprovar o pleno funcionamento na
utilização do WebService.
3.1 Informações do Projeto AgroMobile com WebServices
O projeto AgroMobile, a partir de estudos relacionados nas áreas de
Computação Móvel, Ubíqua e Aplicada na Agricultura de Precisão, tem como
objetivo o desenvolvimento de uma arquitetura de software, e com essas
ferramentas auxiliar engenheiros agrônomos e técnicos agrícolas na tomada de
decisões mais precisas para se ter um bom gerenciamento dos negócios, evitando
desperdícios de insumos e consequentemente minimizando o impacto ambiental.
Como parte desta arquitetura, este trabalho tem como principal objetivo criar
interfaces na forma de WebServices a fim de interligar os módulos da arquitetura
AgroMobile, visando prover serviços para que se possam gravar, excluir, alterar e
consultar as informações entre eles.
Estas interfaces baseiam-se na estrutura dos dados utilizados na arquitetura
do banco de dados. Para isto, a modelagem das informações no diagrama lógico
das tabelas do banco de dados (Figura 6) utilizado pelo sistema é fundamental para
que se tenha o sincronismo com os WebServices. O banco de dados relacional
utilizado pela Arquitetura AgroMobile foi o Postgres com a extensão PostGIS da qual
dá suporte a dados geo-referênciados e é de distribuição livre.
26
Figura 6 - Diagrama Lógico da Modelagem da Informação
Fonte: Própria (2014)
A arquitetura de software representada na Figura 7 resume o AgroMobile.
Nele contamos com uma rede de sensores distribuídos em nós que farão as coletas
dos dados na lavoura transmitindo-os ao coletor de dados, que por sua vez faz a
filtragem das informações e envia ao seu WebService para a persistência destes
dados no banco. As ontologias são a base de conhecimento modelada, elas fazem o
raciocínio dos dados obtidos dos sensores e dos informados pelos dispositivos
(App/Web). Possui duas formas de utilização do sistema, sendo uma baseada em
um aplicativo desenvolvido para Android e a outra forma via Web HTTP, onde
ambas terão sincronismo com os dados através dos WebServices.
Figura 7 - Arquitetura de software
Fonte: Própria (2014)
27
3.2 Desenvolvimento dos WebServices
O desenvolvimento dos WebServices destina-se a interligação entre os
módulos da arquitetura, fazendo o gerenciamento do fluxo das informações,
garantindo o pleno funcionamento do AgroMobile. O padrão REST, se baseia em
métodos padrões da HTTP Web como GET, PUT, POST e DELETE e tem como
foco principal explorar estes métodos com seus chamados recursos, que nada mais
são que os endereços das URLs a serem utilizados.
Para o desenvolvimento do WebService é necessário utilização de algumas
tecnologias, onde para mapeamento das tabelas do banco de dados foi utilizado o
framework Hibernate. Ele oferece todas as ferramentas para o serviço web estar em
plena comunicação com a base de dados (BAUER; KING, 2005). Também foi
utilizada a API Jersey que é open source e mantida pela Oracle e que possui as
especificações da Interface de Programação de Aplicativos (API) JAX-RS das quais
se baseiam em anotações. Estas anotações são feitas nas classes do projeto, como
por exemplo: @Path, @Get, @Put, @Post, @Delete, @Produces, @Consumes,
@PathParam entre outras, que servem para simplificar a necessidade extra de
configurações. Na Tabela 1, veremos a utilidade das principais anotações do nosso
projeto.
Tabela 1 - Anotações e sua Funcionalidade
ANOTAÇÃO
@GET
@PUT
@POST
@DELETE
@PATH
@PRODUCES
@CONSUMES
@STATELESS
@PERSISTENCECONTEXT
@OVERRIDE
@ENTITY
@TABLE
@XMLROOTELEMENT
FUNÇÃO
HTTP GET lista os recursos
HTTP PUT atualiza um recurso
HTTP POST adiciona um recurso
HTTP DELETE remove um recurso
Configura o caminho do recurso
Indica qual o tipo de conteúdo será produzido pelo método ao
devolver a requisição
Indica qual o tipo de arquivo que espera receber para trata-lo
Reconhece cada requisição como uma requisição nova
Local de armazenamento dos objetos (entidades) que estão
sendo manipuladas pelo EntityManager (responsável pelo
sincronismo com o banco de dados, gerenciando o ciclo de
vida da entidade)
Anotação de que o método é uma reescrita
Informa que a classe é uma tabela do banco de dados
Indica o nome da tabela do banco em questão
Mapeamento da classe para um elemento XML
28
@NAMEDQUERIES
@COLUMN
@NOTNULL
@SIZE
Especificação de uma consulta estática no banco de dados
Indica o nome da coluna da tabela em questão
Indica que o valor do objeto não pode ser nulo
Indica os limites de tamanho do elemento especificado
Fonte: Própria (2014)
Para rodar o WebService RESTful, necessita-se de um Web Container, do
qual utilizaremos o servidor de aplicação Java EE com o Glassfish, que por sua vez
já possui tal implementação.
Visando uma melhor organização, o desenvolvimento dos WebServices
REST em Java foram divididos em três pacotes conforme suas funções. Abaixo, a
Figura 8 ilustra o diagrama de pacotes do desenvolvimento.
Figura 8 - Diagrama de Pacotes dos WebServices.
Fonte: Própria (2014)
O WebService é composto pelo pacote config, entidades e recursos os quais
serão explanados nas próximas seções.
3.2.1 Pacote Config
As classes do pacote config são as classes padrões utilizadas por todos os
recursos do projeto. Neste pacote temos a classe ApplicationConfig que tem a
função de adicionar todos os recursos que possuímos e também definir parte da
URL com o ApplicationPath, que será utilizada para chamar os recursos. Esta classe
é ilustrada abaixo na Figura 9.
29
Figura 9 - Classe ApplicationConfig
Fonte: Própria (2014)
Neste mesmo pacote config também temos a classe AbstractFacade, ou
Fachada Abstrata, nela contém métodos genéricos do projeto como salvar, editar,
excluir e encontrar (Figura 10), os quais são relacionados a persistência dos dados.
Esta classe serve como modelo para as subclasses e não permite instanciá-la.
Figura 10 - Métodos genéricos da classe AbstractFacade
Fonte: Própria (2014)
30
3.2.2 Pacote entidades
No pacote entidades, estão às classes POJO (Plain Old Java Objects) as
quais possuem os getters, setters, anotações das características relacionadas às
tabelas do banco de dados (mapeamento) e métodos utilizados pelo Hibernate para
persistência. No diagrama de classes apresentado na Figura 11 são ilustradas as
classes que compõe este pacote.
Figura 11 - Diagrama de Classes do Pacote Entidades
Fonte: Própria (2014)
Estas classes, como mencionado anteriormente, possuem características
semelhantes, alterando de uma para outra apenas os nomes dos campos e os tipos
dos objetos conforme foram criadas as tabelas no banco de dados. Todas estas
classes iniciam com as anotações @Entity que as referenciam como uma entidade,
@Table que indica referente à qual tabela do banco de dados é a referida classe e
@XmlRootElement que indica que o mapeamento da classe ocorrerá em um
elemento XML. As anotações @NamedQueries são as possíveis consultas que
poderão ser realizadas para aquela entidade. Na sequência vem à classe principal
serializada com os atributos definidos e suas características, vindo a formar o
espelho da tabela do banco de dados e que será utilizada pelo framework Hibernate
em suas persistências. Na sequência, possuímos os getters e setters dos atributos
da classe para as manipulações dos referidos dados.
Como exemplo na Figura 12, temos o início da classe Tecnico do pacote
entidades que demonstra estas questões.
31
Figura 12 - Classe Técnico do Pacote Entidades.
Fonte: Própria (2014)
3.2.3 Pacote Recursos
Por fim o pacote recursos, hospedeiro das classes fachadas especificas de
cada recurso. Estas classes estendem a classe AbstractFacade que possuem os
métodos genéricos, e juntamente no parâmetro recebem a lista da classe entidade
(POJO) do recurso em questão. São nelas que possuímos o final do endereço da
URL que vimos na classe ApplicationConfig, o qual vamos utilizar o WebService e
destinar os dados a determinada entidade. É aqui que possuímos os métodos
padrões HTTP dos quais o REST faz uso, sendo que estes são desenvolvidos
igualmente para todas as classes contidas neste pacote, alterando apenas as
entidades a serem trabalhadas pela classe. No diagrama de classes apresentado na
Figura 13 são ilustradas as classes que compõe o pacote recursos.
32
Figura 13 - Diagrama de Classes Pacote Recursos
Fonte: Própria (2014)
Nestas classes contamos com alguns recursos específicos do tipo
anotações que serão abordados a seguir. Ao iniciarmos a classe fachada de um
recurso, a anotação @Stateless tem a função de reconhecer a cada requisição
como uma requisição nova, isto é uma característica do padrão REST, em seguida,
a anotação @Path é onde configura o caminho do recurso, no exemplo abaixo
(Figura 14) o caminho deste recurso ficaria “http://.../webresources/tecnico” sendo
que o “webresource” vem da classe ApplicationConfig que vimos anteriormente,
completando a URL com o “tecnico” do Path da classe TecnicoFacadeREST.
Figura 14 - Exemplo do Inicio da Classe Fachada.
Fonte: Própria (2014)
Em seguida, contamos com o método local create exemplificado abaixo na
Figura 15, que por ter a anotação @POST terá a função de incluir dados no banco.
Para isto, é preciso ter a anotação @Consumes especificando qual o tipo de
formatação de dados se espera receber, neste caso estamos trabalhando com
informações no formato JSON. Ao receber estes dados é povoada a entidade da
qual foi feita a requisição do recurso e por fim o método create da classe
AbstractFacade que foi estendida é invocado passando a entidade para persistência
destes dados no banco.
33
Figura 15 - Exemplo Método Create (POST)
Fonte: Própria (2014)
Já o outro método local chamado edit conforme abaixo exemplificado na
Figura 16, possui a anotação @PUT que tem como função a alteração de dados já
gravados no banco. Para isto é preciso da anotação no método @Path recebendo o
identificador do registro na tabela a ser alterada, juntamente com os dados alterados
no formato JSON através da anotação @Consumes. Igualmente no método anterior,
ao receber estas informações será povoada a entidade e invocado o método edit da
classe AbstractFacade para a persistência no banco.
Figura 16 - Exemplo Método Edit (PUT)
Fonte: Própria (2014)
Para fazer a exclusão de um registro do banco de dados é utilizado o
método local remove com a anotação @DELETE, que também recebe através do
@Path no método, o identificador do registro a ser eliminado na tabela do banco de
dados. Para tal execução, é invocado o método padrão remove da classe
AbstractFacade concatenado ao método find desta mesma classe que tem como
função encontrar na tabela especifica o identificador passado no parâmetro para
finalmente excluí-lo. Abaixo na Figura 17 tem-se o exemplo deste método de
remoção.
34
Figura 17 - Exemplo Método Remove (DELETE)
Fonte: Própria (2014)
Finalizando as classes do pacote recursos, contamos com o método local
find que atrelado à anotação @GET tem a função de retornar uma pesquisa feita
através do identificador do registro. Para isto, é necessária a anotação no método
@Path indicando que deverá receber o “id” a ser encontrado na tabela, e,
diferentemente dos demais métodos ao invés de consumir dados, este irá produzir
dados para o retorno da informação a quem a solicitou utilizando a anotação
@Produces indicando o formato do retorno, que neste caso também é JSON. Após
receber este identificador é invocado o método find da classe AbstractFacade que
fará a pesquisa e retornará os dados solicitados. O exemplo do método de pesquisa
consta na Figura 18.
Figura 18 - Exemplo Método Find (GET)
Fonte: Própria (2014)
3.3 Protótipo para AgroMobile
Nesta seção, é apresentado um protótipo desenvolvido em Java baseado
em RESTful com padrão de troca de dados JSON, utilizando banco de dados
Postgresql. O caso em questão corresponde ao envio de dados a partir de um
módulo Arduíno para o WebService, simulando dados coletados dos sensores e
gravando estes no banco de dados para que posteriormente sejam feitas possíveis
consultas ou alertas a serem enviados ao agricultor.
35
Devido ao foco do trabalho não ser a parte do banco de dados e nem do
cliente que irá consumir o WebService, será abordado somente as partes básicas
destes dois elementos para que se possa entender e provar o pleno funcionamento
do WebService. Abaixo na Figura 19, o esquema do protótipo em questão.
Figura 19 - Esquema do Protótipo
Fonte: Própria (2014)
A tabela do banco de dados para gerar este modelo chama-se “leituras”,
aonde serão armazenados dados dos sensores que serão enviados ao coletor que
posteriormente enviará as mesmas para o WebService, que fará a persistência dos
dados nesta tabela. Sua estrutura é mostrada na Figura 20.
Figura 20 - Estrutura lógica da tabela leituras.
Fonte: Própria (2014)
36
Em relação ao Cliente que consumirá o WebService, precisamos de uma
classe POJO com os atributos da tabela “leituras” para que possam ser criados os
objetos para enviar ao recurso desejado do WebService. Para o envio destes dados
é necessário uma classe aonde seja criado um Cliente, um recurso (caminho para
aonde enviar os dados), um método (create) para o qual se deseja enviar a
solicitação ao WebService (neste caso é um POST) e um método (close) que fecha
o Cliente após o envio dos dados. Na Figura 21, pode-se ver como ficou a classe
NewJerseyClient que executa estes procedimentos.
Figura 21 - Classe NewJerseyClient no Cliente.
Fonte: Própria (2014)
Estas duas classes descritas acima são chamadas pelo método mount
também no Cliente conforme ilustra na Figura 22, que tem a função de povoar a
classe POJO e chamar o método create da classe NewJerseyClient, afim de enviar
o arquivo no formato JSON ao WebService, e ao final fechar esta conexão do
Cliente.
Figura 22 - Método Mount no Cliente.
Fonte: Própria (2014)
37
Como podemos obsevar na Figura 23, os dados enviados pelo Cliente
através do Arduíno estão sendo gravados com sucesso no banco de dados ao
passarem pelo recurso do WebService. Neste caso, está sendo feito um POST no
recurso Leituras que foi definido no Path do WebService.
Figura 23 - Retorno do Cliente ao Fazer POST no Recurso Leituras
Fonte: Própria (2014)
Constatou-se ainda, que ao fazer uma requisição via HTTP pelo browser no
recurso criado (Figura 24), retorna a lista em formato JSON dos dados inseridos na
tabela Leituras do banco de dados. Esta solicitação caracteriza uma consulta na
requisição GET.
Figura 24 - Consulta via HTTP GET no Recurso Leituras
Fonte: Própria (2014)
Com os códigos e os resultados apresentados acima, demonstra-se o pleno
funcionamento no WebService Leituras, o qual tem a finalidade de receber os dados
enviados pelos sensores ao coletor e este encaminhar ao WebService que
designará ao método create para fazer a inserção destas informações na tabela
Leituras do banco de dados.
38
CONCLUSÃO
Uma das atividades mais importantes na agricultura de precisão é o
acompanhamento do desenvolvimento da cultura em tempo real e a correção dos
fatores deficientes no instante em que é diagnosticado. A tecnologia possui técnicas
que podem auxiliar na identificação dos fatores que afetam a variação da
produtividade em áreas distintas da lavoura. Estes fatores podem ser a infestação
de pragas que atacam a plantação, de ervas daninhas que concorrem com a planta,
entre outros.
A agricultura de precisão é a nova tendência do mercado agrícola. As
vantagens que podem obter com ela são inúmeras, colheitas mais produtivas, uma
menor poluição devido ao uso reduzido de insumos e consequentemente uma
grande economia. Ela tende a se tornar cada vez mais comum nas propriedades
rurais. As tecnologias hoje existentes já permitem que se tenha um grande
conhecimento das variabilidades encontradas entre as diferentes áreas da
propriedade, o que já proporciona a tomada de decisões com base em dados mais
precisos.
Este trabalho demonstrou o desenvolvimento de uma aplicação na
linguagem de programação Java, baseada em WebServices aonde segue-se
padrões pré-definidos do RESTful juntamente com algumas tecnologias embutidas
como o framework Hibernate, a API Jersey com anotações do JAX-RS, dos quais
pode-se tirar o máximo de proveito no desenvolvimento, segurança e rapidez da
informação a fim de gerenciar o tráfego dos dados e fazer a sincronização entre os
módulos da arquitetura AgroMobile.
O
padrão
RESTful
vem
confirmar
seu
ótimo
funcionamento
em
WebServices, tornando sua utilização ideal em projetos que necessitam de agilidade
e eficiência na interoperabilidade entre as partes. Por utilizar métodos padrões
HTTP, torna-se amplamente acoplada a qualquer tipo de desenvolvimento em
diferentes linguagens de programação explorando toda arquitetura Web em seu
benefício.
Diante disto, com os recursos de WebServices desenvolvidos neste trabalho
a Arquitetura AgroMobile torna-se totalmente interligada entre seus diversos
módulos, proporcionando a interoperabilidade entre eles.
39
REFERÊNCIAS
ASSAD, Maria Leonor Lopes; ALMEIDA, Jalcione. Agricultura e sustentabilidade. Contexto, Desafios
e Cenários. Artigo publicado Ciência & Ambiente, 2004.
AURÉLIO, Rafael; MORGENSTERN, Marcos; MARAN, Vinicius. UMA DEFINIÇÃO ONTOLÓGICA
DO DOMÍNIO DE AGRICULTURA DE PRECISÃO PARA A ARQUITETURA AGROMOBILE. Salão
do Conhecimento, 2013.
BAUER, Cristian; KING, Gavin. Java Persistence com Hibernate. Editora Ciência Moderna, 2005.
BOEMO, Daniel, Desenvolvimento de Sistemas de Geoprocessamento e tecnologia móvel
aplicados à agricultura de precisão. Santa Maria-RS, Abril 2011. Disponível em:
<http://cascavel.cpd.ufsm.br/tede/tde_busca/arquivo.php?codArquivo=3905>
Acessado em 09/10/2013.
BRAY, Tim. et al. E.Extensible MarkupLanguage (XML) 1.0 (Fifth Edition), 2008. Disponível em:
<http://www.w3.org/TR/REC-xml>, Acessado em 02/11/2013.
CAMPANHOLA, C. Novos significados e desafios. Brasília, DF: Embrapa Informação Tecnológica,
2004.
COMISSÃO DE QUÍMICA E FERTILIDADE DO SOLO. Manual de adubação e de calagem para os
estados do Rio Grande do Sul e Santa Catarina. SBCS/NRS. Porto Alegre, 2004.
CROCKFORD, Douglas. JavaScript Object Notation (JSON), Julho 2006. Diponível em
<http://www.ietf.org/rfc/rfc4627.txt?number=4627>, Acessado em 02/11/2013.
DUARTE, Katia C.; FALBO, Ricardo A. Uma ontologia de qualidade de software. In: Workshop de
Qualidade de Software, João Pessoa. 2000.
EMBRAPA. Rede Agricultura de Precisão (AP 2). O que é Agricultura de Precisão?. Disponível em:
<http://www.macroprograma1.cnptia.embrapa.br/redeap2/o-que-e-agricultura-de-precisao> Acessado
em 20/11/2013.
GRUBER, Thomas R. Toward principles for the design of ontologies used for knowledge sharing?.
International journal of human-computer studies,1995.
KIRSCHNER, S. F. ; MARAN, V. . Um Sistema de Auxílio à Coleta de Dados na Área de Agricultura
de Precisão Baseada em Aplicações Móveis. In: XX Seminário de Iniciação Científica - Salão do
Conhecimento 2012 - Unijuí, 2012, Ijuí.
MORGENSTERN, M. S. ; AURELIO, R. ; ALVES, R. ; MARAN, V. . Definição de uma Rede de
Sensores para a Arquitetura AgroMobile. In: XII Simpósio de Informática da UNIFRA (SIRC), 2013,
Santa Maria - RS. Anais do XII Simpósio de Informática da UNIFRA (SIRC), 2013.
OLIVEIRA, Leonardo Eloy. Estado da arte de banco de dados orientados a documento, 2009.
Monografia (Conclusão do Curso de Graduação em Ciências Tecnológicas)–Universidade de
Fortaleza –UNIFOR, Ceára, 2009.
SILVA, Grace Kelly de Castro; PEREIRA, Patrícia Maria; MAGALHÃES, Geovane. Disponibilização
de Serviços Baseados em Localização via Web Services. In: Simpósio Brasileiro de
GeoInformática, GeoInfo. 2004.
SOAP, 2003, “Simple Object Access Protocol” (27 de abril, 2007); Disponível em
<http://www.w3.org/TR/soap12 >. Acessado em 02/11/2013.
40
SUMRA, Rajesh. “Developing JAX-RPC-Based Web Services Using Axis and SOAP”, 2003.
Disponível em: <http://www.developer.com/open/article.php/2237251/Developing-JAXRPCndashBased-Web-Services-Using-Axis-and-SOAP.htm>, Acessado em 01/11/2013.
ZAVALIK, Claudimir. Integração de sistemas de informação através de web services. 2004.
Dissertação de Mestrado (Programa de Pós Graduação em Computação)–Universidade Federal do
Rio Grande do Sul. Porto Alegre, 2004.
41
APÊNDICE A – Classes do Pacote Config

Classe AbstractFacade.java
package config;
import java.util.List;
import javax.persistence.EntityManager;
public abstract class AbstractFacade<T> {
private Class<T> entityClass;
public AbstractFacade(Class<T> entityClass) {
this.entityClass = entityClass;
}
protected abstract EntityManager getEntityManager();
public void create(T entity) {
getEntityManager().persist(entity);
}
public void edit(T entity) {
getEntityManager().merge(entity);
}
public void remove(T entity) {
getEntityManager().remove(getEntityManager().merge(entity));
}
public T find(Object id) {
return getEntityManager().find(entityClass, id);
}
public List<T> findAll() {
javax.persistence.criteria.CriteriaQuery cq =
getEntityManager().getCriteriaBuilder().createQuery();
cq.select(cq.from(entityClass));
return getEntityManager().createQuery(cq).getResultList();
}
public List<T> findRange(int[] range) {
javax.persistence.criteria.CriteriaQuery cq =
getEntityManager().getCriteriaBuilder().createQuery();
cq.select(cq.from(entityClass));
42
javax.persistence.Query q = getEntityManager().createQuery(cq);
q.setMaxResults(range[1] - range[0] + 1);
q.setFirstResult(range[0]);
return q.getResultList();
}
public int count() {
javax.persistence.criteria.CriteriaQuery cq =
getEntityManager().getCriteriaBuilder().createQuery();
javax.persistence.criteria.Root<T> rt = cq.from(entityClass);
cq.select(getEntityManager().getCriteriaBuilder().count(rt));
javax.persistence.Query q = getEntityManager().createQuery(cq);
return ((Long) q.getSingleResult()).intValue();
}
}
43

Classe ApplicationConfig.java
package config;
import java.util.Set;
import javax.ws.rs.core.Application;
@javax.ws.rs.ApplicationPath("webresources")
public class ApplicationConfig extends Application {
@Override
public Set<Class<?>> getClasses() {
Set<Class<?>> resources = new java.util.HashSet<>();
addRestResourceClasses(resources);
return resources;
}
private void addRestResourceClasses(Set<Class<?>> resources) {
resources.add(recursos.AnoagricolaFacadeREST.class);
resources.add(recursos.CidadeFacadeREST.class);
resources.add(recursos.CultivaresFacadeREST.class);
resources.add(recursos.CulturaFacadeREST.class);
resources.add(recursos.EspeciemFacadeREST.class);
resources.add(recursos.EstadioFacadeREST.class);
resources.add(recursos.EventoscFacadeREST.class);
resources.add(recursos.GlebaFacadeREST.class);
resources.add(recursos.GlebasvinculadasFacadeREST.class);
resources.add(recursos.ItemplanjFacadeREST.class);
resources.add(recursos.LeiturasFacadeREST.class);
resources.add(recursos.MonitoramentoFacadeREST.class);
resources.add(recursos.PlanejamentoFacadeREST.class);
resources.add(recursos.PontoamostraFacadeREST.class);
resources.add(recursos.ProdutoFacadeREST.class);
resources.add(recursos.ProdutorFacadeREST.class);
resources.add(recursos.PropriedadeFacadeREST.class);
resources.add(recursos.SafraFacadeREST.class);
resources.add(recursos.TecnicoFacadeREST.class);
resources.add(recursos.VariedadesFacadeREST.class);
resources.add(recursos.VariedadesglebaFacadeREST.class);
}
}
44
APÊNDICE B – Classes do Pacote Entidades

Classe Anoagriola.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "anoagricola")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Anoagricola.findAll", query = "SELECT a FROM Anoagricola a"),
@NamedQuery(name = "Anoagricola.findByIdAnoagricola", query = "SELECT a FROM Anoagricola a WHERE a.idAnoagricola = :idAnoagricola"),
@NamedQuery(name = "Anoagricola.findByDescricao", query = "SELECT a FROM Anoagricola a WHERE a.descricao = :descricao"),
@NamedQuery(name = "Anoagricola.findByAnoinicial", query = "SELECT a FROM Anoagricola a WHERE a.anoinicial = :anoinicial"),
@NamedQuery(name = "Anoagricola.findByCondicao", query = "SELECT a FROM Anoagricola a WHERE a.condicao = :condicao"),
@NamedQuery(name = "Anoagricola.findByFlagSincronizacao", query = "SELECT a FROM Anoagricola a WHERE a.flagSincronizacao = :flagSincronizacao")})
public class Anoagricola implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_anoagricola")
private Integer idAnoagricola;
45
@Size(max = 25)
@Column(name = "descricao")
private String descricao;
@Size(max = 4)
@Column(name = "anoinicial")
private String anoinicial;
@Size(max = 1)
@Column(name = "condicao")
private String condicao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idAnoagricola")
private Collection<Safra> safraCollection;
public Anoagricola() {
}
public Anoagricola(Integer idAnoagricola) {
this.idAnoagricola = idAnoagricola;
}
public Integer getIdAnoagricola() {
return idAnoagricola;
}
public void setIdAnoagricola(Integer idAnoagricola) {
this.idAnoagricola = idAnoagricola;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getAnoinicial() {
return anoinicial;
46
}
public void setAnoinicial(String anoinicial) {
this.anoinicial = anoinicial;
}
public String getCondicao() {
return condicao;
}
public void setCondicao(String condicao) {
this.condicao = condicao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Safra> getSafraCollection() {
return safraCollection;
}
public void setSafraCollection(Collection<Safra> safraCollection) {
this.safraCollection = safraCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idAnoagricola != null ? idAnoagricola.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
47
if (!(object instanceof Anoagricola)) {
return false;
}
Anoagricola other = (Anoagricola) object;
if ((this.idAnoagricola == null && other.idAnoagricola != null) || (this.idAnoagricola != null &&
!this.idAnoagricola.equals(other.idAnoagricola))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Anoagricola[ idAnoagricola=" + idAnoagricola + " ]";
}
}

Classe Cidade.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
48
@Entity
@Table(name = "cidade")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Cidade.findAll", query = "SELECT c FROM Cidade c"),
@NamedQuery(name = "Cidade.findByIdCidade", query = "SELECT c FROM Cidade c WHERE c.idCidade = :idCidade"),
@NamedQuery(name = "Cidade.findByCidade", query = "SELECT c FROM Cidade c WHERE c.cidade = :cidade"),
@NamedQuery(name = "Cidade.findByFlagSincronizacao", query = "SELECT c FROM Cidade c WHERE c.flagSincronizacao = :flagSincronizacao"),
@NamedQuery(name = "Cidade.findByUf", query = "SELECT c FROM Cidade c WHERE c.uf = :uf")})
public class Cidade implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_cidade")
private Integer idCidade;
@Basic(optional = false)
@NotNull
@Size(min = 1, max = 40)
@Column(name = "cidade")
private String cidade;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@Size(max = 2)
@Column(name = "uf")
private String uf;
@OneToMany(mappedBy = "idCidade")
private Collection<Produtor> produtorCollection;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idCidade")
private Collection<Gleba> glebaCollection;
public Cidade() {
}
public Cidade(Integer idCidade) {
this.idCidade = idCidade;
}
public Cidade(Integer idCidade, String cidade) {
this.idCidade = idCidade;
49
this.cidade = cidade;
}
public Integer getIdCidade() {
return idCidade;
}
public void setIdCidade(Integer idCidade) {
this.idCidade = idCidade;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public String getUf() {
return uf;
}
public void setUf(String uf) {
this.uf = uf;
}
@XmlTransient
public Collection<Produtor> getProdutorCollection() {
return produtorCollection;
}
50
public void setProdutorCollection(Collection<Produtor> produtorCollection) {
this.produtorCollection = produtorCollection;
}
@XmlTransient
public Collection<Gleba> getGlebaCollection() {
return glebaCollection;
}
public void setGlebaCollection(Collection<Gleba> glebaCollection) {
this.glebaCollection = glebaCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idCidade != null ? idCidade.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Cidade)) {
return false;
}
Cidade other = (Cidade) object;
if ((this.idCidade == null && other.idCidade != null) || (this.idCidade != null &&
!this.idCidade.equals(other.idCidade))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Cidade[ idCidade=" + idCidade + " ]";
}
}
51

Classe Cultivares.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "cultivares")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Cultivares.findAll", query = "SELECT c FROM Cultivares c"),
@NamedQuery(name = "Cultivares.findByIdCultivares", query = "SELECT c FROM Cultivares c WHERE c.idCultivares = :idCultivares"),
@NamedQuery(name = "Cultivares.findByDatac", query = "SELECT c FROM Cultivares c WHERE c.datac = :datac"),
@NamedQuery(name = "Cultivares.findByObservacao", query = "SELECT c FROM Cultivares c WHERE c.observacao = :observacao"),
@NamedQuery(name = "Cultivares.findByPestimada", query = "SELECT c FROM Cultivares c WHERE c.pestimada = :pestimada"),
@NamedQuery(name = "Cultivares.findByEestimada", query = "SELECT c FROM Cultivares c WHERE c.eestimada = :eestimada"),
@NamedQuery(name = "Cultivares.findBySituacao", query = "SELECT c FROM Cultivares c WHERE c.situacao = :situacao"),
@NamedQuery(name = "Cultivares.findByFlagSincronizacao", query = "SELECT c FROM Cultivares c WHERE c.flagSincronizacao = :flagSincronizacao")})
public class Cultivares implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_cultivares")
private Integer idCultivares;
@Size(max = 10)
@Column(name = "datac")
52
private String datac;
@Size(max = 100)
@Column(name = "observacao")
private String observacao;
@Column(name = "pestimada")
private Integer pestimada;
@Column(name = "eestimada")
private Integer eestimada;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_variedadesgleba", referencedColumnName = "id_variedadesgleba")
@ManyToOne(optional = false)
private Variedadesgleba idVariedadesgleba;
@JoinColumn(name = "id_glebavinculada", referencedColumnName = "id_glebavinculada")
@ManyToOne(optional = false)
private Glebasvinculadas idGlebavinculada;
@JoinColumn(name = "id_estadio", referencedColumnName = "id_estadio")
@ManyToOne
private Estadio idEstadio;
@OneToMany(mappedBy = "idCultivares")
private Collection<Pontoamostra> pontoamostraCollection;
public Cultivares() {
}
public Cultivares(Integer idCultivares) {
this.idCultivares = idCultivares;
}
public Integer getIdCultivares() {
return idCultivares;
}
public void setIdCultivares(Integer idCultivares) {
this.idCultivares = idCultivares;
}
53
public String getDatac() {
return datac;
}
public void setDatac(String datac) {
this.datac = datac;
}
public String getObservacao() {
return observacao;
}
public void setObservacao(String observacao) {
this.observacao = observacao;
}
public Integer getPestimada() {
return pestimada;
}
public void setPestimada(Integer pestimada) {
this.pestimada = pestimada;
}
public Integer getEestimada() {
return eestimada;
}
public void setEestimada(Integer eestimada) {
this.eestimada = eestimada;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
54
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Variedadesgleba getIdVariedadesgleba() {
return idVariedadesgleba;
}
public void setIdVariedadesgleba(Variedadesgleba idVariedadesgleba) {
this.idVariedadesgleba = idVariedadesgleba;
}
public Glebasvinculadas getIdGlebavinculada() {
return idGlebavinculada;
}
public void setIdGlebavinculada(Glebasvinculadas idGlebavinculada) {
this.idGlebavinculada = idGlebavinculada;
}
public Estadio getIdEstadio() {
return idEstadio;
}
public void setIdEstadio(Estadio idEstadio) {
this.idEstadio = idEstadio;
}
@XmlTransient
public Collection<Pontoamostra> getPontoamostraCollection() {
return pontoamostraCollection;
}
public void setPontoamostraCollection(Collection<Pontoamostra> pontoamostraCollection) {
this.pontoamostraCollection = pontoamostraCollection;
55
}
@Override
public int hashCode() {
int hash = 0;
hash += (idCultivares != null ? idCultivares.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Cultivares)) {
return false;
}
Cultivares other = (Cultivares) object;
if ((this.idCultivares == null && other.idCultivares != null) || (this.idCultivares != null &&
!this.idCultivares.equals(other.idCultivares))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Cultivares[ idCultivares=" + idCultivares + " ]";
}
}

Classe Cultura.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
56
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "cultura")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Cultura.findAll", query = "SELECT c FROM Cultura c"),
@NamedQuery(name = "Cultura.findByIdCultura", query = "SELECT c FROM Cultura c WHERE c.idCultura = :idCultura"),
@NamedQuery(name = "Cultura.findByNome", query = "SELECT c FROM Cultura c WHERE c.nome = :nome"),
@NamedQuery(name = "Cultura.findByPoprec", query = "SELECT c FROM Cultura c WHERE c.poprec = :poprec"),
@NamedQuery(name = "Cultura.findByEpocaplant", query = "SELECT c FROM Cultura c WHERE c.epocaplant = :epocaplant"),
@NamedQuery(name = "Cultura.findByOrdimp", query = "SELECT c FROM Cultura c WHERE c.ordimp = :ordimp"),
@NamedQuery(name = "Cultura.findByFlagSincronizacao", query = "SELECT c FROM Cultura c WHERE c.flagSincronizacao = :flagSincronizacao")})
public class Cultura implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_cultura")
private Integer idCultura;
@Size(max = 40)
@Column(name = "nome")
private String nome;
@Column(name = "poprec")
private Integer poprec;
@Size(max = 1)
@Column(name = "epocaplant")
private String epocaplant;
@Column(name = "ordimp")
private Integer ordimp;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(mappedBy = "idCultura")
private Collection<Variedades> variedadesCollection;
57
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idCultura")
private Collection<Safra> safraCollection;
public Cultura() {
}
public Cultura(Integer idCultura) {
this.idCultura = idCultura;
}
public Integer getIdCultura() {
return idCultura;
}
public void setIdCultura(Integer idCultura) {
this.idCultura = idCultura;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public Integer getPoprec() {
return poprec;
}
public void setPoprec(Integer poprec) {
this.poprec = poprec;
}
public String getEpocaplant() {
return epocaplant;
}
public void setEpocaplant(String epocaplant) {
this.epocaplant = epocaplant;
58
}
public Integer getOrdimp() {
return ordimp;
}
public void setOrdimp(Integer ordimp) {
this.ordimp = ordimp;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Variedades> getVariedadesCollection() {
return variedadesCollection;
}
public void setVariedadesCollection(Collection<Variedades> variedadesCollection) {
this.variedadesCollection = variedadesCollection;
}
@XmlTransient
public Collection<Safra> getSafraCollection() {
return safraCollection;
}
public void setSafraCollection(Collection<Safra> safraCollection) {
this.safraCollection = safraCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idCultura != null ? idCultura.hashCode() : 0);
59
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Cultura)) {
return false;
}
Cultura other = (Cultura) object;
if ((this.idCultura == null && other.idCultura != null) || (this.idCultura != null &&
!this.idCultura.equals(other.idCultura))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Cultura[ idCultura=" + idCultura + " ]";
}
}

Classe Especiem.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
60
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "especiem")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Especiem.findAll", query = "SELECT e FROM Especiem e"),
@NamedQuery(name = "Especiem.findByIdEspeciem", query = "SELECT e FROM Especiem e WHERE e.idEspeciem = :idEspeciem"),
@NamedQuery(name = "Especiem.findByDescricao", query = "SELECT e FROM Especiem e WHERE e.descricao = :descricao"),
@NamedQuery(name = "Especiem.findByTipo", query = "SELECT e FROM Especiem e WHERE e.tipo = :tipo"),
@NamedQuery(name = "Especiem.findByFlagSincronizacao", query = "SELECT e FROM Especiem e WHERE e.flagSincronizacao = :flagSincronizacao")})
public class Especiem implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_especiem")
private Integer idEspeciem;
@Size(max = 40)
@Column(name = "descricao")
private String descricao;
@Size(max = 1)
@Column(name = "tipo")
private String tipo;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(mappedBy = "idEspeciem")
private Collection<Monitoramento> monitoramentoCollection;
public Especiem() {
}
public Especiem(Integer idEspeciem) {
this.idEspeciem = idEspeciem;
}
public Integer getIdEspeciem() {
return idEspeciem;
}
61
public void setIdEspeciem(Integer idEspeciem) {
this.idEspeciem = idEspeciem;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
this.tipo = tipo;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Monitoramento> getMonitoramentoCollection() {
return monitoramentoCollection;
}
public void setMonitoramentoCollection(Collection<Monitoramento> monitoramentoCollection)
{
this.monitoramentoCollection = monitoramentoCollection;
}
@Override
public int hashCode() {
62
int hash = 0;
hash += (idEspeciem != null ? idEspeciem.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Especiem)) {
return false;
}
Especiem other = (Especiem) object;
if ((this.idEspeciem == null && other.idEspeciem != null) || (this.idEspeciem != null &&
!this.idEspeciem.equals(other.idEspeciem))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Especiem[ idEspeciem=" + idEspeciem + " ]";
}
}

Classe Estadio.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
63
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "estadio")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Estadio.findAll", query = "SELECT e FROM Estadio e"),
@NamedQuery(name = "Estadio.findByIdEstadio", query = "SELECT e FROM Estadio e WHERE e.idEstadio = :idEstadio"),
@NamedQuery(name = "Estadio.findByNomeEsstadio", query = "SELECT e FROM Estadio e WHERE e.nomeEsstadio = :nomeEsstadio"),
@NamedQuery(name = "Estadio.findByDescricao", query = "SELECT e FROM Estadio e WHERE e.descricao = :descricao"),
@NamedQuery(name = "Estadio.findByFlagSincronizacao", query = "SELECT e FROM Estadio e WHERE e.flagSincronizacao = :flagSincronizacao")})
public class Estadio implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_estadio")
private Integer idEstadio;
@Size(max = 40)
@Column(name = "nome_esstadio")
private String nomeEsstadio;
@Size(max = 100)
@Column(name = "descricao")
private String descricao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(mappedBy = "idEstadio")
private Collection<Monitoramento> monitoramentoCollection;
@OneToMany(mappedBy = "idEstadio")
private Collection<Cultivares> cultivaresCollection;
@OneToMany(mappedBy = "idEstadio")
private Collection<Eventosc> eventoscCollection;
public Estadio() {
}
public Estadio(Integer idEstadio) {
this.idEstadio = idEstadio;
64
}
public Integer getIdEstadio() {
return idEstadio;
}
public void setIdEstadio(Integer idEstadio) {
this.idEstadio = idEstadio;
}
public String getNomeEsstadio() {
return nomeEsstadio;
}
public void setNomeEsstadio(String nomeEsstadio) {
this.nomeEsstadio = nomeEsstadio;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Monitoramento> getMonitoramentoCollection() {
return monitoramentoCollection;
}
65
public void setMonitoramentoCollection(Collection<Monitoramento> monitoramentoCollection)
{
this.monitoramentoCollection = monitoramentoCollection;
}
@XmlTransient
public Collection<Cultivares> getCultivaresCollection() {
return cultivaresCollection;
}
public void setCultivaresCollection(Collection<Cultivares> cultivaresCollection) {
this.cultivaresCollection = cultivaresCollection;
}
@XmlTransient
public Collection<Eventosc> getEventoscCollection() {
return eventoscCollection;
}
public void setEventoscCollection(Collection<Eventosc> eventoscCollection) {
this.eventoscCollection = eventoscCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idEstadio != null ? idEstadio.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Estadio)) {
return false;
}
Estadio other = (Estadio) object;
if ((this.idEstadio == null && other.idEstadio != null) || (this.idEstadio != null &&
!this.idEstadio.equals(other.idEstadio))) {
return false;
}
66
return true;
}
@Override
public String toString() {
return "entidades.Estadio[ idEstadio=" + idEstadio + " ]";
}
}

Classe Eventosc.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "eventosc")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Eventosc.findAll", query = "SELECT e FROM Eventosc e"),
@NamedQuery(name = "Eventosc.findByIdEventosc", query = "SELECT e FROM Eventosc e WHERE e.idEventosc = :idEventosc"),
@NamedQuery(name = "Eventosc.findByDatae", query = "SELECT e FROM Eventosc e WHERE e.datae = :datae"),
@NamedQuery(name = "Eventosc.findByTipo", query = "SELECT e FROM Eventosc e WHERE e.tipo = :tipo"),
@NamedQuery(name = "Eventosc.findByPrecipitacao", query = "SELECT e FROM Eventosc e WHERE e.precipitacao = :precipitacao"),
@NamedQuery(name = "Eventosc.findByEstperda", query = "SELECT e FROM Eventosc e WHERE e.estperda = :estperda"),
67
@NamedQuery(name = "Eventosc.findByObservacao", query = "SELECT e FROM Eventosc e WHERE e.observacao = :observacao"),
@NamedQuery(name = "Eventosc.findBySituacao", query = "SELECT e FROM Eventosc e WHERE e.situacao = :situacao"),
@NamedQuery(name = "Eventosc.findByFlagSincronizacao", query = "SELECT e FROM Eventosc e WHERE e.flagSincronizacao = :flagSincronizacao")})
public class Eventosc implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_eventosc")
private Integer idEventosc;
@Size(max = 10)
@Column(name = "datae")
private String datae;
@Size(max = 15)
@Column(name = "tipo")
private String tipo;
@Size(max = 4)
@Column(name = "precipitacao")
private String precipitacao;
@Column(name = "estperda")
private Integer estperda;
@Size(max = 100)
@Column(name = "observacao")
private String observacao;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(mappedBy = "idEventosc")
private Collection<Pontoamostra> pontoamostraCollection;
@JoinColumn(name = "id_glebavinculada", referencedColumnName = "id_glebavinculada")
@ManyToOne(optional = false)
private Glebasvinculadas idGlebavinculada;
@JoinColumn(name = "id_estadio", referencedColumnName = "id_estadio")
@ManyToOne
private Estadio idEstadio;
public Eventosc() {
}
68
public Eventosc(Integer idEventosc) {
this.idEventosc = idEventosc;
}
public Integer getIdEventosc() {
return idEventosc;
}
public void setIdEventosc(Integer idEventosc) {
this.idEventosc = idEventosc;
}
public String getDatae() {
return datae;
}
public void setDatae(String datae) {
this.datae = datae;
}
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
this.tipo = tipo;
}
public String getPrecipitacao() {
return precipitacao;
}
public void setPrecipitacao(String precipitacao) {
this.precipitacao = precipitacao;
}
public Integer getEstperda() {
return estperda;
}
69
public void setEstperda(Integer estperda) {
this.estperda = estperda;
}
public String getObservacao() {
return observacao;
}
public void setObservacao(String observacao) {
this.observacao = observacao;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Pontoamostra> getPontoamostraCollection() {
return pontoamostraCollection;
}
public void setPontoamostraCollection(Collection<Pontoamostra> pontoamostraCollection) {
this.pontoamostraCollection = pontoamostraCollection;
}
public Glebasvinculadas getIdGlebavinculada() {
return idGlebavinculada;
70
}
public void setIdGlebavinculada(Glebasvinculadas idGlebavinculada) {
this.idGlebavinculada = idGlebavinculada;
}
public Estadio getIdEstadio() {
return idEstadio;
}
public void setIdEstadio(Estadio idEstadio) {
this.idEstadio = idEstadio;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idEventosc != null ? idEventosc.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Eventosc)) {
return false;
}
Eventosc other = (Eventosc) object;
if ((this.idEventosc == null && other.idEventosc != null) || (this.idEventosc != null &&
!this.idEventosc.equals(other.idEventosc))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Eventosc[ idEventosc=" + idEventosc + " ]";
}
}
71

Classe Gleba.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "gleba")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Gleba.findAll", query = "SELECT g FROM Gleba g"),
@NamedQuery(name = "Gleba.findByIdGleba", query = "SELECT g FROM Gleba g WHERE g.idGleba = :idGleba"),
@NamedQuery(name = "Gleba.findByNomeGleba", query = "SELECT g FROM Gleba g WHERE g.nomeGleba = :nomeGleba"),
@NamedQuery(name = "Gleba.findByAreaPropria", query = "SELECT g FROM Gleba g WHERE g.areaPropria = :areaPropria"),
@NamedQuery(name = "Gleba.findByAreaArrendada", query = "SELECT g FROM Gleba g WHERE g.areaArrendada = :areaArrendada"),
@NamedQuery(name = "Gleba.findByValorArrend", query = "SELECT g FROM Gleba g WHERE g.valorArrend = :valorArrend"),
@NamedQuery(name = "Gleba.findByPrazoArrend", query = "SELECT g FROM Gleba g WHERE g.prazoArrend = :prazoArrend"),
@NamedQuery(name = "Gleba.findByCordendasGps", query = "SELECT g FROM Gleba g WHERE g.cordendasGps = :cordendasGps"),
@NamedQuery(name = "Gleba.findByPontosGps", query = "SELECT g FROM Gleba g WHERE g.pontosGps = :pontosGps"),
@NamedQuery(name = "Gleba.findByFlagSincronizacao", query = "SELECT g FROM Gleba g WHERE g.flagSincronizacao = :flagSincronizacao")})
public class Gleba implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_gleba")
private Integer idGleba;
72
@Size(max = 40)
@Column(name = "nome_gleba")
private String nomeGleba;
@Size(max = 40)
@Column(name = "area_propria")
private String areaPropria;
@Size(max = 40)
@Column(name = "area_arrendada")
private String areaArrendada;
@Size(max = 40)
@Column(name = "valor_arrend")
private String valorArrend;
@Size(max = 40)
@Column(name = "prazo_arrend")
private String prazoArrend;
@Size(max = 200)
@Column(name = "cordendas_gps")
private String cordendasGps;
@Size(max = 200)
@Column(name = "pontos_gps")
private String pontosGps;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_propriedade", referencedColumnName = "id_propriedade")
@ManyToOne(optional = false)
private Propriedade idPropriedade;
@JoinColumn(name = "id_cidade", referencedColumnName = "id_cidade")
@ManyToOne(optional = false)
private Cidade idCidade;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idGleba")
private Collection<Glebasvinculadas> glebasvinculadasCollection;
public Gleba() {
}
public Gleba(Integer idGleba) {
this.idGleba = idGleba;
}
73
public Integer getIdGleba() {
return idGleba;
}
public void setIdGleba(Integer idGleba) {
this.idGleba = idGleba;
}
public String getNomeGleba() {
return nomeGleba;
}
public void setNomeGleba(String nomeGleba) {
this.nomeGleba = nomeGleba;
}
public String getAreaPropria() {
return areaPropria;
}
public void setAreaPropria(String areaPropria) {
this.areaPropria = areaPropria;
}
public String getAreaArrendada() {
return areaArrendada;
}
public void setAreaArrendada(String areaArrendada) {
this.areaArrendada = areaArrendada;
}
public String getValorArrend() {
return valorArrend;
}
public void setValorArrend(String valorArrend) {
this.valorArrend = valorArrend;
}
74
public String getPrazoArrend() {
return prazoArrend;
}
public void setPrazoArrend(String prazoArrend) {
this.prazoArrend = prazoArrend;
}
public String getCordendasGps() {
return cordendasGps;
}
public void setCordendasGps(String cordendasGps) {
this.cordendasGps = cordendasGps;
}
public String getPontosGps() {
return pontosGps;
}
public void setPontosGps(String pontosGps) {
this.pontosGps = pontosGps;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Propriedade getIdPropriedade() {
return idPropriedade;
}
public void setIdPropriedade(Propriedade idPropriedade) {
this.idPropriedade = idPropriedade;
}
75
public Cidade getIdCidade() {
return idCidade;
}
public void setIdCidade(Cidade idCidade) {
this.idCidade = idCidade;
}
@XmlTransient
public Collection<Glebasvinculadas> getGlebasvinculadasCollection() {
return glebasvinculadasCollection;
}
public void setGlebasvinculadasCollection(Collection<Glebasvinculadas>
glebasvinculadasCollection) {
this.glebasvinculadasCollection = glebasvinculadasCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idGleba != null ? idGleba.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Gleba)) {
return false;
}
Gleba other = (Gleba) object;
if ((this.idGleba == null && other.idGleba != null) || (this.idGleba != null &&
!this.idGleba.equals(other.idGleba))) {
return false;
}
return true;
}
@Override
public String toString() {
76
return "entidades.Gleba[ idGleba=" + idGleba + " ]";
}
}

Classe Glebasvinculadas.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "glebasvinculadas")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Glebasvinculadas.findAll", query = "SELECT g FROM Glebasvinculadas g"),
@NamedQuery(name = "Glebasvinculadas.findByIdGlebavinculada", query = "SELECT g FROM Glebasvinculadas g WHERE g.idGlebavinculada =
:idGlebavinculada"),
@NamedQuery(name = "Glebasvinculadas.findByAreaCultivo", query = "SELECT g FROM Glebasvinculadas g WHERE g.areaCultivo = :areaCultivo"),
@NamedQuery(name = "Glebasvinculadas.findByFlagSincronizacao", query = "SELECT g FROM Glebasvinculadas g WHERE g.flagSincronizacao =
:flagSincronizacao")})
public class Glebasvinculadas implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
77
@Basic(optional = false)
@Column(name = "id_glebavinculada")
private Integer idGlebavinculada;
@Column(name = "area_cultivo")
private Integer areaCultivo;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idGlebavinculada")
private Collection<Monitoramento> monitoramentoCollection;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idGlebavinculada")
private Collection<Cultivares> cultivaresCollection;
@JoinColumn(name = "id_planejamento", referencedColumnName = "id_planejamento")
@ManyToOne(optional = false)
private Planejamento idPlanejamento;
@JoinColumn(name = "id_gleba", referencedColumnName = "id_gleba")
@ManyToOne(optional = false)
private Gleba idGleba;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idGlebavinculada")
private Collection<Eventosc> eventoscCollection;
public Glebasvinculadas() {
}
public Glebasvinculadas(Integer idGlebavinculada) {
this.idGlebavinculada = idGlebavinculada;
}
public Integer getIdGlebavinculada() {
return idGlebavinculada;
}
public void setIdGlebavinculada(Integer idGlebavinculada) {
this.idGlebavinculada = idGlebavinculada;
}
public Integer getAreaCultivo() {
return areaCultivo;
}
78
public void setAreaCultivo(Integer areaCultivo) {
this.areaCultivo = areaCultivo;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Monitoramento> getMonitoramentoCollection() {
return monitoramentoCollection;
}
public void setMonitoramentoCollection(Collection<Monitoramento> monitoramentoCollection)
{
this.monitoramentoCollection = monitoramentoCollection;
}
@XmlTransient
public Collection<Cultivares> getCultivaresCollection() {
return cultivaresCollection;
}
public void setCultivaresCollection(Collection<Cultivares> cultivaresCollection) {
this.cultivaresCollection = cultivaresCollection;
}
public Planejamento getIdPlanejamento() {
return idPlanejamento;
}
public void setIdPlanejamento(Planejamento idPlanejamento) {
this.idPlanejamento = idPlanejamento;
}
public Gleba getIdGleba() {
79
return idGleba;
}
public void setIdGleba(Gleba idGleba) {
this.idGleba = idGleba;
}
@XmlTransient
public Collection<Eventosc> getEventoscCollection() {
return eventoscCollection;
}
public void setEventoscCollection(Collection<Eventosc> eventoscCollection) {
this.eventoscCollection = eventoscCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idGlebavinculada != null ? idGlebavinculada.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Glebasvinculadas)) {
return false;
}
Glebasvinculadas other = (Glebasvinculadas) object;
if ((this.idGlebavinculada == null && other.idGlebavinculada != null) || (this.idGlebavinculada
!= null && !this.idGlebavinculada.equals(other.idGlebavinculada))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Glebasvinculadas[ idGlebavinculada=" + idGlebavinculada + " ]";
}}
80

Classe Itemplanj.java
package entidades;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "itemplanj")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Itemplanj.findAll", query = "SELECT i FROM Itemplanj i"),
@NamedQuery(name = "Itemplanj.findByIdItemplanj", query = "SELECT i FROM Itemplanj i WHERE i.idItemplanj = :idItemplanj"),
@NamedQuery(name = "Itemplanj.findByCategoria", query = "SELECT i FROM Itemplanj i WHERE i.categoria = :categoria"),
@NamedQuery(name = "Itemplanj.findByTipo", query = "SELECT i FROM Itemplanj i WHERE i.tipo = :tipo"),
@NamedQuery(name = "Itemplanj.findByDtaplic", query = "SELECT i FROM Itemplanj i WHERE i.dtaplic = :dtaplic"),
@NamedQuery(name = "Itemplanj.findByQuantidade", query = "SELECT i FROM Itemplanj i WHERE i.quantidade = :quantidade"),
@NamedQuery(name = "Itemplanj.findByUnidade", query = "SELECT i FROM Itemplanj i WHERE i.unidade = :unidade"),
@NamedQuery(name = "Itemplanj.findByArea", query = "SELECT i FROM Itemplanj i WHERE i.area = :area"),
@NamedQuery(name = "Itemplanj.findByVlunitario", query = "SELECT i FROM Itemplanj i WHERE i.vlunitario = :vlunitario"),
@NamedQuery(name = "Itemplanj.findByVltotal", query = "SELECT i FROM Itemplanj i WHERE i.vltotal = :vltotal"),
@NamedQuery(name = "Itemplanj.findByTpfertilizante", query = "SELECT i FROM Itemplanj i WHERE i.tpfertilizante = :tpfertilizante"),
@NamedQuery(name = "Itemplanj.findByEspeciebase", query = "SELECT i FROM Itemplanj i WHERE i.especiebase = :especiebase"),
@NamedQuery(name = "Itemplanj.findByTpoperac", query = "SELECT i FROM Itemplanj i WHERE i.tpoperac = :tpoperac"),
@NamedQuery(name = "Itemplanj.findByNutilizacao", query = "SELECT i FROM Itemplanj i WHERE i.nutilizacao = :nutilizacao"),
@NamedQuery(name = "Itemplanj.findByFormulacao", query = "SELECT i FROM Itemplanj i WHERE i.formulacao = :formulacao"),
@NamedQuery(name = "Itemplanj.findByCondicao", query = "SELECT i FROM Itemplanj i WHERE i.condicao = :condicao"),
@NamedQuery(name = "Itemplanj.findByTpdespesa", query = "SELECT i FROM Itemplanj i WHERE i.tpdespesa = :tpdespesa"),
@NamedQuery(name = "Itemplanj.findBySituacao", query = "SELECT i FROM Itemplanj i WHERE i.situacao = :situacao"),
@NamedQuery(name = "Itemplanj.findByFlagSincronizacao", query = "SELECT i FROM Itemplanj i WHERE i.flagSincronizacao = :flagSincronizacao")})
public class Itemplanj implements Serializable {
private static final long serialVersionUID = 1L;
81
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_itemplanj")
private Integer idItemplanj;
@Size(max = 15)
@Column(name = "categoria")
private String categoria;
@Size(max = 1)
@Column(name = "tipo")
private String tipo;
@Size(max = 10)
@Column(name = "dtaplic")
private String dtaplic;
@Column(name = "quantidade")
private BigDecimal quantidade;
@Size(max = 3)
@Column(name = "unidade")
private String unidade;
@Column(name = "area")
private BigDecimal area;
@Column(name = "vlunitario")
private BigDecimal vlunitario;
@Column(name = "vltotal")
private BigDecimal vltotal;
@Size(max = 10)
@Column(name = "tpfertilizante")
private String tpfertilizante;
@Size(max = 5)
@Column(name = "especiebase")
private String especiebase;
@Size(max = 25)
@Column(name = "tpoperac")
private String tpoperac;
@Column(name = "nutilizacao")
private Integer nutilizacao;
@Size(max = 12)
@Column(name = "formulacao")
private String formulacao;
@Size(max = 1)
82
@Column(name = "condicao")
private String condicao;
@Size(max = 1)
@Column(name = "tpdespesa")
private String tpdespesa;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(mappedBy = "idItemplanj")
private Collection<Variedadesgleba> variedadesglebaCollection;
@JoinColumn(name = "id_produto", referencedColumnName = "id_produto")
@ManyToOne(optional = false)
private Produto idProduto;
@JoinColumn(name = "id_planejamento", referencedColumnName = "id_planejamento")
@ManyToOne(optional = false)
private Planejamento idPlanejamento;
public Itemplanj() {
}
public Itemplanj(Integer idItemplanj) {
this.idItemplanj = idItemplanj;
}
public Integer getIdItemplanj() {
return idItemplanj;
}
public void setIdItemplanj(Integer idItemplanj) {
this.idItemplanj = idItemplanj;
}
public String getCategoria() {
return categoria;
}
public void setCategoria(String categoria) {
83
this.categoria = categoria;
}
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
this.tipo = tipo;
}
public String getDtaplic() {
return dtaplic;
}
public void setDtaplic(String dtaplic) {
this.dtaplic = dtaplic;
}
public BigDecimal getQuantidade() {
return quantidade;
}
public void setQuantidade(BigDecimal quantidade) {
this.quantidade = quantidade;
}
public String getUnidade() {
return unidade;
}
public void setUnidade(String unidade) {
this.unidade = unidade;
}
public BigDecimal getArea() {
return area;
}
public void setArea(BigDecimal area) {
84
this.area = area;
}
public BigDecimal getVlunitario() {
return vlunitario;
}
public void setVlunitario(BigDecimal vlunitario) {
this.vlunitario = vlunitario;
}
public BigDecimal getVltotal() {
return vltotal;
}
public void setVltotal(BigDecimal vltotal) {
this.vltotal = vltotal;
}
public String getTpfertilizante() {
return tpfertilizante;
}
public void setTpfertilizante(String tpfertilizante) {
this.tpfertilizante = tpfertilizante;
}
public String getEspeciebase() {
return especiebase;
}
public void setEspeciebase(String especiebase) {
this.especiebase = especiebase;
}
public String getTpoperac() {
return tpoperac;
}
public void setTpoperac(String tpoperac) {
85
this.tpoperac = tpoperac;
}
public Integer getNutilizacao() {
return nutilizacao;
}
public void setNutilizacao(Integer nutilizacao) {
this.nutilizacao = nutilizacao;
}
public String getFormulacao() {
return formulacao;
}
public void setFormulacao(String formulacao) {
this.formulacao = formulacao;
}
public String getCondicao() {
return condicao;
}
public void setCondicao(String condicao) {
this.condicao = condicao;
}
public String getTpdespesa() {
return tpdespesa;
}
public void setTpdespesa(String tpdespesa) {
this.tpdespesa = tpdespesa;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
86
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Variedadesgleba> getVariedadesglebaCollection() {
return variedadesglebaCollection;
}
public void setVariedadesglebaCollection(Collection<Variedadesgleba>
variedadesglebaCollection) {
this.variedadesglebaCollection = variedadesglebaCollection;
}
public Produto getIdProduto() {
return idProduto;
}
public void setIdProduto(Produto idProduto) {
this.idProduto = idProduto;
}
public Planejamento getIdPlanejamento() {
return idPlanejamento;
}
public void setIdPlanejamento(Planejamento idPlanejamento) {
this.idPlanejamento = idPlanejamento;
}
@Override
public int hashCode() {
int hash = 0;
87
hash += (idItemplanj != null ? idItemplanj.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Itemplanj)) {
return false;
}
Itemplanj other = (Itemplanj) object;
if ((this.idItemplanj == null && other.idItemplanj != null) || (this.idItemplanj != null &&
!this.idItemplanj.equals(other.idItemplanj))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Itemplanj[ idItemplanj=" + idItemplanj + " ]";
}
}

Classe Leituras.java
package entidades;
import java.io.Serializable;
import java.math.BigDecimal;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
88
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
@Entity
@Table(name = "leituras")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Leituras.findAll", query = "SELECT l FROM Leituras l"),
@NamedQuery(name = "Leituras.findByIdChave", query = "SELECT l FROM Leituras l WHERE l.idChave = :idChave"),
@NamedQuery(name = "Leituras.findByIdLeitura", query = "SELECT l FROM Leituras l WHERE l.idLeitura = :idLeitura"),
@NamedQuery(name = "Leituras.findByResistenceLeitura", query = "SELECT l FROM Leituras l WHERE l.resistenceLeitura = :resistenceLeitura"),
@NamedQuery(name = "Leituras.findByEnviromentmoistureLeitura", query = "SELECT l FROM Leituras l WHERE l.enviromentmoistureLeitura =
:enviromentmoistureLeitura"),
@NamedQuery(name = "Leituras.findByEnviromenttemperatureLeitura", query = "SELECT l FROM Leituras l WHERE l.enviromenttemperatureLeitura =
:enviromenttemperatureLeitura"),
@NamedQuery(name = "Leituras.findByHourLeitura", query = "SELECT l FROM Leituras l WHERE l.hourLeitura = :hourLeitura"),
@NamedQuery(name = "Leituras.findByDateLeitura", query = "SELECT l FROM Leituras l WHERE l.dateLeitura = :dateLeitura")})
public class Leituras implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_chave")
private Integer idChave;
@Basic(optional = false)
@NotNull
@Column(name = "id_leitura")
private int idLeitura;
@Basic(optional = false)
@NotNull
@Column(name = "resistence_leitura")
private BigDecimal resistenceLeitura;
@Basic(optional = false)
@NotNull
@Column(name = "enviromentmoisture_leitura")
private BigDecimal enviromentmoistureLeitura;
@Basic(optional = false)
@NotNull
@Column(name = "enviromenttemperature_leitura")
private BigDecimal enviromenttemperatureLeitura;
@Basic(optional = false)
@NotNull
@Size(min = 1, max = 8)
@Column(name = "hour_leitura")
89
private String hourLeitura;
@Basic(optional = false)
@NotNull
@Size(min = 1, max = 10)
@Column(name = "date_leitura")
private String dateLeitura;
public Leituras() {
}
public Leituras(Integer idChave) {
this.idChave = idChave;
}
public Leituras(Integer idChave, int idLeitura, BigDecimal resistenceLeitura, BigDecimal
enviromentmoistureLeitura, BigDecimal enviromenttemperatureLeitura, String hourLeitura, String
dateLeitura) {
this.idChave = idChave;
this.idLeitura = idLeitura;
this.resistenceLeitura = resistenceLeitura;
this.enviromentmoistureLeitura = enviromentmoistureLeitura;
this.enviromenttemperatureLeitura = enviromenttemperatureLeitura;
this.hourLeitura = hourLeitura;
this.dateLeitura = dateLeitura;
}
public Integer getIdChave() {
return idChave;
}
public void setIdChave(Integer idChave) {
this.idChave = idChave;
}
public int getIdLeitura() {
return idLeitura;
}
public void setIdLeitura(int idLeitura) {
this.idLeitura = idLeitura;
90
}
public BigDecimal getResistenceLeitura() {
return resistenceLeitura;
}
public void setResistenceLeitura(BigDecimal resistenceLeitura) {
this.resistenceLeitura = resistenceLeitura;
}
public BigDecimal getEnviromentmoistureLeitura() {
return enviromentmoistureLeitura;
}
public void setEnviromentmoistureLeitura(BigDecimal enviromentmoistureLeitura) {
this.enviromentmoistureLeitura = enviromentmoistureLeitura;
}
public BigDecimal getEnviromenttemperatureLeitura() {
return enviromenttemperatureLeitura;
}
public void setEnviromenttemperatureLeitura(BigDecimal enviromenttemperatureLeitura) {
this.enviromenttemperatureLeitura = enviromenttemperatureLeitura;
}
public String getHourLeitura() {
return hourLeitura;
}
public void setHourLeitura(String hourLeitura) {
this.hourLeitura = hourLeitura;
}
public String getDateLeitura() {
return dateLeitura;
}
public void setDateLeitura(String dateLeitura) {
this.dateLeitura = dateLeitura;
91
}
@Override
public int hashCode() {
int hash = 0;
hash += (idChave != null ? idChave.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Leituras)) {
return false;
}
Leituras other = (Leituras) object;
if ((this.idChave == null && other.idChave != null) || (this.idChave != null &&
!this.idChave.equals(other.idChave))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Leituras[ idChave=" + idChave + " ]";
}
}

Classe Monitoramento.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
92
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "monitoramento")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Monitoramento.findAll", query = "SELECT m FROM Monitoramento m"),
@NamedQuery(name = "Monitoramento.findByIdMonitoramento", query = "SELECT m FROM Monitoramento m WHERE m.idMonitoramento =
:idMonitoramento"),
@NamedQuery(name = "Monitoramento.findByData", query = "SELECT m FROM Monitoramento m WHERE m.data = :data"),
@NamedQuery(name = "Monitoramento.findByTipo", query = "SELECT m FROM Monitoramento m WHERE m.tipo = :tipo"),
@NamedQuery(name = "Monitoramento.findByNivel", query = "SELECT m FROM Monitoramento m WHERE m.nivel = :nivel"),
@NamedQuery(name = "Monitoramento.findByOcorrencia", query = "SELECT m FROM Monitoramento m WHERE m.ocorrencia = :ocorrencia"),
@NamedQuery(name = "Monitoramento.findByObservacao", query = "SELECT m FROM Monitoramento m WHERE m.observacao = :observacao"),
@NamedQuery(name = "Monitoramento.findBySituacao", query = "SELECT m FROM Monitoramento m WHERE m.situacao = :situacao"),
@NamedQuery(name = "Monitoramento.findByFlagSincronizacao", query = "SELECT m FROM Monitoramento m WHERE m.flagSincronizacao =
:flagSincronizacao")})
public class Monitoramento implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_monitoramento")
private Integer idMonitoramento;
@Size(max = 10)
@Column(name = "data")
private String data;
@Size(max = 1)
@Column(name = "tipo")
private String tipo;
@Size(max = 15)
@Column(name = "nivel")
private String nivel;
@Column(name = "ocorrencia")
private Integer ocorrencia;
@Size(max = 100)
93
@Column(name = "observacao")
private String observacao;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_glebavinculada", referencedColumnName = "id_glebavinculada")
@ManyToOne(optional = false)
private Glebasvinculadas idGlebavinculada;
@JoinColumn(name = "id_estadio", referencedColumnName = "id_estadio")
@ManyToOne
private Estadio idEstadio;
@JoinColumn(name = "id_especiem", referencedColumnName = "id_especiem")
@ManyToOne
private Especiem idEspeciem;
@OneToMany(mappedBy = "idMonitoramento")
private Collection<Pontoamostra> pontoamostraCollection;
public Monitoramento() {
}
public Monitoramento(Integer idMonitoramento) {
this.idMonitoramento = idMonitoramento;
}
public Integer getIdMonitoramento() {
return idMonitoramento;
}
public void setIdMonitoramento(Integer idMonitoramento) {
this.idMonitoramento = idMonitoramento;
}
public String getData() {
return data;
}
public void setData(String data) {
94
this.data = data;
}
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
this.tipo = tipo;
}
public String getNivel() {
return nivel;
}
public void setNivel(String nivel) {
this.nivel = nivel;
}
public Integer getOcorrencia() {
return ocorrencia;
}
public void setOcorrencia(Integer ocorrencia) {
this.ocorrencia = ocorrencia;
}
public String getObservacao() {
return observacao;
}
public void setObservacao(String observacao) {
this.observacao = observacao;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
95
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Glebasvinculadas getIdGlebavinculada() {
return idGlebavinculada;
}
public void setIdGlebavinculada(Glebasvinculadas idGlebavinculada) {
this.idGlebavinculada = idGlebavinculada;
}
public Estadio getIdEstadio() {
return idEstadio;
}
public void setIdEstadio(Estadio idEstadio) {
this.idEstadio = idEstadio;
}
public Especiem getIdEspeciem() {
return idEspeciem;
}
public void setIdEspeciem(Especiem idEspeciem) {
this.idEspeciem = idEspeciem;
}
@XmlTransient
public Collection<Pontoamostra> getPontoamostraCollection() {
return pontoamostraCollection;
}
96
public void setPontoamostraCollection(Collection<Pontoamostra> pontoamostraCollection) {
this.pontoamostraCollection = pontoamostraCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idMonitoramento != null ? idMonitoramento.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Monitoramento)) {
return false;
}
Monitoramento other = (Monitoramento) object;
if ((this.idMonitoramento == null && other.idMonitoramento != null) || (this.idMonitoramento
!= null && !this.idMonitoramento.equals(other.idMonitoramento))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Monitoramento[ idMonitoramento=" + idMonitoramento + " ]";
}
}

Classe Planejamento.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
97
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "planejamento")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Planejamento.findAll", query = "SELECT p FROM Planejamento p"),
@NamedQuery(name = "Planejamento.findByIdPlanejamento", query = "SELECT p FROM Planejamento p WHERE p.idPlanejamento = :idPlanejamento"),
@NamedQuery(name = "Planejamento.findByDescricao", query = "SELECT p FROM Planejamento p WHERE p.descricao = :descricao"),
@NamedQuery(name = "Planejamento.findByEspcontrole", query = "SELECT p FROM Planejamento p WHERE p.espcontrole = :espcontrole"),
@NamedQuery(name = "Planejamento.findByProdestimada", query = "SELECT p FROM Planejamento p WHERE p.prodestimada = :prodestimada"),
@NamedQuery(name = "Planejamento.findByProdrealizada", query = "SELECT p FROM Planejamento p WHERE p.prodrealizada = :prodrealizada"),
@NamedQuery(name = "Planejamento.findByProdentregue", query = "SELECT p FROM Planejamento p WHERE p.prodentregue = :prodentregue"),
@NamedQuery(name = "Planejamento.findByCondicao", query = "SELECT p FROM Planejamento p WHERE p.condicao = :condicao"),
@NamedQuery(name = "Planejamento.findBySituacao", query = "SELECT p FROM Planejamento p WHERE p.situacao = :situacao"),
@NamedQuery(name = "Planejamento.findByFlagSincronizacao", query = "SELECT p FROM Planejamento p WHERE p.flagSincronizacao =
:flagSincronizacao")})
public class Planejamento implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_planejamento")
private Integer idPlanejamento;
@Size(max = 25)
@Column(name = "descricao")
private String descricao;
@Size(max = 1)
@Column(name = "espcontrole")
private String espcontrole;
@Column(name = "prodestimada")
private Integer prodestimada;
@Column(name = "prodrealizada")
private Integer prodrealizada;
98
@Column(name = "prodentregue")
private Integer prodentregue;
@Size(max = 1)
@Column(name = "condicao")
private String condicao;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idPlanejamento")
private Collection<Glebasvinculadas> glebasvinculadasCollection;
@JoinColumn(name = "id_safra", referencedColumnName = "id_safra")
@ManyToOne(optional = false)
private Safra idSafra;
@JoinColumn(name = "id_produtor", referencedColumnName = "id_produtor")
@ManyToOne(optional = false)
private Produtor idProdutor;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idPlanejamento")
private Collection<Itemplanj> itemplanjCollection;
public Planejamento() {
}
public Planejamento(Integer idPlanejamento) {
this.idPlanejamento = idPlanejamento;
}
public Integer getIdPlanejamento() {
return idPlanejamento;
}
public void setIdPlanejamento(Integer idPlanejamento) {
this.idPlanejamento = idPlanejamento;
}
public String getDescricao() {
return descricao;
}
99
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getEspcontrole() {
return espcontrole;
}
public void setEspcontrole(String espcontrole) {
this.espcontrole = espcontrole;
}
public Integer getProdestimada() {
return prodestimada;
}
public void setProdestimada(Integer prodestimada) {
this.prodestimada = prodestimada;
}
public Integer getProdrealizada() {
return prodrealizada;
}
public void setProdrealizada(Integer prodrealizada) {
this.prodrealizada = prodrealizada;
}
public Integer getProdentregue() {
return prodentregue;
}
public void setProdentregue(Integer prodentregue) {
this.prodentregue = prodentregue;
}
public String getCondicao() {
return condicao;
}
100
public void setCondicao(String condicao) {
this.condicao = condicao;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Glebasvinculadas> getGlebasvinculadasCollection() {
return glebasvinculadasCollection;
}
public void setGlebasvinculadasCollection(Collection<Glebasvinculadas>
glebasvinculadasCollection) {
this.glebasvinculadasCollection = glebasvinculadasCollection;
}
public Safra getIdSafra() {
return idSafra;
}
public void setIdSafra(Safra idSafra) {
this.idSafra = idSafra;
}
public Produtor getIdProdutor() {
101
return idProdutor;
}
public void setIdProdutor(Produtor idProdutor) {
this.idProdutor = idProdutor;
}
@XmlTransient
public Collection<Itemplanj> getItemplanjCollection() {
return itemplanjCollection;
}
public void setItemplanjCollection(Collection<Itemplanj> itemplanjCollection) {
this.itemplanjCollection = itemplanjCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idPlanejamento != null ? idPlanejamento.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Planejamento)) {
return false;
}
Planejamento other = (Planejamento) object;
if ((this.idPlanejamento == null && other.idPlanejamento != null) || (this.idPlanejamento !=
null && !this.idPlanejamento.equals(other.idPlanejamento))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Planejamento[ idPlanejamento=" + idPlanejamento + " ]";
}}
102

Classe Pontoamostra.java
package entidades;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
@Entity
@Table(name = "pontoamostra")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Pontoamostra.findAll", query = "SELECT p FROM Pontoamostra p"),
@NamedQuery(name = "Pontoamostra.findByIdPontoamostra", query = "SELECT p FROM Pontoamostra p WHERE p.idPontoamostra = :idPontoamostra"),
@NamedQuery(name = "Pontoamostra.findByLatitude", query = "SELECT p FROM Pontoamostra p WHERE p.latitude = :latitude"),
@NamedQuery(name = "Pontoamostra.findByLongitude", query = "SELECT p FROM Pontoamostra p WHERE p.longitude = :longitude"),
@NamedQuery(name = "Pontoamostra.findByChave", query = "SELECT p FROM Pontoamostra p WHERE p.chave = :chave"),
@NamedQuery(name = "Pontoamostra.findByObservacao", query = "SELECT p FROM Pontoamostra p WHERE p.observacao = :observacao"),
@NamedQuery(name = "Pontoamostra.findByFlagSincronizacao", query = "SELECT p FROM Pontoamostra p WHERE p.flagSincronizacao =
:flagSincronizacao")})
public class Pontoamostra implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_pontoamostra")
private Integer idPontoamostra;
@Size(max = 200)
@Column(name = "latitude")
private String latitude;
@Size(max = 200)
@Column(name = "longitude")
103
private String longitude;
@Size(max = 200)
@Column(name = "chave")
private String chave;
@Size(max = 100)
@Column(name = "observacao")
private String observacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_monitoramento", referencedColumnName = "id_monitoramento")
@ManyToOne
private Monitoramento idMonitoramento;
@JoinColumn(name = "id_eventosc", referencedColumnName = "id_eventosc")
@ManyToOne
private Eventosc idEventosc;
@JoinColumn(name = "id_cultivares", referencedColumnName = "id_cultivares")
@ManyToOne
private Cultivares idCultivares;
public Pontoamostra() {
}
public Pontoamostra(Integer idPontoamostra) {
this.idPontoamostra = idPontoamostra;
}
public Integer getIdPontoamostra() {
return idPontoamostra;
}
public void setIdPontoamostra(Integer idPontoamostra) {
this.idPontoamostra = idPontoamostra;
}
public String getLatitude() {
return latitude;
}
public void setLatitude(String latitude) {
104
this.latitude = latitude;
}
public String getLongitude() {
return longitude;
}
public void setLongitude(String longitude) {
this.longitude = longitude;
}
public String getChave() {
return chave;
}
public void setChave(String chave) {
this.chave = chave;
}
public String getObservacao() {
return observacao;
}
public void setObservacao(String observacao) {
this.observacao = observacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Monitoramento getIdMonitoramento() {
return idMonitoramento;
}
public void setIdMonitoramento(Monitoramento idMonitoramento) {
105
this.idMonitoramento = idMonitoramento;
}
public Eventosc getIdEventosc() {
return idEventosc;
}
public void setIdEventosc(Eventosc idEventosc) {
this.idEventosc = idEventosc;
}
public Cultivares getIdCultivares() {
return idCultivares;
}
public void setIdCultivares(Cultivares idCultivares) {
this.idCultivares = idCultivares;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idPontoamostra != null ? idPontoamostra.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Pontoamostra)) {
return false;
}
Pontoamostra other = (Pontoamostra) object;
if ((this.idPontoamostra == null && other.idPontoamostra != null) || (this.idPontoamostra !=
null && !this.idPontoamostra.equals(other.idPontoamostra))) {
return false;
}
return true;
}
@Override
106
public String toString() {
return "entidades.Pontoamostra[ idPontoamostra=" + idPontoamostra + " ]";
}
}

Classe Produto.java
package entidades;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "produto")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Produto.findAll", query = "SELECT p FROM Produto p"),
@NamedQuery(name = "Produto.findByIdProduto", query = "SELECT p FROM Produto p WHERE p.idProduto = :idProduto"),
@NamedQuery(name = "Produto.findByNome", query = "SELECT p FROM Produto p WHERE p.nome = :nome"),
@NamedQuery(name = "Produto.findByUnidade", query = "SELECT p FROM Produto p WHERE p.unidade = :unidade"),
@NamedQuery(name = "Produto.findByPreco", query = "SELECT p FROM Produto p WHERE p.preco = :preco"),
@NamedQuery(name = "Produto.findByDosagem", query = "SELECT p FROM Produto p WHERE p.dosagem = :dosagem"),
@NamedQuery(name = "Produto.findByFormulacao", query = "SELECT p FROM Produto p WHERE p.formulacao = :formulacao"),
@NamedQuery(name = "Produto.findBySituacao", query = "SELECT p FROM Produto p WHERE p.situacao = :situacao"),
@NamedQuery(name = "Produto.findByFlagSincronizacao", query = "SELECT p FROM Produto p WHERE p.flagSincronizacao = :flagSincronizacao")})
public class Produto implements Serializable {
private static final long serialVersionUID = 1L;
@Id
107
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_produto")
private Integer idProduto;
@Size(max = 15)
@Column(name = "nome")
private String nome;
@Size(max = 3)
@Column(name = "unidade")
private String unidade;
@Column(name = "preco")
private BigDecimal preco;
@Column(name = "dosagem")
private BigDecimal dosagem;
@Size(max = 4)
@Column(name = "formulacao")
private String formulacao;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idProduto")
private Collection<Itemplanj> itemplanjCollection;
public Produto() {
}
public Produto(Integer idProduto) {
this.idProduto = idProduto;
}
public Integer getIdProduto() {
return idProduto;
}
public void setIdProduto(Integer idProduto) {
this.idProduto = idProduto;
}
108
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getUnidade() {
return unidade;
}
public void setUnidade(String unidade) {
this.unidade = unidade;
}
public BigDecimal getPreco() {
return preco;
}
public void setPreco(BigDecimal preco) {
this.preco = preco;
}
public BigDecimal getDosagem() {
return dosagem;
}
public void setDosagem(BigDecimal dosagem) {
this.dosagem = dosagem;
}
public String getFormulacao() {
return formulacao;
}
public void setFormulacao(String formulacao) {
this.formulacao = formulacao;
}
109
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Itemplanj> getItemplanjCollection() {
return itemplanjCollection;
}
public void setItemplanjCollection(Collection<Itemplanj> itemplanjCollection) {
this.itemplanjCollection = itemplanjCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idProduto != null ? idProduto.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Produto)) {
return false;
}
Produto other = (Produto) object;
110
if ((this.idProduto == null && other.idProduto != null) || (this.idProduto != null &&
!this.idProduto.equals(other.idProduto))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Produto[ idProduto=" + idProduto + " ]";
}
}

Classe Produtor.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "produtor")
@XmlRootElement
@NamedQueries({
111
@NamedQuery(name = "Produtor.findAll", query = "SELECT p FROM Produtor p"),
@NamedQuery(name = "Produtor.findByIdProdutor", query = "SELECT p FROM Produtor p WHERE p.idProdutor = :idProdutor"),
@NamedQuery(name = "Produtor.findByNome", query = "SELECT p FROM Produtor p WHERE p.nome = :nome"),
@NamedQuery(name = "Produtor.findByDatanasc", query = "SELECT p FROM Produtor p WHERE p.datanasc = :datanasc"),
@NamedQuery(name = "Produtor.findByCpf", query = "SELECT p FROM Produtor p WHERE p.cpf = :cpf"),
@NamedQuery(name = "Produtor.findByNivelassist", query = "SELECT p FROM Produtor p WHERE p.nivelassist = :nivelassist"),
@NamedQuery(name = "Produtor.findByTipocadastro", query = "SELECT p FROM Produtor p WHERE p.tipocadastro = :tipocadastro"),
@NamedQuery(name = "Produtor.findBySituacao", query = "SELECT p FROM Produtor p WHERE p.situacao = :situacao"),
@NamedQuery(name = "Produtor.findBySexo", query = "SELECT p FROM Produtor p WHERE p.sexo = :sexo"),
@NamedQuery(name = "Produtor.findByEndereco", query = "SELECT p FROM Produtor p WHERE p.endereco = :endereco"),
@NamedQuery(name = "Produtor.findByTelefone", query = "SELECT p FROM Produtor p WHERE p.telefone = :telefone"),
@NamedQuery(name = "Produtor.findByEmail", query = "SELECT p FROM Produtor p WHERE p.email = :email"),
@NamedQuery(name = "Produtor.findByObservacao", query = "SELECT p FROM Produtor p WHERE p.observacao = :observacao"),
@NamedQuery(name = "Produtor.findByFlagSincronizacao", query = "SELECT p FROM Produtor p WHERE p.flagSincronizacao = :flagSincronizacao")})
public class Produtor implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_produtor")
private Integer idProdutor;
@Size(max = 2147483647)
@Column(name = "nome")
private String nome;
@Size(max = 10)
@Column(name = "datanasc")
private String datanasc;
@Size(max = 14)
@Column(name = "cpf")
private String cpf;
@Size(max = 1)
@Column(name = "nivelassist")
private String nivelassist;
@Size(max = 1)
@Column(name = "tipocadastro")
private String tipocadastro;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "sexo")
private String sexo;
@Size(max = 2147483647)
@Column(name = "endereco")
private String endereco;
@Size(max = 2147483647)
112
@Column(name = "telefone")
private String telefone;
@Size(max = 2147483647)
@Column(name = "email")
private String email;
@Size(max = 2147483647)
@Column(name = "observacao")
private String observacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_tecnico", referencedColumnName = "id_tecnico")
@ManyToOne
private Tecnico idTecnico;
@JoinColumn(name = "id_cidade", referencedColumnName = "id_cidade")
@ManyToOne
private Cidade idCidade;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idProdutor")
private Collection<Propriedade> propriedadeCollection;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idProdutor")
private Collection<Planejamento> planejamentoCollection;
public Produtor() {
}
public Produtor(Integer idProdutor) {
this.idProdutor = idProdutor;
}
public Integer getIdProdutor() {
return idProdutor;
}
public void setIdProdutor(Integer idProdutor) {
this.idProdutor = idProdutor;
}
public String getNome() {
return nome;
}
113
public void setNome(String nome) {
this.nome = nome;
}
public String getDatanasc() {
return datanasc;
}
public void setDatanasc(String datanasc) {
this.datanasc = datanasc;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getNivelassist() {
return nivelassist;
}
public void setNivelassist(String nivelassist) {
this.nivelassist = nivelassist;
}
public String getTipocadastro() {
return tipocadastro;
}
public void setTipocadastro(String tipocadastro) {
this.tipocadastro = tipocadastro;
}
public String getSituacao() {
return situacao;
}
114
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public String getEndereco() {
return endereco;
}
public void setEndereco(String endereco) {
this.endereco = endereco;
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getObservacao() {
return observacao;
}
115
public void setObservacao(String observacao) {
this.observacao = observacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Tecnico getIdTecnico() {
return idTecnico;
}
public void setIdTecnico(Tecnico idTecnico) {
this.idTecnico = idTecnico;
}
public Cidade getIdCidade() {
return idCidade;
}
public void setIdCidade(Cidade idCidade) {
this.idCidade = idCidade;
}
@XmlTransient
public Collection<Propriedade> getPropriedadeCollection() {
return propriedadeCollection;
}
public void setPropriedadeCollection(Collection<Propriedade> propriedadeCollection) {
this.propriedadeCollection = propriedadeCollection;
}
@XmlTransient
public Collection<Planejamento> getPlanejamentoCollection() {
116
return planejamentoCollection;
}
public void setPlanejamentoCollection(Collection<Planejamento> planejamentoCollection) {
this.planejamentoCollection = planejamentoCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idProdutor != null ? idProdutor.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Produtor)) {
return false;
}
Produtor other = (Produtor) object;
if ((this.idProdutor == null && other.idProdutor != null) || (this.idProdutor != null &&
!this.idProdutor.equals(other.idProdutor))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Produtor[ idProdutor=" + idProdutor + " ]";
}
}

Classe Propriedade.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
117
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "propriedade")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Propriedade.findAll", query = "SELECT p FROM Propriedade p"),
@NamedQuery(name = "Propriedade.findByIdPropriedade", query = "SELECT p FROM Propriedade p WHERE p.idPropriedade = :idPropriedade"),
@NamedQuery(name = "Propriedade.findByNomePropriedade", query = "SELECT p FROM Propriedade p WHERE p.nomePropriedade = :nomePropriedade"),
@NamedQuery(name = "Propriedade.findByLocalidade", query = "SELECT p FROM Propriedade p WHERE p.localidade = :localidade"),
@NamedQuery(name = "Propriedade.findByArea", query = "SELECT p FROM Propriedade p WHERE p.area = :area"),
@NamedQuery(name = "Propriedade.findByAreaArrendada", query = "SELECT p FROM Propriedade p WHERE p.areaArrendada = :areaArrendada"),
@NamedQuery(name = "Propriedade.findBySituacao", query = "SELECT p FROM Propriedade p WHERE p.situacao = :situacao"),
@NamedQuery(name = "Propriedade.findByObservacao", query = "SELECT p FROM Propriedade p WHERE p.observacao = :observacao"),
@NamedQuery(name = "Propriedade.findByFlagSincronizacao", query = "SELECT p FROM Propriedade p WHERE p.flagSincronizacao =
:flagSincronizacao")})
public class Propriedade implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_propriedade")
private Integer idPropriedade;
@Basic(optional = false)
@NotNull
@Size(min = 1, max = 40)
@Column(name = "nome_propriedade")
private String nomePropriedade;
118
@Size(max = 40)
@Column(name = "localidade")
private String localidade;
@Size(max = 10)
@Column(name = "area")
private String area;
@Size(max = 10)
@Column(name = "area_arrendada")
private String areaArrendada;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 2147483647)
@Column(name = "observacao")
private String observacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_produtor", referencedColumnName = "id_produtor")
@ManyToOne(optional = false)
private Produtor idProdutor;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idPropriedade")
private Collection<Gleba> glebaCollection;
public Propriedade() {
}
public Propriedade(Integer idPropriedade) {
this.idPropriedade = idPropriedade;
}
public Propriedade(Integer idPropriedade, String nomePropriedade) {
this.idPropriedade = idPropriedade;
this.nomePropriedade = nomePropriedade;
}
public Integer getIdPropriedade() {
return idPropriedade;
}
119
public void setIdPropriedade(Integer idPropriedade) {
this.idPropriedade = idPropriedade;
}
public String getNomePropriedade() {
return nomePropriedade;
}
public void setNomePropriedade(String nomePropriedade) {
this.nomePropriedade = nomePropriedade;
}
public String getLocalidade() {
return localidade;
}
public void setLocalidade(String localidade) {
this.localidade = localidade;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
public String getAreaArrendada() {
return areaArrendada;
}
public void setAreaArrendada(String areaArrendada) {
this.areaArrendada = areaArrendada;
}
public String getSituacao() {
return situacao;
}
120
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getObservacao() {
return observacao;
}
public void setObservacao(String observacao) {
this.observacao = observacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Produtor getIdProdutor() {
return idProdutor;
}
public void setIdProdutor(Produtor idProdutor) {
this.idProdutor = idProdutor;
}
@XmlTransient
public Collection<Gleba> getGlebaCollection() {
return glebaCollection;
}
public void setGlebaCollection(Collection<Gleba> glebaCollection) {
this.glebaCollection = glebaCollection;
}
@Override
public int hashCode() {
int hash = 0;
121
hash += (idPropriedade != null ? idPropriedade.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Propriedade)) {
return false;
}
Propriedade other = (Propriedade) object;
if ((this.idPropriedade == null && other.idPropriedade != null) || (this.idPropriedade != null &&
!this.idPropriedade.equals(other.idPropriedade))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Propriedade[ idPropriedade=" + idPropriedade + " ]";
}
}

Classe Safra.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
122
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "safra")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Safra.findAll", query = "SELECT s FROM Safra s"),
@NamedQuery(name = "Safra.findByIdSafra", query = "SELECT s FROM Safra s WHERE s.idSafra = :idSafra"),
@NamedQuery(name = "Safra.findByDescricao", query = "SELECT s FROM Safra s WHERE s.descricao = :descricao"),
@NamedQuery(name = "Safra.findByCondicao", query = "SELECT s FROM Safra s WHERE s.condicao = :condicao"),
@NamedQuery(name = "Safra.findByMascinicio", query = "SELECT s FROM Safra s WHERE s.mascinicio = :mascinicio"),
@NamedQuery(name = "Safra.findByMascfim", query = "SELECT s FROM Safra s WHERE s.mascfim = :mascfim"),
@NamedQuery(name = "Safra.findBySituacao", query = "SELECT s FROM Safra s WHERE s.situacao = :situacao"),
@NamedQuery(name = "Safra.findByFlagSincronizacao", query = "SELECT s FROM Safra s WHERE s.flagSincronizacao = :flagSincronizacao")})
public class Safra implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_safra")
private Integer idSafra;
@Size(max = 40)
@Column(name = "descricao")
private String descricao;
@Size(max = 1)
@Column(name = "condicao")
private String condicao;
@Size(max = 40)
@Column(name = "mascinicio")
private String mascinicio;
@Size(max = 40)
@Column(name = "mascfim")
private String mascfim;
@Size(max = 40)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
123
@JoinColumn(name = "id_cultura", referencedColumnName = "id_cultura")
@ManyToOne(optional = false)
private Cultura idCultura;
@JoinColumn(name = "id_anoagricola", referencedColumnName = "id_anoagricola")
@ManyToOne(optional = false)
private Anoagricola idAnoagricola;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idSafra")
private Collection<Planejamento> planejamentoCollection;
public Safra() {
}
public Safra(Integer idSafra) {
this.idSafra = idSafra;
}
public Integer getIdSafra() {
return idSafra;
}
public void setIdSafra(Integer idSafra) {
this.idSafra = idSafra;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getCondicao() {
return condicao;
}
public void setCondicao(String condicao) {
this.condicao = condicao;
}
124
public String getMascinicio() {
return mascinicio;
}
public void setMascinicio(String mascinicio) {
this.mascinicio = mascinicio;
}
public String getMascfim() {
return mascfim;
}
public void setMascfim(String mascfim) {
this.mascfim = mascfim;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Cultura getIdCultura() {
return idCultura;
}
public void setIdCultura(Cultura idCultura) {
this.idCultura = idCultura;
}
125
public Anoagricola getIdAnoagricola() {
return idAnoagricola;
}
public void setIdAnoagricola(Anoagricola idAnoagricola) {
this.idAnoagricola = idAnoagricola;
}
@XmlTransient
public Collection<Planejamento> getPlanejamentoCollection() {
return planejamentoCollection;
}
public void setPlanejamentoCollection(Collection<Planejamento> planejamentoCollection) {
this.planejamentoCollection = planejamentoCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idSafra != null ? idSafra.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Safra)) {
return false;
}
Safra other = (Safra) object;
if ((this.idSafra == null && other.idSafra != null) || (this.idSafra != null &&
!this.idSafra.equals(other.idSafra))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Safra[ idSafra=" + idSafra + " ]";
}}
126

Classe Tecnico.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "tecnico")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Tecnico.findAll", query = "SELECT t FROM Tecnico t"),
@NamedQuery(name = "Tecnico.findByIdTecnico", query = "SELECT t FROM Tecnico t WHERE t.idTecnico = :idTecnico"),
@NamedQuery(name = "Tecnico.findByTecnico", query = "SELECT t FROM Tecnico t WHERE t.tecnico = :tecnico"),
@NamedQuery(name = "Tecnico.findByCrea", query = "SELECT t FROM Tecnico t WHERE t.crea = :crea"),
@NamedQuery(name = "Tecnico.findByFlagSincronizacao", query = "SELECT t FROM Tecnico t WHERE t.flagSincronizacao = :flagSincronizacao")})
public class Tecnico implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_tecnico")
private Integer idTecnico;
@Size(max = 40)
@Column(name = "tecnico")
private String tecnico;
@Basic(optional = false)
@NotNull
127
@Size(min = 1, max = 15)
@Column(name = "crea")
private String crea;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(mappedBy = "idTecnico")
private Collection<Produtor> produtorCollection;
public Tecnico() {
}
public Tecnico(Integer idTecnico) {
this.idTecnico = idTecnico;
}
public Tecnico(Integer idTecnico, String crea) {
this.idTecnico = idTecnico;
this.crea = crea;
}
public Integer getIdTecnico() {
return idTecnico;
}
public void setIdTecnico(Integer idTecnico) {
this.idTecnico = idTecnico;
}
public String getTecnico() {
return tecnico;
}
public void setTecnico(String tecnico) {
this.tecnico = tecnico;
}
public String getCrea() {
return crea;
}
128
public void setCrea(String crea) {
this.crea = crea;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Produtor> getProdutorCollection() {
return produtorCollection;
}
public void setProdutorCollection(Collection<Produtor> produtorCollection) {
this.produtorCollection = produtorCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idTecnico != null ? idTecnico.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Tecnico)) {
return false;
}
Tecnico other = (Tecnico) object;
if ((this.idTecnico == null && other.idTecnico != null) || (this.idTecnico != null &&
!this.idTecnico.equals(other.idTecnico))) {
return false;
}
return true;
129
}
@Override
public String toString() {
return "entidades.Tecnico[ idTecnico=" + idTecnico + " ]";
}
}

Classe Variedades.java
package entidades;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "variedades")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Variedades.findAll", query = "SELECT v FROM Variedades v"),
@NamedQuery(name = "Variedades.findByIdVariedades", query = "SELECT v FROM Variedades v WHERE v.idVariedades = :idVariedades"),
@NamedQuery(name = "Variedades.findByDescricao", query = "SELECT v FROM Variedades v WHERE v.descricao = :descricao"),
@NamedQuery(name = "Variedades.findByPopfinal", query = "SELECT v FROM Variedades v WHERE v.popfinal = :popfinal"),
@NamedQuery(name = "Variedades.findBySituacao", query = "SELECT v FROM Variedades v WHERE v.situacao = :situacao"),
@NamedQuery(name = "Variedades.findByFlagSincronizacao", query = "SELECT v FROM Variedades v WHERE v.flagSincronizacao = :flagSincronizacao")})
130
public class Variedades implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_variedades")
private Integer idVariedades;
@Size(max = 30)
@Column(name = "descricao")
private String descricao;
@Column(name = "popfinal")
private Integer popfinal;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@JoinColumn(name = "id_cultura", referencedColumnName = "id_cultura")
@ManyToOne
private Cultura idCultura;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idVariedades")
private Collection<Variedadesgleba> variedadesglebaCollection;
public Variedades() {
}
public Variedades(Integer idVariedades) {
this.idVariedades = idVariedades;
}
public Integer getIdVariedades() {
return idVariedades;
}
public void setIdVariedades(Integer idVariedades) {
this.idVariedades = idVariedades;
}
public String getDescricao() {
131
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public Integer getPopfinal() {
return popfinal;
}
public void setPopfinal(Integer popfinal) {
this.popfinal = popfinal;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
public Cultura getIdCultura() {
return idCultura;
}
public void setIdCultura(Cultura idCultura) {
this.idCultura = idCultura;
}
@XmlTransient
132
public Collection<Variedadesgleba> getVariedadesglebaCollection() {
return variedadesglebaCollection;
}
public void setVariedadesglebaCollection(Collection<Variedadesgleba>
variedadesglebaCollection) {
this.variedadesglebaCollection = variedadesglebaCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idVariedades != null ? idVariedades.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Variedades)) {
return false;
}
Variedades other = (Variedades) object;
if ((this.idVariedades == null && other.idVariedades != null) || (this.idVariedades != null &&
!this.idVariedades.equals(other.idVariedades))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Variedades[ idVariedades=" + idVariedades + " ]";
}
}

Classe Variedadegleba.java
package entidades;
133
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
@Entity
@Table(name = "variedadesgleba")
@XmlRootElement
@NamedQueries({
@NamedQuery(name = "Variedadesgleba.findAll", query = "SELECT v FROM Variedadesgleba v"),
@NamedQuery(name = "Variedadesgleba.findByIdVariedadesgleba", query = "SELECT v FROM Variedadesgleba v WHERE v.idVariedadesgleba =
:idVariedadesgleba"),
@NamedQuery(name = "Variedadesgleba.findByQntaplic", query = "SELECT v FROM Variedadesgleba v WHERE v.qntaplic = :qntaplic"),
@NamedQuery(name = "Variedadesgleba.findByEspalinha", query = "SELECT v FROM Variedadesgleba v WHERE v.espalinha = :espalinha"),
@NamedQuery(name = "Variedadesgleba.findByPmetrolinear", query = "SELECT v FROM Variedadesgleba v WHERE v.pmetrolinear = :pmetrolinear"),
@NamedQuery(name = "Variedadesgleba.findByPopulhec", query = "SELECT v FROM Variedadesgleba v WHERE v.populhec = :populhec"),
@NamedQuery(name = "Variedadesgleba.findByDtinicio", query = "SELECT v FROM Variedadesgleba v WHERE v.dtinicio = :dtinicio"),
@NamedQuery(name = "Variedadesgleba.findByDtfinal", query = "SELECT v FROM Variedadesgleba v WHERE v.dtfinal = :dtfinal"),
@NamedQuery(name = "Variedadesgleba.findBySituacao", query = "SELECT v FROM Variedadesgleba v WHERE v.situacao = :situacao"),
@NamedQuery(name = "Variedadesgleba.findByFlagSincronizacao", query = "SELECT v FROM Variedadesgleba v WHERE v.flagSincronizacao =
:flagSincronizacao")})
public class Variedadesgleba implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id_variedadesgleba")
private Integer idVariedadesgleba;
@Column(name = "qntaplic")
private Integer qntaplic;
@Column(name = "espalinha")
134
private Integer espalinha;
@Column(name = "pmetrolinear")
private Integer pmetrolinear;
@Column(name = "populhec")
private Integer populhec;
@Size(max = 10)
@Column(name = "dtinicio")
private String dtinicio;
@Size(max = 10)
@Column(name = "dtfinal")
private String dtfinal;
@Size(max = 1)
@Column(name = "situacao")
private String situacao;
@Size(max = 1)
@Column(name = "flag_sincronizacao")
private String flagSincronizacao;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "idVariedadesgleba")
private Collection<Cultivares> cultivaresCollection;
@JoinColumn(name = "id_variedades", referencedColumnName = "id_variedades")
@ManyToOne(optional = false)
private Variedades idVariedades;
@JoinColumn(name = "id_itemplanj", referencedColumnName = "id_itemplanj")
@ManyToOne
private Itemplanj idItemplanj;
public Variedadesgleba() {
}
public Variedadesgleba(Integer idVariedadesgleba) {
this.idVariedadesgleba = idVariedadesgleba;
}
public Integer getIdVariedadesgleba() {
return idVariedadesgleba;
}
public void setIdVariedadesgleba(Integer idVariedadesgleba) {
this.idVariedadesgleba = idVariedadesgleba;
}
135
public Integer getQntaplic() {
return qntaplic;
}
public void setQntaplic(Integer qntaplic) {
this.qntaplic = qntaplic;
}
public Integer getEspalinha() {
return espalinha;
}
public void setEspalinha(Integer espalinha) {
this.espalinha = espalinha;
}
public Integer getPmetrolinear() {
return pmetrolinear;
}
public void setPmetrolinear(Integer pmetrolinear) {
this.pmetrolinear = pmetrolinear;
}
public Integer getPopulhec() {
return populhec;
}
public void setPopulhec(Integer populhec) {
this.populhec = populhec;
}
public String getDtinicio() {
return dtinicio;
}
public void setDtinicio(String dtinicio) {
this.dtinicio = dtinicio;
}
136
public String getDtfinal() {
return dtfinal;
}
public void setDtfinal(String dtfinal) {
this.dtfinal = dtfinal;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
this.situacao = situacao;
}
public String getFlagSincronizacao() {
return flagSincronizacao;
}
public void setFlagSincronizacao(String flagSincronizacao) {
this.flagSincronizacao = flagSincronizacao;
}
@XmlTransient
public Collection<Cultivares> getCultivaresCollection() {
return cultivaresCollection;
}
public void setCultivaresCollection(Collection<Cultivares> cultivaresCollection) {
this.cultivaresCollection = cultivaresCollection;
}
public Variedades getIdVariedades() {
return idVariedades;
}
public void setIdVariedades(Variedades idVariedades) {
this.idVariedades = idVariedades;
137
}
public Itemplanj getIdItemplanj() {
return idItemplanj;
}
public void setIdItemplanj(Itemplanj idItemplanj) {
this.idItemplanj = idItemplanj;
}
@Override
public int hashCode() {
int hash = 0;
hash += (idVariedadesgleba != null ? idVariedadesgleba.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
if (!(object instanceof Variedadesgleba)) {
return false;
}
Variedadesgleba other = (Variedadesgleba) object;
if ((this.idVariedadesgleba == null && other.idVariedadesgleba != null) ||
(this.idVariedadesgleba != null && !this.idVariedadesgleba.equals(other.idVariedadesgleba))) {
return false;
}
return true;
}
@Override
public String toString() {
return "entidades.Variedadesgleba[ idVariedadesgleba=" + idVariedadesgleba + " ]";
}
}
138
APÊNDICE C – Classes do Pacote Recursos

Classe AnoagricolaFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Anoagricola;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.anoagricola")
public class AnoagricolaFacadeREST extends AbstractFacade<Anoagricola> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public AnoagricolaFacadeREST() {
super(Anoagricola.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Anoagricola entity) {
super.create(entity);
}
@PUT
139
@Path("{id}")
@Consumes( "application/json")
public void edit(@PathParam("id") Integer id, Anoagricola entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Anoagricola find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Anoagricola> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Anoagricola> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
140
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe CidadeFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Cidade;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.cidade")
public class CidadeFacadeREST extends AbstractFacade<Cidade> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public CidadeFacadeREST() {
super(Cidade.class);
}
@POST
@Override
@Consumes("application/json")
141
public void create(Cidade entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Cidade entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Cidade find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces( "application/json")
public List<Cidade> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Cidade> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
142
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe CultivaresFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Cultivares;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.cultivares")
public class CultivaresFacadeREST extends AbstractFacade<Cultivares> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public CultivaresFacadeREST() {
super(Cultivares.class);
143
}
@POST
@Override
@Consumes("application/json")
public void create(Cultivares entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Cultivares entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Cultivares find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Cultivares> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
144
public List<Cultivares> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe CulturaFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Cultura;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.cultura")
145
public class CulturaFacadeREST extends AbstractFacade<Cultura> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public CulturaFacadeREST() {
super(Cultura.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Cultura entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Cultura entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Cultura find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Cultura> findAll() {
return super.findAll();
146
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Cultura> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe EspeciemFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Especiem;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
147
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.especiem")
public class EspeciemFacadeREST extends AbstractFacade<Especiem> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public EspeciemFacadeREST() {
super(Especiem.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Especiem entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Especiem entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Especiem find(@PathParam("id") Integer id) {
return super.find(id);
}
148
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Especiem> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public List<Especiem> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe EstadioFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Estadio;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
149
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.estadio")
public class EstadioFacadeREST extends AbstractFacade<Estadio> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public EstadioFacadeREST() {
super(Estadio.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Estadio entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Estadio entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
150
@Produces("application/json")
public Estadio find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Estadio> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Estadio> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe EventoscFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Eventosc;
151
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.eventosc")
public class EventoscFacadeREST extends AbstractFacade<Eventosc> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public EventoscFacadeREST() {
super(Eventosc.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Eventosc entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Eventosc entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
152
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Eventosc find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Eventosc> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Eventosc> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}
153

Classe GlebaFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Gleba;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.gleba")
public class GlebaFacadeREST extends AbstractFacade<Gleba> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public GlebaFacadeREST() {
super(Gleba.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Gleba entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Gleba entity) {
154
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Gleba find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Gleba> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Gleba> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
155
return em;
}
}

Classe GlebasvinculadasFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Glebasvinculadas;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.glebasvinculadas")
public class GlebasvinculadasFacadeREST extends AbstractFacade<Glebasvinculadas> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public GlebasvinculadasFacadeREST() {
super(Glebasvinculadas.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Glebasvinculadas entity) {
super.create(entity);
156
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Glebasvinculadas entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Glebasvinculadas find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Glebasvinculadas> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public
List<Glebasvinculadas>
findRange(@PathParam("from")
@PathParam("to") Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
Integer
from,
157
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe ItemplanjFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Itemplanj;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.itemplanj")
public class ItemplanjFacadeREST extends AbstractFacade<Itemplanj> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public ItemplanjFacadeREST() {
super(Itemplanj.class);
}
158
@POST
@Override
@Consumes( "application/json")
public void create(Itemplanj entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Itemplanj entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Itemplanj find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces( "application/json")
public List<Itemplanj> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Itemplanj> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
159
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe LeiturasFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Leituras;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.leituras")
public class LeiturasFacadeREST extends AbstractFacade<Leituras> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
160
public LeiturasFacadeREST() {
super(Leituras.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Leituras entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Leituras entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Leituras find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Leituras> findAll() {
return super.findAll();
}
@GET
161
@Path("{from}/{to}")
@Produces("application/json")
public List<Leituras> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe MonitoramentoFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Monitoramento;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
162
@Stateless
@Path("entidades.monitoramento")
public class MonitoramentoFacadeREST extends AbstractFacade<Monitoramento> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public MonitoramentoFacadeREST() {
super(Monitoramento.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Monitoramento entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Monitoramento entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
public Monitoramento find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
163
@Produces("application/json")
public List<Monitoramento> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Monitoramento> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe PlanejamentoFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Planejamento;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
164
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.planejamento")
public class PlanejamentoFacadeREST extends AbstractFacade<Planejamento> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public PlanejamentoFacadeREST() {
super(Planejamento.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Planejamento entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Planejamento entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces("application/json")
165
public Planejamento find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Planejamento> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Planejamento> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe PontoamostraFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Pontoamostra;
import java.util.List;
166
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.pontoamostra")
public class PontoamostraFacadeREST extends AbstractFacade<Pontoamostra> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public PontoamostraFacadeREST() {
super(Pontoamostra.class);
}
@POST
@Override
@Consumes("application/json")
public void create(Pontoamostra entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes("application/json")
public void edit(@PathParam("id") Integer id, Pontoamostra entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
167
}
@GET
@Path("{id}")
@Produces("application/json")
public Pontoamostra find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces("application/json")
public List<Pontoamostra> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces("application/json")
public List<Pontoamostra> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe ProdutoFacadeREST.java
168
package recursos;
import config.AbstractFacade;
import entidades.Produto;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.produto")
public class ProdutoFacadeREST extends AbstractFacade<Produto> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public ProdutoFacadeREST() {
super(Produto.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Produto entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Produto entity) {
super.edit(entity);
}
169
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Produto find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Produto> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public List<Produto> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
170
}

Classe ProdutorFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Produtor;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.produtor")
public class ProdutorFacadeREST extends AbstractFacade<Produtor> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public ProdutorFacadeREST() {
super(Produtor.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Produtor entity) {
super.create(entity);
}
@PUT
171
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Produtor entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Produtor find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Produtor> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public List<Produtor> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
172
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe PropriedadeFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Propriedade;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.propriedade")
public class PropriedadeFacadeREST extends AbstractFacade<Propriedade> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public PropriedadeFacadeREST() {
super(Propriedade.class);
}
@POST
@Override
173
@Consumes({"application/xml", "application/json"})
public void create(Propriedade entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Propriedade entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Propriedade find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Propriedade> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public List<Propriedade> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
174
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe SafraFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Safra;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.safra")
public class SafraFacadeREST extends AbstractFacade<Safra> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
175
public SafraFacadeREST() {
super(Safra.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Safra entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Safra entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Safra find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Safra> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
176
@Produces({"application/xml", "application/json"})
public List<Safra> findRange(@PathParam("from") Integer from, @PathParam("to") Integer to)
{
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe TecnicoFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Tecnico;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
177
@Stateless
@Path("entidades.tecnico")
public class TecnicoFacadeREST extends AbstractFacade<Tecnico> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public TecnicoFacadeREST() {
super(Tecnico.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Tecnico entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Tecnico entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Tecnico find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
178
public List<Tecnico> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public List<Tecnico> findRange(@PathParam("from") Integer from, @PathParam("to") Integer
to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe VariedadesFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Variedades;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
179
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.variedades")
public class VariedadesFacadeREST extends AbstractFacade<Variedades> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public VariedadesFacadeREST() {
super(Variedades.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Variedades entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Variedades entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Variedades find(@PathParam("id") Integer id) {
180
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Variedades> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public List<Variedades> findRange(@PathParam("from") Integer from, @PathParam("to")
Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}

Classe VariedadesglebaFacadeREST.java
package recursos;
import config.AbstractFacade;
import entidades.Variedadesgleba;
import java.util.List;
import javax.ejb.Stateless;
181
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Stateless
@Path("entidades.variedadesgleba")
public class VariedadesglebaFacadeREST extends AbstractFacade<Variedadesgleba> {
@PersistenceContext(unitName = "AgroMobileWSPU")
private EntityManager em;
public VariedadesglebaFacadeREST() {
super(Variedadesgleba.class);
}
@POST
@Override
@Consumes({"application/xml", "application/json"})
public void create(Variedadesgleba entity) {
super.create(entity);
}
@PUT
@Path("{id}")
@Consumes({"application/xml", "application/json"})
public void edit(@PathParam("id") Integer id, Variedadesgleba entity) {
super.edit(entity);
}
@DELETE
@Path("{id}")
public void remove(@PathParam("id") Integer id) {
super.remove(super.find(id));
}
182
@GET
@Path("{id}")
@Produces({"application/xml", "application/json"})
public Variedadesgleba find(@PathParam("id") Integer id) {
return super.find(id);
}
@GET
@Override
@Produces({"application/xml", "application/json"})
public List<Variedadesgleba> findAll() {
return super.findAll();
}
@GET
@Path("{from}/{to}")
@Produces({"application/xml", "application/json"})
public
List<Variedadesgleba>
findRange(@PathParam("from")
@PathParam("to") Integer to) {
return super.findRange(new int[]{from, to});
}
@GET
@Path("count")
@Produces("text/plain")
public String countREST() {
return String.valueOf(super.count());
}
@Override
protected EntityManager getEntityManager() {
return em;
}
}
Integer
from,