desenvolvimento de um sistema inteligente para uma empresa...
TRANSCRIPT
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
DEPARTAMENTO ACADÊMICO DE INFORMÁTICA
CURSO DE BACHARELADO EM SISTEMAS DE INFORMAÇÃO
ESTEVAN FREDERICO PASQUETTA JANTSK
THOMAZ TEODOROVICZ
DESENVOLVIMENTO DE UM SISTEMA INTELIGENTE PARA UMA
EMPRESA DE DEPARTAMENTOS
MONOGRAFIA
CURITIBA
1
2009
ESTEVAN FREDERICO PASQUETTA JANTSK
THOMAZ TEODOROVICZ
DESENVOLVIMENTO DE UM SISTEMA INTELIGENTE PARA UMA
EMPRESA DE DEPARTAMENTOS
Monografia apresentada às
disciplinas de Algoritmos I,
Fundamentos de Programação I,
Teoria Geral dos Sistemas eLógica para Computação
CURITIBA
2
2009
SUMÁRIO
1 INTRODUÇÃO...................................................................................................................4
1.1 TEMA................................................................................................................................4
1.2 OBJETO.............................................................................................................................4
1.3 OBJETIVOS......................................................................................................................4
1.3.1 Objetivo geral.................................................................................................................5
1.3.2 Objetivos específicos......................................................................................................5
1.4 JUSTIFICATIVA..............................................................................................................5
1.5 METODOLOGIA EMPREGADA....................................................................................6
2 MODELAGEM DO SISTEMA.........................................................................................7
2.1 DESCRIÇÃO DA EMPRESA...........................................................................................7
2.2 DIAGRAMAS DE FLUXO DE DADOS..........................................................................7
2.2.1 Diagrama de fluxo de dados no nível 0...........................................................................7
2.2.2 Diagramas de fluxo de dados no nível 1.........................................................................9
3 ESPECIFICAÇÃO............................................................................................................18
3.1 ESPECIFICAÇÃO FORMAL..........................................................................................18
3.1.1 Tipos do Sistema............................................................................................................18
3.1.2 Propriedades...................................................................................................................18
3.1.3 Funções..........................................................................................................................18
3.1.4 Estado do Sistema..........................................................................................................19
3.1.5 Estado Inicial.................................................................................................................19
3.1.6 Especificação formal das operações..............................................................................20
4 APLICAÇÃO DO SISTEMA...........................................................................................33
5 CONCLUSÕES..................................................................................................................34
6 REFERÊNCIAS.................................................................................................................35
3
1 INTRODUÇÃO
1.1 TEMA
O projeto tem como proposta a utilização dos conhecimentos adquiridos durante o
primeiro semestre do curso para a construção de um sistema de tráfego e controle de
informações entre as lojas de uma grande rede de lojas de departamento, analisado sobre
diferentes óticas (matriz e filial).
1.2 OBJETO
O sistema desenvolvido para promover a organização da situação da loja de
departamento, ou seja, um programa capaz de controlar os cadastros de produtos, clientes,
veículos, filiais, além de analisar dados e possibilitar o tráfego de informações de uma ou
mais filiais para a matriz. Tal objeto é desenvolvido na linguagem de programação JAVA
1.3 OBJETIVOS
4
1.3.1 Objetivo geral
O trabalho propõe o objetivo geral de integrar as áreas do conhecimento necessárias
para a criação de um sistema de uma rede de lojas de departamento, sendo que, esse programa
deve ser capaz de operar em condições minimamente realistas. As diferentes áreas que devem
ser utilizadas seriam a de modelagem, especificação formal do problema, criação de um
algoritmo para a realização dos processos e a implementação desse algoritmo com sucesso,
para tanto, a conexão de matérias deve, obrigatoriamente, existir.
1.3.2 Objetivos específicos
O programa desenvolvido deve ser capaz de organizar as mais diversas ações uma
grande rede de lojas de departamento fictícia através da entrada de informações por uma parte
humana. Ele deve possibilitar o cadastro dos mais variados produtos, organizando-os em um
arquivo possível de ser utilizado por todas as lojas, assim como criar outros arquivos
cadastrando os clientes, os veículos usados no transporte de mercadorias e todas as lojas da
rede (com seus respectivos estoques), além de fornecer informações importantes para a matriz
melhor gerenciar a situação da rede de departamento. Mais que isso, o sistema tem como
objetivo principal fazer com que todas as filiais da rede possam requisitar produtos em falta à
matriz, trazendo realidade ao projeto. As habilidades de programação, criação de resoluções
para um problema complexo e definição do escopo de ação do sistema são outros aspectos
que o trabalho visa analisar e, assim, verificar a capacidade de abstração dos alunos de
Bacharelado em Sistemas de Informação.
1.4 JUSTIFICATIVA
Trabalho proposto pelo Departamento Acadêmico de Informática da Universidade
Tecnológica do Paraná (UTFPR) aos alunos do primeiro período de Bacharelado em Sistemas
de Informação, tendo como criador do projeto o professor e coordenador do curso Gustavo
5
Alberto Gimenez Lugo e como responsável direto pelo trabalho o professor Adolfo Gustavo
Serra Seca Neto.
1.5 METODOLOGIA EMPREGADA
Durante o processo de realização muitas ferramentas foram utilizadas, ente elas
destacam-se: a modelagem com os diagramas de fluxos de dados (tanto em nível 0 como em
nível 1), baseados inteiramente no conhecimento adquirido durante as aulas de Teoria Geral
de Sistemas e reproduzidos utilizando o software SmartDraw2009 que apesar de ser pago no
concedeu 7 dias de uso livre, a especificação formal de cada processo realizado pelo
programa, feita em linguagem Z (conhecimento retirado do livro Especificações em Z do
autor Arnaldo Vieira Moura) e utilização do software livre NetBeans, programa utilizado
durante toda o procedimento de implementação do algoritmo para gerar o código em
linguagem JAVA e para testes. O software Látex foi usado para a edição da parte escrita.
6
2 MODELAGEM DO SISTEMA
2.1 DESCRIÇÃO DA EMPRESA
Há uma empresa varejista “Loja de Departamentos”, formada por uma matriz e suas
filiais, cujo objetivo é comercializar diversos produtos. Essa empresa possui um conjunto
limitado de veículos, controlados pela matriz, e que servem para o transporte de mercadorias.
Todas as filiais da empresa têm sua localização determinada em um mapa e possuem
o seu próprio estoque. Já na matriz, localiza-se o estoque central (único capaz de fazer
compras de novos produtos), e por isso ela centraliza todas as requisições efetuadas pelas
filiais, cada qual responsável por seu estoque.
Para efetuar vendas no varejo, é necessário verificar se o cliente está cadastrado no
sistema. Se o estoque da filial onde o cliente se encontra possui o produto, a entrega é
imediata. Caso contrário, a filial deve requerer o produto à matriz.
Estas requisições contém o código da filial, o código da requisição e uma lista de
códigos dos produtos desejados e suas respectivas quantidades. A matriz verifica a situação
dos veículos da empresa e dos estoques, comandando uma movimentação de produtos para
atender à filial e informando o prazo de entrega.
2.2 DIAGRAMAS DE FLUXOS DE DADOS
2.2.1 Diagrama de fluxo de dados no nível 0
7
Figura 1 – Processo nível 0
Fonte: realização própria
8
2.2.2 Diagrama de fluxo de dados no nível 1
Figura 2 – Processo 01Fonte: realização própria GERAR PEDIDO
Um pedido feito pelo cliente é armazenado nesse processo. A loja pega os dados do
cliente e verificam se ele existe, assim como verificam se o código do produto pedido existe e
se a quantidade do produto requisitado está presente no estoque dessa filial. O pedido é
armazenado.
9
Figura 3 – Processo 02
Fonte: realização própria
REQUISITAR MATERIAL DA MATRIZA filial, ao perceber que existem pedidos que não foram atendidos na hora, gera
requisições de produtos para a filial. Nessas requisições estão o código do produto
requisitado, sua quantidade e o código da filial que as geraram. Essas requisições são
armazenadas e, futuramente, serão atendidas pela matriz.
10
Figura 4 – Processo 04
Fonte: realização própria
REPOR ESTOQUE DA FILIALAssim que os novos produtos chegarem, o código dessa requisição fornece os
códigos dos produtos requisitados e suas quantidades para que o estoque da filial
abastecida tenha seus dados incrementados.
11
Figura 5 – Processo 07,08 e 09
Fonte: realização própria
CADASTRAR PRODUTOA matriz entra com os dados do produto novo que será revendido pela rede de
departamentos, esses dados incluem o nome, preço de venda, preço de compra e volume
(tamanho) do produto. Após o processo, o produto receberá um código único e todos esses
dados serão armazenados.
CADASTRAR CAMINHÃOA matriz, ao adquirir um novo caminhão, passa dados essenciais ao sistema para
serem armazenados, entre eles estão: a placa do caminhão, sua velocidade média de uso e
sua capacidade. O sistema gerará um código único para o caminhão e o marcará como
“disponível para uso”.
12
CADASTRAR FILIALAssim que a rede de departamentos adquire uma nova filial, a matriz entra com
os dados dessa filial para serem armazenados (nome da filial, seu endereço, a distância
entre a filial e a matriz e a capacidade do estoque). O sistema se encarrega de criar um
código único para a filial, assim como cadastrar o estoque da filial com o mesmo código
da filial.
13
Figura 6 – Processo 10
Fonte: realização própria
GERAR RELATÓRIOSA matriz pode, a qualquer tempo, mandar um sinal que deseja relatórios dos
estoques e dos caminhões. A situação de todos os estoques (quantidade de cada produto) e
dos caminhões (estado de cada caminhão) será enviada à matriz. Esse processo não altera
o sistema.
14
Figura 7– Processo 11
Fonte: realização própria
CADASTRAR CLIENTE
Processo básico de cadastramento de clientes da rede, o cpf e o nome da pessoa são
armazenados pelo atendente da loja que o recebeu.
15
Figura 8– Processo 12
Fonte: realização própria
EXCLUIR FILIAL
Se, por algum acaso, alguma filial pare de ser parte da rede de departamentos,
seus dados serão apagados do cadastro. Para isso, a matriz passa o código para o sistema
que se encarregará de apagar os dados.
16
Figura 9 – Processo 03
Fonte: realização própria
ATENDEDER REQUISIÇÃOA matriz checa o banco de dados de requisições e tenta atendê-las.
Primeiramente, verifica caso os produtos estão disponíveis no seu estoque ou em estoques
de outras matrizes, depois ela checa se existem caminhões disponíveis para fazer a entrega
do pedido. A última etapa é mandar uma previsão para a filial de chegada dos pedidos
requisitados, alterar a situação dos caminhões para “não disponíveis”, atualizar os
estoques de onde os produtos foram retirados
17
3 ESPECIFICAÇÃO
3.1 Especificação formal
Sistema: Loja de departamento
3.1.1 Tipos do Sistema
• Tipos pré-definidos: [TEXTO, INTEIRO, REAL]
• FILIAL = <nome: TEXTO, endereço: TEXTO, distância: REAL,
capacidade_estoque:
• REAL, cód_filial : INTEIRO>
• CAMINHAO =<placa:TEXTO, velocidade:REAL, capacidade:REAL,
cód_caminhão:REAL, disponibilidade: REAL>
• PRODUTO = <cód_produto:INTEIRO, nome:TEXTO, tamanho:REAL,
preço_compra:REAL, preço_venda:REAL>
• PEDIDO = <cpf_cliente:INTEIRO, cód_produto:INTEIRO, qtde: INTEIRO>
• REQUISICAO = <qtde_necessária:INTEIRO, cód_filial:INTEIRO,
cód_requisição:INTEIRO, cód_produto:INTEIRO>
• ESTOQUE = < [<cód_produto:INTEIRO, qtde: INTEIRO>], cap_estoque:REAL,
cód_estoque:INTEIRO>
• CLIENTE = <cód_cliente:INTEIRO, nome: TEXTO, cpf: INTEIRO>
3.1.2 Propriedades
• Novo(e,_): verdadeiro se o que foi criado em “_” não existe na entidade “e”.
• Vazio(c): verdadeiro se o campo “c” é vazio.
3.1.3 Funções
18
• Tempo(x,y): marca o tempo que o caminhão levará para chegar em seu destino,
baseado na velocidade média dele e na distância a ser percorrida.
• Dados(e,y): é verdadeiro se “y” pertence a entidade “e”.
• Emitir(e): escreve os dados da entidade “e”.
3.1.4 Estado do Sistema
Produtos: [PRODUTO]
Estoques: [ESTOQUE]
Requisicoes: [REQUISICAO]
Clientes: [CLIENTE]
Filiais: [FILIAL]
Pedido: [PEDIDO]
Caminhoes: [CAMINHAO]
3.1.5 Estado Inicial
InitSistema
produtos = ∅
estoques = ∅
requisições = ∅
clientes = ∅
filiais = ∅
pedido = ∅
caminhoes = ∅
19
3.1.6 Especificação formal das operações
3.1.6.1 - Cadastrar produto
∆ sistema
Nome?: Texto
Preço-venda?: real
Preço-compra?: real
Tamanho?: real
Cód-produto! : inteiro
Produto!: PRODUTO
Pré:
// não existe outro produto com o mesmo nome
Nome? ∉dados.(produtos,nome)
// o preço de compra deve ser menor que o preço de venda
Preço-compra? < Preço-venda?
// ambos os preços devem ser maiores que 0
Preço-compra > 0
preço-venda > 0
20
// o tamanho deve ser maior que 0
Tamanho > 0
// o nome não pode ser uma string vazia
¬vazio(nome?)
Pós:
//todos os dados de entrada devem ser aqueles armazenados no cadastro
Produto!.nome = nome?
produto!.preço-venda = preço-venda?
produto!.preço-compra = preço-compra?
produto!.tamanho = tamanho?
//cria-se um novo código para o produto, que ainda não existe
Novo (produto!.cód-produto!, produtos, cód-produto)
//o novo produto entra no cadastro
Produto! Є produtos’
3.1.6.2 - Cadastrar caminhão
∆ sistema
Placa?: Texto
21
Velocidade?: real
Capacidade?: real
Disponibilidade! : inteiro
Cód-caminhão! : inteiro
Caminhão!: CAMINHÃO
Pré:
//não existe caminhão com a mesma placa
Placa? ∉dados(caminhões,placa)
//a placa não é vazia
¬vazio(placa?)
//velocidade deve ser maior que 0
Velocidade? > 0
//a capacidade deve ser maior que 0
capacidade? > 0
Pós:
//todos os dados de entrada devem ser cadastrados no caminhão novo
Caminhão!.placa = placa?
caminhão!.velocidade = velocidade!
caminhão!.capacidade = capacidade?
22
// a disponibilidade é igual a 0 (siginifica que está disponível)
Caminhão.disponibilidade = 0
// um código diferente dos já existentes é criado para esse caminhão
Novo(caminhão!.cód_caminhão!, caminhões, cód_caminhão)
//novo caminhão agora está cadastrado
Caminhão! Є Caminhões’
3.1.6.3 - Cadastrar filial
∆ sistema
Nome?: Texto
Endereço?: Texto
Distância?: real
Cap_estoque?: real
Cód_filial!: int
Filial!: FILIAL
Estoque!: ESTOQUE
Pré:
//nome da filial não pode ser vazio
¬vazio(nome?)
23
//nome da filial não pode existir
nome? ∉dados(filiais,nome)
//o endereço da filial não pode ser vazio
¬vazio(endereço?)
//endereço da filial não pode já estar cadastrado
endereço? ∉dados(filiais,endereço)
//a capacidade do estoque deve ser maior que 0
Cap_estoque? > 0
//a distância entre a matriz e a filial deve ser maior que 0
distância > 0
Pós:
// nova filial recebe os dados entrados
Filial!.nome = nome?
filial!.endereço = endereço?
filial!.distancia = distancia?
// cria-se um código novo para essa filial (não é código de nenhuma outra filial pré-existente)
Novo(filial!.cód-filial!, filiais, cód-filial)
// cria-se um estoque dessa filial com a capacidade de estoque e código da filial
Estoque!.capacidade = cap-estoque? ^ estoque!.código = cód-filial
24
// tanto o estoque como a filial são cadastrados e armazenados
Estoque! Є estoques’
filial! Є filiais’
3.1.6.4 - Cadastrar cliente
∆ sistema
nome?: String
cpf?: Int
clientes Є P CLIENTE
cliente!: CLIENTE
Pré
//nome não nulo
¬vazio(nome?:)
//cpf maior que 0
cpf? > 0
//cpf não existente antes
cpf? ∉dados(clientes, cpf)
Pós
25
//dados de entrada são os dados do novo cliente
cliente!.cpf = cpf?
cliente!.nome = nome?
//cliente entra no cadastro
cliente! E clientes`
3.1.6.5 - Gerar Pedido
∆ sistema
cpf_cliente?: Real
qtde?: Int
cód_produto?: Int
pedidos’: PEDIDO
pedido! : PEDIDO
Pré:
//o cpf do cliente deve existir
cpf! E dados(clientes, cpf)
//qtde maior que 0
qtde? > 0
//código do produto existe
26
cód_produto Є dados(produtos, código)
Pós:
//cria um novo código para o pedido
novo(pedido!.código, pedidos, código)
//verificação de valores (dados entrados iguais aos armazenados)
pedido!.qtde = qtde?
pedido!.cód_produto = cód_produto?
pedido!.cliente = cpf_cliente?
//guarda pedido
pedido! Є pedidos`
3.1.6.6 - Requisitar material da matriz
∆ sistema
cód_filial?: Inteiro
qtde_necessária?: Inteiro
cód_produto?: Inteiro
cód_requisição!: Inteiro
requisição!: REQUISIÇÃO
27
Pré:
//qtde necessária maior que 0
qtde_necessária? > 0
//código do produto existe
cód_produto? Є dados(produtos, cód_produto)
//código da filial existe
cód_filial? Є dados(filiais, dados)
//o tamanho do produto não pode ser maior que o do estoque
Produto.tamanho * qtde_necessária? < estoque.capacidade
Pós:
//criar novo código de requisição
nova(requisição!.cód_requisição, requisições, cód_requisição)
//verificação de valores armazenados
requisição!.cód_produto = cód_produto?
requisição.qde_necessária = qtde_necessária!
requisição!.cód_filial = cód_filial?
//guarda a requisição
requisição! Є requisições`
28
3.1.6.7 – Atender Requisição
∆ sistema
cod_requisicao?: INTEIRO
caminhão: CAMINHAO
filial: FILIAL
prazo_entrega! : String
Pré:
//o código de requisição deve existir
Cód_requisição! Є dados(requisições, cód_requisiçao)
Pós:
//Um prazo de entrega será feito
Prazo_entrega! = tempo(caminhão,filial)
//O caminhão estará ocupado
Caminhão.disponibilidade = 1
3.1.6.8 - Atualizar Estoque da Filial
∆ sistema
29
cod_requisicao?: inteiro
cod_produto?: inteiro
cód_estoque? : inteiro
quantidade?: INTEIRO
caminhão!: CAMINHAO
estoque : ESTOQUE
Pré:
//O código de requisição, do produto e do estoque deve existir.
cod_produto? Є dados(produtos,cod_produto)
//O código de requisição deve existir.
cod_requisicao? Є dados(requisicoes,cod_requisicao)
//O código do estoque deve existir.
cod_estoque? Є dados(estoques,cod_estoque)
//A quantidade deve ser maior que 0
Quantidade? > 0
//A requisição deve conter o código do produto e a quantidade pedida
Contem(cod_requisição?, cod_produto?, quantidade?)
Pós:
// O estoque terá a quantidade do produto “x” igual a quantidade antiga somada a nova
30
estoque’.quantidade = estoque. quantidade + quantidade?
//O código de requisição some
cod_requisicao requisicoes∉
//O caminhao está disponivel
Caminhao.disponibilidade = 0
3.1.6.9 - Excluir Filial
∆ sistema
Cod_filial?: inteiro
Cod_estoque?:inteiro
Pré:
//O código entrado deve existir
Cod_filial E dados(filiais, cod_filiais)
//O código de estoque é igual ao código da filial
Cód_estoque = cod_filial
Pós:
//A filial e seu estoque não existem mais
Cód_filial ∉filiais ^ cód_estoque ∉estoques
31
3.1.6.10 - Gerar Relatório
Ξ sistema
NomeEntidade? : TEXTO
Relatório!:TEXTO
Pré:
//Nome da entidade não vazio
¬vazio(nomeEntidade?)
Pós:
//D,,,ados serão emitidos
relatório! = emitir(NomeEntidade?)
32
4 APLICAÇÃO DO SISTEMA
Para a utilização do “cadastro produto” o sistema responderia da seguinte forma: Na
janela principal do sistema, serão pedidas duas senhas, a da matriz (que liberará as ações da
matriz) e da filial (liberará ações da filial), nesse caso, digite a senha da matriz “Matriz”,
habilitando a opção de cadastrar produto. Ao clicar no item de menu, uma nova janela será
aberta e ela deverá conter campos e texto que pedem o nome do produto, o preço de compra,
preço de venda e tamanho (volume).
Após digitar tais informações, deve-se clicar no botão “Cadastrar produto”, ao fazê-
lo, uma mensagem aparecerá do lado direito da janela, indicando se o cadastro foi bem
sucedido ou não. Caso o cadastro tenha sido bem sucedido, os dados do produto serão
armazenados em um arquivo de texto, com um código único e seqüencial criado pelo
programa, caso contrário, podem existir diversos motivos que geraram a não conclusão do
cadastro, eles seriam: preço de compra maior que preço de venda, algum dos preços ser um
valor negativo ou zero, o tamanho do produto ser zero ou negativo, nesses casos, basta digitar
os dados do produto e tentar novamente, entretanto, caso um produto com o mesmo nome já
tenha sido cadastrado, uma mensagem diferente aparecerá e você deverá alterar o nome do
produto.
Todos os casos de “não sucesso” ferem a especificação formal do processo e, com
diz a especificação, um novo código é criado e o produto é armazenado com suas
informações.
Como não fomos capazes de produzir o programa em sua totalidade, não podemos
analisar de forma ampla os resultados, somente o faremos dos processos que foram
reproduzidos no programa. Os cadastros, principalmente, foram feitos de forma a facilitar a
busca de dados, organizados linha por linha, com um código crescente à frente dos dados
específicos, uma espécie de índice indexado foi criado dessa forma, baseado na ordem de
cadastro. A geração de requisição criou certos problemas, pois a verificação era mais
complexa e deveria ser feita em diversos arquivos diferentes. A parte que mais deu orgulho
foi a interface gráfica, fácil de ser utilizada, entretanto, eficiente e agradável. O software
NetBeans facilitou a produção do código, permitindo diversos testes e a visualização da
interface gráfica antes de sua aplicação.
33
5 CONCLUSÕES
Com a realização desse trabalho é possível observar o alto grau de conexão que
modelagem, especificação formal, criação e implementação do algoritmo possuem. A cada
novo passo do processo, era necessário recorrer aos passos anteriores, senão para conseguir
concluir o novo estágio, para ter certeza de que erros crassos não estavam prestes a acontecer.
O desenvolvimento de um sistema não é algo trivial e requer muito pensamento e
dedicação, os resultados obtidos nem sempre são os desejados e, para mudá-los, uma
capacidade de adaptação deve ser treinada. Da mesma forma, essa habilidade é obrigatória
para adequar o seu pensamento ao pensamento do seu cliente, uma vez que, as características
básicas de um sistema é ele quem fornece.
Provavelmente, a maior dificuldade é relacionar todos os processos e objetos
envolvidos em um sistema orientado ao objeto, o pensamento não está acostumado a pensar o
que cada peça integrante faz, mas sim vê o programa como um todo que deve realizar funções
específicas, para realizar OO, deve treinar muito o pensamento através de pequenos exercícios
que, aos poucos, adaptem a imagem “desconstruída” do programa no nosso cérebro.
A expectativa para trabalhos futuros é nada mais que a melhora contínua da
programação, aumentar a capacidade de representação da realidade no programa e,
conseqüentemente, sua produtividade.
34
6 REFERÊNCIAS
SILVA, Flávio S. C. da; FINGER, Marcelo; MELO, Ana C. V. de. Lógica para
Computação. São Paulo: Thomson Learning, 2006.
MOURA, Arnaldo V. Especificações em z. São Paulo: UNICAMP, 2002.
DEITEL, Harvey M.; DEITEL, Paul J. Java: Como programar. Nacional: Prentice-Hal,
2005.
35