Merge pull request #63 from RavinProject/issue-47-gerenciar-mesas

Issue 63 - Gerenciamento de Reservas
RavinProject · Aug 2, 2023 · 376e851 · 376e851
2 parents 3601d78 + a233861
commit 376e851
Show file tree

Hide file tree

Showing 66 changed files with 815 additions and 341 deletions.
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
diff --git a/README.md b/README.md
@@ -20,15 +20,15 @@ Antes de começar, certifique-se de ter o seguinte instalado em seu sistema:
 ```bash
 git clone https://github.com/RavinProject/ProjetoRavin.git
 ```
-1. Navegue até o diretório que contém a classe principal `App.java`:
+2. Navegue até o diretório que contém a classe principal `App.java`:
 ```bash
 cd ProjetoRavin/src/main/java/org/ravin
 ```
-1. Compile o código:
+3. Compile o código:
 ```bash
 javac App.java
 ```
-1. Execute a classe principal:
+4. Execute a classe principal:
 ```bash
 java App
 ```
@@ -43,7 +43,7 @@ java App
 | Estoque     | ✔️               | ✔️             | ✔️                   | ✔️               |
 | Funcionário | ✔️               | ✔️             | ✔️                   | ✔️               |
 | Mesa        | ✔️               | ✔️             | ✔️                   | ✔️               |
-| Reserva     | 🚧               | 🚧             | 🚧                   | 🚧               | 
+| Reserva     | ✔️               | ✔️             | ✔️                   | ✔️               | 
 | Pedido      | 🚧               | 🚧             | 🚧                   | 🚧               |
 | Produto     | ✔️               | ✔️             | ✔️                   | ✔️               |
 

diff --git a/src/dao/interfaces/IFuncionarioRepositorio.java b/src/dao/interfaces/IFuncionarioRepositorio.java
diff --git a/src/main/java/org/ravin/controllers/ClienteController.java b/src/main/java/org/ravin/controllers/ClienteController.java
@@ -9,9 +9,9 @@
 import java.util.Optional;
 
 public class ClienteController implements IClienteController {
-
-    // Injeção de dependência
+
     private final IClienteService clienteService;
+
     public ClienteController(IClienteService clienteService) {
         this.clienteService = clienteService;
     }
@@ -22,7 +22,12 @@ public void inserir(Cliente objeto) {
     }
 
     @Override
-    public Cliente recuperarPorId(int id) throws EntidadeNaoEncontradaException {
+    public void atualizar(Cliente objeto) {
+        clienteService.atualizar(objeto);
+    }
+
+    @Override
+    public Cliente recuperarPorId(int id) throws EntidadeNaoEncontradaException{
         Optional<Cliente> cliente = clienteService.recuperarPorId(id);
         if (cliente.isPresent()) {
             return cliente.get();
@@ -47,13 +52,8 @@ public List<Cliente> recuperarTodos() {
     }
 
     @Override
-    public void atualizar(Cliente objeto) {
-        clienteService.atualizar(objeto);
-    }
-
-    @Override
-    public boolean remover(Cliente objeto) {
-        clienteService.remover(objeto);
+    public boolean remover(Cliente cliente) {
+        clienteService.remover(cliente);
         return true;
     }
 }
diff --git a/src/main/java/org/ravin/controllers/EstoqueController.java b/src/main/java/org/ravin/controllers/EstoqueController.java
@@ -10,8 +10,8 @@
 
 public class EstoqueController implements IEstoqueController {
 
-    // Injeção de dependência
     private final IEstoqueService estoqueService;
+
     public EstoqueController(IEstoqueService estoqueService){
         this.estoqueService = estoqueService;
     }

diff --git a/src/main/java/org/ravin/controllers/MesaController.java b/src/main/java/org/ravin/controllers/MesaController.java
@@ -20,19 +20,19 @@ public void inserir(Mesa mesa) {
 
     @Override
     public Mesa recuperarPorId(int id) throws EntidadeNaoEncontradaException {
-        Optional<Mesa> mesa = mesaService.recuperarPorId(id);
-        if (mesa.isPresent()) {
-            return mesa.get();
+        Optional<Mesa> oMesa = mesaService.recuperarPorId(id);
+        if (oMesa.isPresent()) {
+            return oMesa.get();
         } else {
             throw new EntidadeNaoEncontradaException("Mesa não encontrada para o ID: " + id);
         }
     }
 
     @Override
     public Mesa recuperarPorCodigo(String codigo) throws EntidadeNaoEncontradaException {
-        Optional<Mesa> mesa = mesaService.recuperarPorCodigo(codigo);
-        if (mesa.isPresent()) {
-            return mesa.get();
+        Optional<Mesa> oMesa = mesaService.recuperarPorCodigo(codigo);
+        if (oMesa.isPresent()) {
+            return oMesa.get();
         } else {
             throw new EntidadeNaoEncontradaException("Mesa não encontrada para o Codigo: " + codigo);
         }

diff --git a/src/main/java/org/ravin/controllers/ProdutoController.java b/src/main/java/org/ravin/controllers/ProdutoController.java
@@ -11,8 +11,8 @@
 
 public class ProdutoController implements IProdutoController {
 
-    // Injeção de dependência
     private final IProdutoService produtoService;
+
     public ProdutoController(IProdutoService produtoService){
         this.produtoService = produtoService;
     }

diff --git a/src/main/java/org/ravin/controllers/ReservaController.java b/src/main/java/org/ravin/controllers/ReservaController.java
@@ -4,10 +4,12 @@
 import org.ravin.models.Cliente;
 import org.ravin.models.Mesa;
 import org.ravin.models.Reserva;
-import org.ravin.services.interfaces.IReservaService;
+import org.ravin.services.reserva.interfaces.IReservaService;
+import org.ravin.utils.exceptions.EntidadeNaoEncontradaException;
+import org.ravin.utils.exceptions.MesaNaoDisponivelException;
 
-import java.util.Date;
 import java.util.List;
+import java.util.Optional;
 
 public class ReservaController implements IReservaController {
 
@@ -16,48 +18,56 @@ public class ReservaController implements IReservaController {
     public ReservaController(IReservaService reservaService) {
         this.reservaService = reservaService;
     }
-    @Override
-    public void inserir(Reserva reserva) {
-        reservaService.inserir(reserva);
-    }
 
-    @Override
-    public Reserva recuperarPorId(int id) {
-        return null;
-    }
 
     @Override
-    public List<Reserva> recuperarTodos() {
-        return reservaService.recuperarTodos();
+    public void inserir(Reserva reserva) throws MesaNaoDisponivelException {
+        try {
+            reservaService.inserir(reserva);
+        } catch (org.ravin.utils.exceptions.DataIndisponivelException e) {
+            throw new RuntimeException(e);
+        } catch (org.ravin.utils.exceptions.ComandaEmMesaException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     @Override
-    public void atualizar(Reserva objeto) {
-
+    public Reserva recuperarPorId(int id) throws EntidadeNaoEncontradaException {
+        Optional<Reserva> oReserva = reservaService.recuperarPorId(id);
+        if (oReserva.isPresent()) {
+            return oReserva.get();
+        } else {
+            throw new EntidadeNaoEncontradaException("Reserva não encontrada para o ID: " + id);
+        }
     }
 
     @Override
-    public boolean remover(Reserva objeto) {
-        return false;
+    public List<Reserva> recuperarTodos() {
+        return reservaService.recuperarTodos();
     }
 
     @Override
-    public void reservarMesa(Cliente cliente, Mesa mesa, Date data) {
-
+    public void atualizar(Reserva reserva) {
+        reservaService.atualizar(reserva);
     }
 
     @Override
-    public List<Reserva> recuperarPorCliente(Cliente cliente) {
-        return null;
+    public boolean remover(Reserva reserva) {
+        try {
+            reservaService.remover(reserva);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
     }
 
     @Override
-    public Reserva recuperarPorMesa(Mesa mesa) {
-        return null;
+    public List<Reserva> recuperarReservasPorCliente(Cliente cliente) {
+        return reservaService.recuperarReservasPorCliente(cliente);
     }
 
     @Override
-    public List<Reserva> recuperarReservasPorCodigo(String codigoMesa) {
-        return null;
+    public List<Reserva> recuperarReservasPorMesa(Mesa mesa) {
+        return reservaService.recuperarReservasPorMesa(mesa);
     }
 }
diff --git a/src/main/java/org/ravin/controllers/interfaces/IController.java b/src/main/java/org/ravin/controllers/interfaces/IController.java
@@ -1,3 +1,11 @@
+/**
+ * Interface para definir a funcionalidade básica de um controlador.
+ *
+ * <p>Esta interface define as operações básicas de CRUD (criar, ler, atualizar e deletar) para um objeto genérico.
+ * Ela pode ser implementada por qualquer controlador que necessite dessas operações.
+ *
+ * @param <T> o tipo do objeto a ser gerenciado pelo controlador.
+ */
 package org.ravin.controllers.interfaces;
 
 import org.ravin.utils.exceptions.EntidadeNaoEncontradaException;

diff --git a/src/main/java/org/ravin/controllers/interfaces/IEstoqueController.java b/src/main/java/org/ravin/controllers/interfaces/IEstoqueController.java
@@ -1,9 +1,30 @@
+/**
+ * Interface para definir a funcionalidade de um controlador de estoque.
+ *
+ * <p>Essa interface estende {@code IController<Estoque>} para fornecer funcionalidades específicas para gerenciar um estoque.
+ * As operações adicionais incluem a recuperação de um estoque por código e a verificação se um estoque já foi cadastrado.
+ *
+ * @see IController
+ */
 package org.ravin.controllers.interfaces;
 
 import org.ravin.models.Estoque;
 import org.ravin.utils.exceptions.EntidadeNaoEncontradaException;
 
 public interface IEstoqueController extends IController<Estoque>{
+    /**
+     * Recupera um estoque por seu código.
+     *
+     * @param codigo O código do estoque a ser recuperado.
+     * @return O objeto Estoque correspondente ao código fornecido.
+     * @throws EntidadeNaoEncontradaException Se o estoque com o código fornecido não for encontrado.
+     */
     Estoque recuperarPorCodigo(String codigo) throws EntidadeNaoEncontradaException;
+    /**
+     * Verifica se um estoque já foi cadastrado.
+     *
+     * @param codigo O código do estoque a ser verificado.
+     * @return {@code true} se o estoque com o código fornecido já foi cadastrado, {@code false} caso contrário.
+     */
     boolean estoqueJaCadastrado(String codigo);
 }
diff --git a/src/main/java/org/ravin/controllers/interfaces/IReservaController.java b/src/main/java/org/ravin/controllers/interfaces/IReservaController.java
@@ -3,15 +3,22 @@
 import org.ravin.models.Cliente;
 import org.ravin.models.Mesa;
 import org.ravin.models.Reserva;
+import org.ravin.utils.exceptions.EntidadeNaoEncontradaException;
+import org.ravin.utils.exceptions.MesaNaoDisponivelException;
 
-import java.util.Date;
 import java.util.List;
 
-public interface IReservaController extends IController<Reserva> {
-    void reservarMesa(Cliente cliente, Mesa mesa, Date data);
-    List<Reserva> recuperarPorCliente(Cliente cliente);
+public interface IReservaController {
 
-    Reserva recuperarPorMesa(Mesa mesa);
+    // Separei IReservaController de IServices para não misturar o exception com a assinatura da interface IService
 
-    List<Reserva> recuperarReservasPorCodigo(String codigoMesa);
+    void inserir(Reserva reserva) throws MesaNaoDisponivelException;
+    Reserva recuperarPorId(int id) throws EntidadeNaoEncontradaException;
+    List<Reserva> recuperarTodos();
+    void atualizar(Reserva reserva) throws EntidadeNaoEncontradaException;
+    boolean remover(Reserva reserva) throws EntidadeNaoEncontradaException;
+
+    List<Reserva> recuperarReservasPorCliente(Cliente cliente);
+
+    List<Reserva> recuperarReservasPorMesa(Mesa mesa);
 }
diff --git a/src/main/java/org/ravin/dao/CardapioRepositorioLista.java b/src/main/java/org/ravin/dao/CardapioRepositorioLista.java
@@ -13,7 +13,7 @@ public void inserir(Cardapio object) {
     }
 
     @Override
-    public List<Cardapio> pegarLista() {
+    public List<Cardapio> recuperarTodos() {
         return null;
     }
 

diff --git a/src/main/java/org/ravin/dao/ClienteRepositorioLista.java b/src/main/java/org/ravin/dao/ClienteRepositorioLista.java
@@ -33,7 +33,7 @@ public Optional<Cliente> recuperarPorId(int id) {
     }
 
     @Override
-    public Optional<Cliente> recuperarPorCpf(String cpf) {
+    public Optional<Cliente> recuperarClientePorCpf(String cpf) {
         // Itera pela lista e tenta encontrar um cliente com o CPF fornecido
         for (Cliente cliente : listaClientes) {
             if (cliente.getCpf().equals(cpf)) {
@@ -43,8 +43,9 @@ public Optional<Cliente> recuperarPorCpf(String cpf) {
         return Optional.empty();
     }
 
+
     @Override
-    public List<Cliente> pegarLista() {
+    public List<Cliente> recuperarTodos() {
         return listaClientes;
     }
 

diff --git a/src/main/java/org/ravin/dao/ComandaRepositorioLista.java b/src/main/java/org/ravin/dao/ComandaRepositorioLista.java
@@ -2,10 +2,13 @@
 
 import org.ravin.dao.interfaces.IComandaRepositorioLista;
 import org.ravin.models.Comanda;
+import org.ravin.models.Mesa;
+import org.ravin.utils.enums.StatusComanda;
 
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 public class ComandaRepositorioLista implements IComandaRepositorioLista {
     private final List<Comanda> listaComanda;
@@ -18,11 +21,11 @@ public ComandaRepositorioLista(List<Comanda> listaComanda) {
     @Override
     public void inserir(Comanda comanda) {
 
-        pegarLista().add(comanda); // Adiciona a cliente na lista
+        listaComanda.add(comanda);
     }
 
     @Override
-    public List<Comanda> pegarLista() {
+    public List<Comanda> recuperarTodos() {
         return listaComanda;
     }
 
@@ -33,16 +36,16 @@ public Optional<Comanda> recuperarPorId(int id) {
 
     @Override
     public void atualizar(Comanda comandaAtualizada) {
-        for (int i = 0; i < pegarLista().size(); i++) {
-            if (pegarLista().get(i).getId() == comandaAtualizada.getId()) {
-                pegarLista().set(i, comandaAtualizada);
+        for (int i = 0; i < listaComanda.size(); i++) {
+            if (listaComanda.get(i).getId() == comandaAtualizada.getId()) {
+                listaComanda.set(i, comandaAtualizada);
                 break;
             }
         }
     }
 
     @Override
-    public void remover(Comanda object) {
+    public void remover(Comanda comanda) {
 
     }
 
@@ -60,4 +63,17 @@ public Optional<Comanda> recuperarComandaPorCodigo(String codigo) {
         }
         return Optional.empty();
     }
+
+    @Override
+    public List<Comanda> recuperarListaPorMesaEStatus(Mesa mesa, StatusComanda statusComanda) {
+        return listaComanda.stream().
+                filter(c -> c.getMesa().equals(mesa) && c.getStatusComanda().equals(statusComanda)).
+                collect(Collectors.toList());
+    }
+
+    @Override
+    public int getId(Comanda comanda) {
+        return IComandaRepositorioLista.super.getId(comanda);
+    }
+
 }