refactor(persistence): move entity-model conversion to adapters

improve docs
refactor products by category list to use name

Author: g-otn

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/in/controller/client/ClientController.java

@@ -3,6 +3,7 @@
 import br.com.grupo63.techchallenge.adapter.in.controller.AbstractController;
 import br.com.grupo63.techchallenge.adapter.in.controller.dto.DefaultResponseDTO;
 import br.com.grupo63.techchallenge.core.application.usecase.client.ClientUseCase;
+import br.com.grupo63.techchallenge.core.application.usecase.client.IClientUseCase;
 import br.com.grupo63.techchallenge.core.application.usecase.dto.ClientDTO;
 import br.com.grupo63.techchallenge.core.application.usecase.exception.NotFoundException;
 import io.swagger.v3.oas.annotations.Operation;
@@ -22,7 +23,7 @@
 @RequestMapping("/clientes")
 public class ClientController extends AbstractController {
 
-    private final ClientUseCase useCase;
+    private final IClientUseCase useCase;
 
     @Operation(
             summary = "Find a client by their national id",
@@ -37,7 +38,7 @@ public ClientDTO findByNationalId(@PathVariable String nationalId) throws NotFou
             summary = "Identificação: Identifica um cliente",
             description = "Registra um cliente com seu CPF")
     @PostMapping("/criar")
-    public ResponseEntity<ClientDTO> create(@RequestParam String nationalId) {
+    public ResponseEntity<ClientDTO> create(@RequestParam String nationalId) throws NotFoundException {
         ClientDTO clientDTO = new ClientDTO(nationalId);
         return ResponseEntity.ok(useCase.create(clientDTO));
     }

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/in/controller/order/OrderController.java

@@ -23,15 +23,15 @@
 @RequestMapping("/pedidos")
 public class OrderController extends AbstractController {
 
-    private final IOrderUseCase orderUseCase;
+    private final IOrderUseCase useCase;
 
     @Operation(
             tags = "5ª chamada - fluxo principal",
             summary = "Listar pedidos pagos porém não finalizados.",
             description = "Seria utilizado pelo monitor no restaurante para exibir os pedidos em preparação e prontos")
     @GetMapping("/listar-fila")
     public ResponseEntity<List<OrderDTO>> listUnfinishedOrders() {
-        return ResponseEntity.ok(orderUseCase.listUnfinishedOrders());
+        return ResponseEntity.ok(useCase.listUnfinishedOrders());
     }
 
     @Operation(
@@ -41,7 +41,7 @@ public ResponseEntity<List<OrderDTO>> listUnfinishedOrders() {
     @PostMapping("/avancar-estado")
     @ResponseStatus(HttpStatus.OK)
     public void advanceOrderStatusFromOrderId(@Parameter(description = "Id do pedido.") @RequestParam Long orderId) throws NotFoundException, ValidationException {
-        orderUseCase.advanceStatus(orderId);
+        useCase.advanceStatus(orderId);
     }
 
     @Operation(
@@ -52,7 +52,7 @@ public void advanceOrderStatusFromOrderId(@Parameter(description = "Id do pedido
     public ResponseEntity<OrderDTO> create(@RequestParam Long clientId,
                                            @RequestBody CreateOrderRequestDTO createOrderRequestDTO) throws NotFoundException {
 
-        return ResponseEntity.ok(orderUseCase.create(createOrderRequestDTO.toDomainDto(clientId)));
+        return ResponseEntity.ok(useCase.create(createOrderRequestDTO.toDomainDto(clientId)));
     }
 
     @Operation(
@@ -61,31 +61,31 @@ public ResponseEntity<OrderDTO> create(@RequestParam Long clientId,
             description = "Find a order by their id.")
     @GetMapping("/{id}")
     public ResponseEntity<OrderDTO> read(@PathVariable("id") Long id) throws NotFoundException {
-        return ResponseEntity.ok(orderUseCase.read(id));
+        return ResponseEntity.ok(useCase.read(id));
     }
 
     @Operation(
             summary = "List all order",
             description = "List all orders.")
     @GetMapping("/listar")
     public ResponseEntity<List<OrderDTO>> list() {
-        return ResponseEntity.ok(orderUseCase.list());
+        return ResponseEntity.ok(useCase.list());
     }
 
     @Operation(
             summary = "Update an order",
             description = "Update an order in the database with the DTO data.")
 //    @PutMapping("/{id}")
     public ResponseEntity<OrderDTO> update(@RequestBody OrderDTO dto, @PathVariable("id") Long id) throws NotFoundException {
-        return ResponseEntity.ok(orderUseCase.update(dto, id));
+        return ResponseEntity.ok(useCase.update(dto, id));
     }
 
     @Operation(
             summary = "Delete a client",
             description = "Delete a client in the database by their id.")
     @DeleteMapping("/{id}")
     public ResponseEntity<DefaultResponseDTO> delete(@PathVariable("id") Long id) throws NotFoundException {
-        orderUseCase.delete(id);
+        useCase.delete(id);
         return ResponseEntity.ok().build();
     }
 

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/in/controller/payment/PaymentController.java

@@ -20,7 +20,7 @@
 @RequestMapping("/pagamentos")
 public class PaymentController extends AbstractController {
 
-    private final IPaymentUseCase paymentUseCase;
+    private final IPaymentUseCase useCase;
 
     @Operation(
             tags = "3ª chamada - fluxo principal",
@@ -30,7 +30,7 @@ public class PaymentController extends AbstractController {
     public QRCodeResponseDTO startPayment(
             @Parameter(description = "Id do pedido") @RequestParam Long orderId
     ) throws NotFoundException, ValidationException {
-        String qrData = paymentUseCase.startPayment(orderId);
+        String qrData = useCase.startPayment(orderId);
         return new QRCodeResponseDTO(qrData);
     }
 
@@ -42,7 +42,7 @@ public QRCodeResponseDTO startPayment(
     @ResponseStatus(HttpStatus.OK)
     public void confirmPaymentFromOrderId(@Parameter(description = "Id do pedido associado ao pagamento")
                                           @RequestParam Long orderId) throws ValidationException, NotFoundException {
-        paymentUseCase.finishPayment(orderId);
+        useCase.finishPayment(orderId);
     }
 
     @Operation(
@@ -52,7 +52,7 @@ public void confirmPaymentFromOrderId(@Parameter(description = "Id do pedido ass
     @GetMapping("/status")
     public PaymentStatusResponseDTO getStatusByOrderId(@Parameter(description = "Id do pedido associado ao pagamento")
                                                        @RequestParam Long orderId) throws NotFoundException, ValidationException {
-        PaymentStatus status = paymentUseCase.getPaymentStatus(orderId);
+        PaymentStatus status = useCase.getPaymentStatus(orderId);
         return new PaymentStatusResponseDTO(status);
     }
 

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/in/controller/product/ProductController.java

@@ -4,8 +4,10 @@
 import br.com.grupo63.techchallenge.adapter.in.controller.dto.DefaultResponseDTO;
 import br.com.grupo63.techchallenge.core.application.usecase.dto.ProductDTO;
 import br.com.grupo63.techchallenge.core.application.usecase.exception.NotFoundException;
+import br.com.grupo63.techchallenge.core.application.usecase.product.IProductUseCase;
 import br.com.grupo63.techchallenge.core.application.usecase.product.ProductUseCase;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
@@ -20,13 +22,14 @@
 @RequestMapping("/produtos")
 public class ProductController extends AbstractController {
 
-    private final ProductUseCase useCase;
+    private final IProductUseCase useCase;
 
     @Operation(
-            summary = "Registers a product",
-            description = "Register a new product in the database with the DTO data.")
+            summary = "Criar um produto",
+            description = "Cria um produto com nome, preço, estoque inicial e categoria. Possíveis categorias (IDs): " +
+                    "1 - Lanche, 2 - Acompanhamento, 3 - Bebida, 4 - Sobremesa")
     @PostMapping("/criar")
-    public ResponseEntity<ProductDTO> create(@Valid @RequestBody ProductDTO dto) {
+    public ResponseEntity<ProductDTO> create(@Valid @RequestBody ProductDTO dto) throws NotFoundException {
         return ResponseEntity.ok(useCase.create(dto));
     }
 
@@ -64,10 +67,12 @@ public ResponseEntity<DefaultResponseDTO> delete(@PathVariable("id") Long id) th
     }
 
     @Operation(
-            summary = "List all products by category",
-            description = "List all products by category.")
+            summary = "Listar produtos por categoria",
+            description = "Lista todos os produtos por nome da categoria")
     @GetMapping("/listar-por-categoria")
-    public ResponseEntity<List<ProductDTO>> listByCategoryId(@RequestParam(value = "categoria") String categoryId) throws NotFoundException {
-        return ResponseEntity.ok(useCase.listByCategoryId(Long.valueOf(categoryId)));
+    public ResponseEntity<List<ProductDTO>> listByCategoryName(
+            @Schema(allowableValues = {"Lanche", "Acompanhamento", "Bebida", "Sobremesa"})
+            @RequestParam(value = "categoria") String categoryName) {
+        return ResponseEntity.ok(useCase.listByCategoryName(categoryName));
     }
 }

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/out/repository/IJpaRepository.java

@@ -0,0 +1,16 @@
+package br.com.grupo63.techchallenge.adapter.out.repository;
+
+import br.com.grupo63.techchallenge.adapter.out.repository.product.entity.ProductEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface IJpaRepository<E> {
+
+    Optional<E> findByIdAndDeletedFalse(Long id);
+
+    List<E> findByDeletedFalse();
+
+
+}

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/out/repository/client/ClientJpaAdapter.java

@@ -0,0 +1,46 @@
+package br.com.grupo63.techchallenge.adapter.out.repository.client;
+
+import br.com.grupo63.techchallenge.adapter.out.repository.client.entity.ClientEntity;
+import br.com.grupo63.techchallenge.core.application.repository.IClientRepository;
+import br.com.grupo63.techchallenge.core.domain.model.client.Client;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Component
+@RequiredArgsConstructor
+public class ClientJpaAdapter implements IClientRepository {
+
+    private final ClientJpaRepository jpaRepository;
+
+    @Override
+    public List<Client> findByDeletedFalse() {
+        return jpaRepository.findByDeletedFalse().stream()
+                .map(ClientEntity::toModel)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Client saveAndFlush(Client client) {
+        ClientEntity entity = new ClientEntity(client);
+
+        entity = jpaRepository.saveAndFlush(entity);
+
+        return entity.toModel();
+    }
+
+    @Override
+    public Optional<Client> findByNationalId(String nationalId) {
+        return jpaRepository.findByNationalIdAndDeletedFalse(nationalId)
+                .map(ClientEntity::toModel);
+    }
+
+    @Override
+    public Optional<Client> findByIdAndDeletedFalse(Long id) {
+        return jpaRepository.findByIdAndDeletedFalse(id)
+                .map(ClientEntity::toModel);
+    }
+}

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/out/repository/client/ClientJpaRepository.java

@@ -0,0 +1,16 @@
+package br.com.grupo63.techchallenge.adapter.out.repository.client;
+
+import br.com.grupo63.techchallenge.adapter.out.repository.IJpaRepository;
+import br.com.grupo63.techchallenge.adapter.out.repository.client.entity.ClientEntity;
+import br.com.grupo63.techchallenge.core.domain.model.client.Client;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface ClientJpaRepository extends JpaRepository<ClientEntity, Long>, IJpaRepository<ClientEntity> {
+
+    Optional<ClientEntity> findByNationalIdAndDeletedFalse(String nationalId);
+
+}

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/out/repository/client/ClientRepository.java

@@ -0,0 +1,49 @@
+package br.com.grupo63.techchallenge.adapter.out.repository.order;
+
+import br.com.grupo63.techchallenge.adapter.out.repository.order.entity.OrderEntity;
+import br.com.grupo63.techchallenge.core.application.repository.IOrderRepository;
+import br.com.grupo63.techchallenge.core.domain.model.order.Order;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Component
+@RequiredArgsConstructor
+public class OrderJpaAdapter implements IOrderRepository {
+
+    private final OrderJpaRepository jpaRepository;
+
+    @Override
+    public List<Order> findByStatusNotFinishedAndDeletedOrderByCreationDate() {
+        return jpaRepository.findByStatusNotFinishedAndDeletedOrderByCreationDate().stream()
+                .map(OrderEntity::toModel)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Optional<Order> findByIdAndDeletedFalse(Long id) {
+        return jpaRepository.findByIdAndDeletedFalse(id)
+                .map(OrderEntity::toModel);
+    }
+
+    @Override
+    @Transactional
+    public Order saveAndFlush(Order order) {
+        OrderEntity entity = new OrderEntity(order);
+
+        entity = jpaRepository.saveAndFlush(entity);
+
+        return entity.toModel();
+    }
+
+    @Override
+    public List<Order> findByDeletedFalse() {
+        return jpaRepository.findByDeletedFalse().stream()
+                .map(OrderEntity::toModel)
+                .toList();
+    }
+}

techchallenge/src/main/java/br/com/grupo63/techchallenge/adapter/out/repository/order/OrderJpaAdapter.java

@@ -0,0 +1,28 @@
+package br.com.grupo63.techchallenge.adapter.out.repository.order;
+
+import br.com.grupo63.techchallenge.adapter.out.repository.IJpaRepository;
+import br.com.grupo63.techchallenge.adapter.out.repository.order.entity.OrderEntity;
+import br.com.grupo63.techchallenge.core.domain.model.order.Order;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface OrderJpaRepository extends JpaRepository<OrderEntity, Long>, IJpaRepository<OrderEntity> {
+
+    @Query("SELECT " +
+            "   order " +
+            "FROM " +
+            "   OrderEntity order " +
+            "WHERE " +
+            "   order.status IN ('RECEIVED', 'PREPARING', 'READY') " +
+            "   AND order.deleted = false " +
+            "ORDER BY " +
+            "   order.creationDate")
+    List<OrderEntity> findByStatusNotFinishedAndDeletedOrderByCreationDate();
+
+}