VisualG Algoritmo controle de estoque

Renan Vinycius · 26 de julho de 2021

Preciso de ajuda urgente para uma atividade.

Estudo de Caso

Uma empresa solicitou o desenvolvimento de um sistema, na qual passou alguns requisitos básicos, identificados pelo analista de requisitos, e estes foram estruturados e passados para a equipe de desenvolvimento. A feature consiste em elaborar um controle de estoque em tempo de execução.

REQUISITOS:

- Cadastrar produto, alterar produto, excluir produto, consultar produto. Vender produto, consultar estoque.
- Produtor deve conter: descrição, nome e quantidade e código.
- Criar critério após encerrar programa apresentar se algum produto precisa ser comprado para repor estoque, considerar estoque baixo, 30% da quantidade cadastrada.
- Elaborar os menus recursivos na qual você pode avançar e voltar nos menu.
- Comentar código usando // para cada estrutura para facilitar os próximos desenvolvedores a entender seu algoritmo e continuar o desenvolvimento (boas praticas de programação).
- Devido a necessidade de se desenvolver em 15 dias a empresa contratou mais um profissional de analise e desenvolvimento de sistemas para realizar a entrega em tempo hábil.

Kamuri · 27 de julho de 2021

O que você fez até agora? Aqui não você não vai conseguir uma resposta pronta, só se tiver dificuldade em algo que você já fez ou tentou fazer, ai tentaremos ajudar.

Renan Vinycius · 27 de julho de 2021

eu peguei um exemplo de um tópico passado aqui do fórum, estou estudando ele, porém vai faltar a parte da venda do produto, quando alguem comprar algo, diminuir automaticamente do estoque a quantidade do produto escolhido.

segue o tópico acima, eu exclui algumas coisas e editando outras, mas vou precisar de uma ajuda pra fazer a parte de venda que a minha atividade pediu.

Simon Viegas · 27 de julho de 2021

@Renan Vinycius, poste o que já fez e qual parte está com dúvidas.

Sobre:

13 horas atrás, Renan Vinycius disse:

estou estudando ele, porém vai faltar a parte da venda do produto, quando alguém comprar algo, diminuir automaticamente do estoque a quantidade do produto escolhido.

Crie um procedimento... que recebe o código do produto que está sendo atualizado e a quantidade de itens que foram vendidos. Não implemente a parte da venda... isso é de outro escopo... Você simplesmente precisa saber qual produto está sendo vendido (código do produto) e quantos foram vendidos (a quantidade), daí atualiza o estoque.

De início NÃO se preocupe com Regra de Negócios, ou seja: sempre suponha que todos os dados serão digitados corretamente; que não vai "vender uma quantidade que existe no estoque"; que não vai informar um código de produto inválido etc. Deixa isso para depois... O mais importante é a base.

Renan Vinycius · 28 de julho de 2021

procedimento venda()
inicio
   escreval("Insira o código do produto que deseja vender:")
   leia(icod)

   se (icod >=1) E (icod <= codItem) então //verificar se é um código válido
      escreval("Código : ", icod) //o código é a posição no vetor!!!
      escreval("Descrição : ", descricoes[icod])
      escreval("Quantidade :", quantidades[icod])
      escreval("Valor de venda : R$", precosVendas[icod], " por unidade")
      escreval()
      escreval("Quantas unidades deseja vender?")
      leia(vendaqtt)
      escreval("Foram vendidas", vendaqtt, " unidades do produto ", descricoes[icod])
      escreval()
      escreval("Pressione ENTER para continuar")
      leia(opc)
   fimSe
fimProcedimento

esse é o procedimento de venda que eu fiz, esta funcionando tudo certinho, porém falta a parte que voce falou sobre tirar do estoque automaticamente quando eu faço o procedimento de venda ai

Simon Viegas · 29 de julho de 2021

Bastaria fazer algo como:

quantidades[icod] <- quantidades[icod] - vendaqtt

Sobre o programa em si... Uma proposta que poderia ser interessante seria você separar a parte do "domínio" com a parte da "interface"...

Como assim? Então, por exemplo, para cadastrar, você teria uma função responsável em "coletar os dados do produto" (interface) e outra função para "cadastrar esses dados no vetor" (domínio).

Fiz um esboço.. vê se consegue aproveitar alguma coisa:

algoritmo "Controle de Estoque"
// Disciplina  :
// Professor   :
// Descrição   :
// Autor(a)    : Renan Vinycius)
// Data atual  : 29/07/2021


//REQUISITOS:

// 1 Funcionalidades do sistema
// 1.1 Cadastrar produto
// 1.2 Alterar produto
// 1.3 Excluir produto
// 1.4 Consultar produto
// 1.5 Vender produto
// 1.6 Consultar estoque

// 2 Atributos de um produto
// 2.1 Descrição
// 2.2 Mome
// 2.3 Quantidade
// 2.4 Código.

// 3 Criar critério após encerrar programa apresentar se algum produto precisa
// ser comprado para repor estoque, considerar estoque baixo, 30% da quantidade
// cadastrada.

// 4 Elaborar os menus recursivos na qual você pode avançar e voltar nos menu.


//Responsável em cadastar um produto no vetor
//Parâmetros
//1-Produto a ser cadastrado
procedimento CadastrarProduto()
inicio
   totalProdutos <- totalProdutos+1 //atualiza o total de produtos cadastrados
   produtos[totalProdutos] <- produtoAux //cadastra na posição correspondente

   //ADENDO: esse "produtoAux" seria um parâmetro do procedimento, mas o
   //VisualG não suporta (não foi implementado ainda). Daí, para contornar,
   //declarei como uma variável global e acesso diretamente (simulando o parâmetro).
   //ADENDO 2: tanto o vetor, tatno a total de itens cadastrados também deveriam
   //vir por parâmetro, mas fica mais prático acessá-los diretamente pelas variáveis
   //globais. (obs.: não é possível passar um vetor por parâmetro no VisualG)
fimProcedimento

//Responsável em alterar um produto no vetor
//Parâmetros:
//1-Produto alterado
//2-Posição do produto
procedimento AlterarProduto(p: inteiro)
inicio
   produtos[p] <- produtoAux
fimProcedimento

//Responsável em excluir um produto no vetor
//Parâmetro:
//1-Posição do produto a ser excluído
procedimento ExluirProduto(p: inteiro)
inicio

fimProcedimento

//Responsável em exibir os dados de um produto
//Parâmetro:
//1-Posição do produto
procedimento ExibirProduto(p: inteiro)
inicio
   escreva (produtos[p].nome:20)
   escreva ("":3, produtos[p].codigo:3)
   escreva ("":3, produtos[p].descricao:20)
   escreva ("":3, produtos[p].quantidade:3)
   escreval()
fimProcedimento





//Responsável em coletar os dados de um produto novo e "solicitar" cadastro no vetor
//Parâmetro: NENHUM
procedimento TelaCadastrarProduto()
var
   novoProduto: t_Produto
   sucesso: logico
inicio
   //aqui fluxo para para solicitar e ler os dados do produto
   //vou criar um produto aleatório, diretamente, apenas para teste
   novoProduto.codigo <- Randi(100)
   novoProduto.nome <- "Produto " + NumPCarac(Randi(100000))
   novoProduto.descricao <- "Descrição teste"
   novoProduto.quantidade <- 50+Randi(50)

   //aqui vai cadastrar o produto no esoquete
   //o produto deveria ser passado por parâmetro, mas como não funciona no
   // VisualG,
   //daí, copia numa variável auxiliar e utiliza a variável lá no procedimento
   produtoAux <- novoProduto
   CadastrarProduto()
fimProcedimento


procedimento BuscarProdutoPorCodigo()
inicio

fimProcedimento

//Responsável em verificar qual produto vai ser alterar, coletar os novos dados
//e solicitar o cadastro da alteração no vetor
//Parâmetro: NENHUM
procedimento TelaAlterarProduto()
var
   produtoAlterado: t_produto
   posProdutoAlterar: inteiro
inicio
   //quero alterar o produto 2
   posProdutoAlterar <- 2
   //copio o produto que quero alterar
   produtoAlterado <- produtos[posProdutoAlterar]
   //altero o que quero alterar (no exemplo, removendo 10 da quantidade)
   produtoAlterado.quantidade <- produtoAlterado.quantidade-10

   produtoAux <- produtoAlterado
   AlterarProduto(2)
fimProcedimento

tipo
   t_Produto = registro
      codigo: inteiro
      nome: caractere
      descricao: caractere
      quantidade: inteiro
   fimRegistro

var
   produtos: vetor [1..10] de t_Produto
   totalProdutos: inteiro //total de produtos cadastrados
   produtoAux: t_Produto //variável utilizanda para pasasr um produto para as funções

inicio
   totalProdutos <- 0 //inicializar com 0 produtos cadastrados

   TelaCadastrarProduto()
   ExibirProduto(1)

   TelaCadastrarProduto()
   ExibirProduto(2)

   TelaCadastrarProduto()
   ExibirProduto(3)

   escreval()
   escreval()
   TelaAlterarProduto()
   ExibirProduto(2)
fimAlgoritmo

Renan Vinycius · 30 de julho de 2021

Até agora consegui incrementar quase tudo, falta a parte de excluir produto e de avisar quando X produto esta com 30% ou menos no estoque.

Gostei do resultado, já mostra na tela de venda quantas unidades do produto sobraram.

O código por enquanto esta assim. Caso tenha algo errado ou que possa melhorar, pode avisar, ficarei grato!

algoritmo "Controle de Estoque"
// Disciplina  : Laboratório de algoritmo
// Professor   : Douglas Ferrari
// Descrição   : Estudo de caso (Controle de estoque)
// Autor(a)    : Renan Vinycius)
// Data atual  : 29/07/2021

//REQUISITOS:

// 1 Funcionalidades do sistema
// 1.1 Cadastrar produto
// 1.2 Alterar produto
// 1.3 Excluir produto
// 1.4 Consultar produto
// 1.5 Vender produto
// 1.6 Consultar estoque

// 2 Atributos de um produto
// 2.1 Nome
// 2.2 Quantidade
// 2.3 Código
// 2.4 Preço
var
   //dados do produto (cada vetor é um atributo)
   descricoes  :vetor [1..4] de caractere
   quantidades :vetor [1..4] de inteiro
   precosVendas:vetor [1..4] de real
   //Vetores do estoque
   vendaqtt   :inteiro    //definir a quantidade de tal produto
   codItem    :inteiro    //código do produto cadastrado
   opc,opc2   :caractere  //selecionar as opções do menu
   fimcad     :real       //usado para acompanhar a exibição do ultimo cadastro
   icod       :inteiro    //usado para ler o código do menu editar
   remov      :inteiro    //usado para recadastrar a quantidade de itens
procedimento cadastro_item
//Responsável em cadastar um produto no vetor
//1-Produto a ser cadastrado
inicio

   codItem <- codItem+1 //constante que dará o código ao produto
   escreval("**  Cadastro de produto  **")
   escreva ("Descrição :")
   leia(descricoes[codItem])
   escreva ("Quantidade :")
   leia(quantidades[codItem])
   escreva ("Valor de venda :")
   leia (precosVendas[codItem])
   limpatela
   //Abaixo irá mostrar o produto cadastrado e suas informações
   escreval()
   escreval()
   escreval ("Produto cadastrado :",descricoes[coditem])
   escreval ("Código :",coditem)
   escreval ("Quantidade :",quantidades[coditem])
   escreval ("Valor de venda : R$",precosVendas[coditem])
   escreval()
   escreval ("Para visualizar o código novamente, imprima o relatório")
   escreval ("de produtos.")
   escreval()
   escreval("Pressione ENTER para voltar ao menu")
   leia(opc)
fimProcedimento

procedimento imprimir_produtos()//Responsável em exibir os dados dos produtos
var
   i :inteiro
inicio
   escreval("Você possui no estoque os seguintes itens: ")
   para i de 1 ate codItem faca //do primeiro até a quantidade já cadastrada
      escreval()
      escreval("Código :",i)
      escreval("Descrição : ",descricoes[i])
      escreval("Quantidade :",quantidades[i])
      escreval("valor de venda : R$",precosVendas[i])
      escreval("------------------------------------------")
      escreval()
   fimpara
   escreva ("Pressione ENTER para voltar ao menu")
   leia(opc)
fimProcedimento

procedimento editar()
//Responsável em verificar qual produto vai se alterar, coletar os novos dados
//e solicitar o cadastro da alteração no vetor
var
   novaQtd :inteiro
inicio
   escreval("Insira o código do produto que deseja pesquisar: ")
   leia(icod)
   se (icod >=1) E (icod <= codItem) então //verificar se é um código válido
      escreval("Código :",icod) //o código é a posição no vetor!!!
      escreval("Descrição :",descricoes[icod])
      escreval("Quantidade :",quantidades[icod])
      escreval("valor de venda : R$",precosVendas[icod])
      escreval()
      escreval("Digite a nova quantidade do estoque, ou")
      escreval("caso não queira modificar, digite a quantidade atual.")
      leia(novaQtd)
      quantidades[icod]:=novaQtd //atualiza a quantidade caso tenha alteraçao
      escreval("O produto ",descricoes[icod]," agora possui ",quantidades[icod]," unidades")
      escreval()
      escreval("Pressione ENTER para continuar")
      leia (opc)
   fimse
fimprocedimento

procedimento venda()
var
   i :inteiro
inicio
   escreval("Você possui no estoque os seguintes itens: ")
   para i de 1 ate codItem faca //do primeiro até a quantidade já cadastrada
      escreval()
      escreval("Código :",i)
      escreval("Descrição : ",descricoes[i])
      escreval("Quantidade :",quantidades[i])
      escreval("valor de venda : R$",precosVendas[i])
      escreval("------------------------------------------")
      escreval()
   fimpara
   escreval("Insira o código do produto que deseja vender:")
   leia(icod)
   se (icod >=1) E (icod <= codItem) então //verificar se é um código válido
      escreval("Descrição :",descricoes[icod])
      escreval("Quantidade :",quantidades[icod])
      escreval("Valor de venda : R$",precosVendas[icod], " por unidade")
      escreval()
      escreval("Quantas unidades deseja vender?")
      leia (vendaqtt)
      escreval()
      escreval("Foram vendidas",vendaqtt," unidades por R$",precosVendas[icod] * vendaqtt)
      escreval()
      quantidades[icod] <- quantidades[icod] - vendaqtt
      escreval("A quantidade de ",descricoes[icod]," foi atualizada!")
      escreval()
      escreval("Pressione ENTER para continuar")
      leia (opc)
   fimse
fimprocedimento

procedimento menu_estoque()
inicio
   repita
      limpaTela
      escreval("-----------ESTOQUE-----------")
      escreval()
      escreval("       1-Cadastro de produto    ")
      escreval("       2-Pesquisar/Editar   ")
      escreval("       3-Venda de mercadoria       ")
      escreval("       5-Sair                ")
      escreval()
      escreval("       0-*Imprimir produtos  ")
      escreval()
      escreval("  Possuem atualmente",codItem," produtos")
      escreval("     cadastrados no estoque!")
      escreval()
      escreva ("Comando: ")
      leia(opc)
      escolha (opc)
      caso "1"
         limpatela
         cadastro_item() //cadastrar produto
      caso "2"
         limpatela
         editar() //pesquisar ou editar item ja cadastrado
      caso "3"
         limpatela
         venda() //vender produto
      caso "0"
         limpatela
         imprimir_produtos() //mostra na tela os produtos ja cadastrados
      caso "5"
      fimEscolha //finaliza o programa
   ate opc="5"
fimProcedimento


INICIO
   codItem <- 0  //inicializa o controlador de código
   menu_estoque()
FIMALGORITMO

Simon Viegas · 30 de julho de 2021

Sobre:

16 horas atrás, Renan Vinycius disse:

[...] falta a parte de excluir produto

Crie outro vetor, por exemplo:

excluidos   :vetor [1..4] de logico

Quando cadastrar:

excluidos[posicaoItem] <- FALSO

Obs.: no VisualG já ficará automaticamente com FALSO, mas atribua manualmente o valor!

Quando excluir:

excluidos[posicaoItem] <- VERDADEIRO

Obs. 2: lembrando que FALSO e VERDADEIRO são valores... ficam sem aspas mesmo.

Ah! vale salientar que na exclusão NÃO se apagar os dados.. apenas "marca como excluído". Normalmente também o registro fica lá... ou seja: uma vez usado, um mesmo código não pode ser reutilizado por outro produto.

Precisará ajustar o restante do código para verificar esse dado..., por exemplo: só vai imprimir os que "não estão excluídos"... Aí verifique quais partes... Mais abaixo tem um exemplo...

Sobre:

16 horas atrás, Renan Vinycius disse:
   codItem <- codItem+1 //constante que dará o código ao produto

Se o valor está sendo atualizado, não faz sentido em falar em "constante". Isso é uma variável. E acho que faria mais sentido algo assim:

Em 29/07/2021 às 13:18, Simon Viegas disse:
totalProdutos <- totalProdutos+1 //atualiza o total de produtos cadastrados

Se quiser deixar o código ainda mais semântico, poderia fazer algo assim:

totalProdutos <- totalProdutos+1 //atualiza o total de produtos cadastrados
codItem <- totalProdutos //código do próximo cadastro

Outra coisa... separe a "consulta de estoque" da "venda de produtos". Na hora de vender, não precisaria listar... o cara vai lá e informa o produto que quer... (Ou ele já sabe qual é, ou ele foi antes no menu e consultou.)

Para imprimir todos os produtos ou editar, está precisando imprimir um produto... perceba que são praticamente a mesma coisa, ou seja: está repetitivo... poderia criar um procedimento para listar um produto.. daí chama essa função em ambos métodos (listar e editar... e onde quiser mais).

Exemplo:

procedimento imprimir_produto(cod: inteiro)
inicio
   se ((cod >= 1) E (cod <= totalProdutos)) entao //verifica se é um código válido
      se (não excluidos[cod]) entao //verifica se está excluído
         escreval()
         escreval("Código        : ", cod:1)
         escreval("Descrição     : ", descricoes[cod])
         escreval("Quantidade    : ", quantidades[cod]:1)
         escreval("valor de venda: R$", precosVendas[cod]:1:2)
         escreval("------------------------------------------")
         escreval()
      senao
         escreval("Item ", cod:1, " está excluído")
      fimSe
   senao
      escreval("Código ", cod:1, " é inválido")
   fimSe
fimProcedimento

Vê se as ideias vão fazendo sentido e vai adaptando ao seu código.

Sobre:

16 horas atrás, Renan Vinycius disse:

avisar quando X produto esta com 30% ou menos no estoque

Aí você precisa pensar numa forma de ter um valor como base... quando o programa encerrar, verificaria qual a porcentagem da quantidade atual dos produtos em relação a esse quantidade base...

Ah! a depender crie um outro vetor para armazenar a quantidade padrão...

Niê · 2 de agosto de 2021

Caramba fico felizão por ver que minhas dúvidas antigas serviram de ajuda, não desista nunca cara, hoje trabalho com desenvolvimento e to feliz nisso! Boa sorte.

Caso precise do código com as últimas modificações que fiz, só falar, dou uma procurada no meu drive.

Renan Vinycius · 6 de agosto de 2021

Oi, eu não consegui fazer a parte de exclusao e aviso quando estava com 30% abaixo do estoque, mas agradeço de coração pela ajuda que vocês me forneceram, fico imensamente grato com a colaboraçao de todos, acabei de apresentar o estudo!

O tópico pode ser fechado já, e qualquer dúvida que eu tenha com futuras questões, eu venho tentar resolve-las aqui.

Muito obrgiado Simon Viegas pela ajuda desde o começo e Niê pela inspiração que seu tópico passado me deu, estava totalmente perdido nessa área, mas com as partes sinalizadas la explicando o que cada coisa faz me auxiliou de uma forma imensa!

Simon Viegas · 6 de agosto de 2021

10 horas atrás, Renan Vinycius disse:

Oi, eu não consegui fazer a parte de exclusão

Qual é a dificuldade? Siga o modelo:

Em 30/07/2021 às 13:45, Simon Viegas disse:
Crie outro vetor, por exemplo:
excluidos   :vetor [1..4] de logico
Quando cadastrar:
excluidos[posicaoItem] <- FALSO
Obs.: no VisualG já ficará automaticamente com FALSO, mas atribua manualmente o valor!

Quando excluir:
excluidos[posicaoItem] <- VERDADEIRO

Esse "posicaoItem" seria qualquer variável, ou valor, que conterá a posição que quer verificar...

Você só vai trabalhar com os arquivos que não estão excluídos... daí, só verificar no momento propício:

Em 30/07/2021 às 13:45, Simon Viegas disse:
se (não excluidos[cod]) entao //verifica se está excluído

PS: é o mesmo que:

se (não (excluidos[cod] = VERDADEIRO)) entao //verifica se está excluído

ou

se (excluidos[cod] = FALSO) entao //verifica se está excluído

PS: o se fica aguardando um lógico, certo? Daí, normalmente utilizamos um operador relacional (nesse exemplo o "=") para que o resultado seja um valor lógico... como a própria variável do vetor já é um valor lógico, então pode ser utilizado diretamente... ali no se pode colocar qualquer coisa... o importante que o resultado final seja um lógico.

sda