Exception mapping

pom.xml

@@ -49,6 +49,11 @@
       <artifactId>quarkus-hibernate-orm</artifactId>
     </dependency>
 
+    <dependency>
+      <groupId>io.quarkus</groupId>
+      <artifactId>quarkus-hibernate-validator</artifactId>
+    </dependency>
+
     <!-- JDBC driver dependencies -->
     <dependency>
       <groupId>io.quarkus</groupId>
@@ -225,7 +230,6 @@
           </execution>
         </executions>
       </plugin>
-
     </plugins>
   </build>
   <profiles>

src/main/java/com/devonfw/quarkus/general/service/exception/ApplicationBusinessException.java

@@ -0,0 +1,34 @@
+package com.devonfw.quarkus.general.service.exception;
+
+public abstract class ApplicationBusinessException extends RuntimeException {
+
+  public ApplicationBusinessException() {
+
+    super();
+  }
+
+  public ApplicationBusinessException(String message) {
+
+    super(message);
+  }
+
+  public ApplicationBusinessException(String message, Exception e) {
+
+    super(message, e);
+  }
+
+  public boolean isTechnical() {
+
+    return false;
+  }
+
+  public String getCode() {
+
+    return getClass().getSimpleName();
+  }
+
+  public Integer getStatusCode() {
+
+    return null;
+  }
+}

src/main/java/com/devonfw/quarkus/general/service/exception/InvalidParameterException.java

@@ -0,0 +1,20 @@
+package com.devonfw.quarkus.general.service.exception;
+
+public class InvalidParameterException extends ApplicationBusinessException {
+
+  public InvalidParameterException() {
+
+    super();
+  }
+
+  public InvalidParameterException(String message) {
+
+    super(message);
+  }
+
+  @Override
+  public Integer getStatusCode() {
+
+    return Integer.valueOf(422);
+  }
+}

src/main/java/com/devonfw/quarkus/general/service/exception/mapper/AbstractExceptionMapper.java

@@ -0,0 +1,58 @@
+package com.devonfw.quarkus.general.service.exception.mapper;
+
+import java.time.ZonedDateTime;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public abstract class AbstractExceptionMapper {
+
+  protected boolean exposeInternalErrorDetails = false;
+
+  @Context
+  UriInfo uriInfo;
+
+  protected void logError(Exception exception) {
+
+    log.error("Exception:{},URL:{},ERROR:{}", exception.getClass().getCanonicalName(), this.uriInfo.getRequestUri(),
+        exception.getMessage());
+  }
+
+  protected Response createResponse(int status, String errorCode, Exception exception) {
+
+    Map<String, Object> jsonMap = new HashMap<>();
+    jsonMap.put("errorCode", errorCode);
+    if (this.exposeInternalErrorDetails) {
+      jsonMap.put("message", getExposedErrorDetails(exception));
+    } else {
+      jsonMap.put("message", exception.getMessage());
+    }
+    jsonMap.put("uri", this.uriInfo.getPath());
+    jsonMap.put("timestamp", ZonedDateTime.now().toString());
+    return Response.status(status).type(MediaType.APPLICATION_JSON).entity(jsonMap).build();
+  }
+
+  protected String getExposedErrorDetails(Throwable error) {
+
+    StringBuilder buffer = new StringBuilder();
+    Throwable e = error;
+    while (e != null) {
+      if (buffer.length() > 0) {
+        buffer.append(System.lineSeparator());
+      }
+      buffer.append(e.getClass().getSimpleName());
+      buffer.append(": ");
+      buffer.append(e.getLocalizedMessage());
+      e = e.getCause();
+    }
+    return buffer.toString();
+  }
+
+}

src/main/java/com/devonfw/quarkus/general/service/exception/mapper/NotFoundExceptionMapper.java

@@ -0,0 +1,19 @@
+package com.devonfw.quarkus.general.service.exception.mapper;
+
+import javax.ws.rs.NotFoundException;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class NotFoundExceptionMapper extends AbstractExceptionMapper implements ExceptionMapper<NotFoundException> {
+
+  @Override
+  public Response toResponse(NotFoundException exception) {
+
+    logError(exception);
+
+    return createResponse(Status.NOT_FOUND.getStatusCode(), exception.getClass().getSimpleName(), exception);
+  }
+}

src/main/java/com/devonfw/quarkus/general/service/exception/mapper/RuntimeExceptionMapper.java

@@ -0,0 +1,46 @@
+package com.devonfw.quarkus.general.service.exception.mapper;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import com.devonfw.quarkus.general.service.exception.ApplicationBusinessException;
+
+@Provider
+public class RuntimeExceptionMapper extends AbstractExceptionMapper implements ExceptionMapper<RuntimeException> {
+
+  @Override
+  public Response toResponse(RuntimeException exception) {
+
+    logError(exception);
+
+    if (exception instanceof ApplicationBusinessException) {
+      return createResponse((ApplicationBusinessException) exception);
+    } else if (exception instanceof WebApplicationException) {
+      return createResponse((WebApplicationException) exception);
+    }
+
+    return createResponse(exception);
+  }
+
+  private Response createResponse(ApplicationBusinessException exception) {
+
+    int status = exception.getStatusCode() == null ? Status.BAD_REQUEST.getStatusCode() : exception.getStatusCode();
+    return createResponse(status, exception.getCode(), exception);
+  }
+
+  private Response createResponse(WebApplicationException exception) {
+
+    Status status = Status.fromStatusCode(exception.getResponse().getStatus());
+    return createResponse(status.getStatusCode(), exception.getClass().getSimpleName(), exception);
+  }
+
+  private Response createResponse(Exception exception) {
+
+    return createResponse(Status.INTERNAL_SERVER_ERROR.getStatusCode(), exception.getClass().getSimpleName(),
+        exception);
+  }
+
+}

src/main/java/com/devonfw/quarkus/general/service/exception/mapper/UnauthorizedExceptionMapper.java

@@ -0,0 +1,21 @@
+package com.devonfw.quarkus.general.service.exception.mapper;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import io.quarkus.security.UnauthorizedException;
+
+@Provider
+public class UnauthorizedExceptionMapper extends AbstractExceptionMapper
+    implements ExceptionMapper<UnauthorizedException> {
+
+  @Override
+  public Response toResponse(UnauthorizedException exception) {
+
+    logError(exception);
+
+    return createResponse(Status.UNAUTHORIZED.getStatusCode(), exception.getClass().getSimpleName(), exception);
+  }
+}

src/main/java/com/devonfw/quarkus/general/service/exception/mapper/ValidationExceptionMapper.java

@@ -0,0 +1,19 @@
+package com.devonfw.quarkus.general.service.exception.mapper;
+
+import javax.validation.ValidationException;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class ValidationExceptionMapper extends AbstractExceptionMapper implements ExceptionMapper<ValidationException> {
+
+  @Override
+  public Response toResponse(ValidationException exception) {
+
+    logError(exception);
+
+    return createResponse(Status.BAD_REQUEST.getStatusCode(), exception.getClass().getSimpleName(), exception);
+  }
+}

src/main/java/com/devonfw/quarkus/productmanagement/domain/repo/ProductRepository.java

@@ -1,16 +1,18 @@
 package com.devonfw.quarkus.productmanagement.domain.repo;
 
+import java.util.Optional;
+
 import org.springframework.data.domain.Page;
+import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.query.Param;
 
 import com.devonfw.quarkus.productmanagement.domain.model.ProductEntity;
 
-public interface ProductRepository extends CrudRepository<ProductEntity, Long>, ProductFragment {
+public interface ProductRepository extends JpaRepository<ProductEntity, Long>, ProductFragment {
 
   @Query("select a from ProductEntity a where title = :title")
-  ProductEntity findByTitle(@Param("title") String title);
+  Optional<ProductEntity> findByTitle(@Param("title") String title);
 
   Page<ProductEntity> findAllByOrderByTitle();
 }

src/main/java/com/devonfw/quarkus/productmanagement/logic/UcFindProductImpl.java

@@ -2,15 +2,18 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 import javax.inject.Inject;
 import javax.inject.Named;
 import javax.transaction.Transactional;
+import javax.ws.rs.NotFoundException;
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.PageRequest;
 
+import com.devonfw.quarkus.general.service.exception.InvalidParameterException;
 import com.devonfw.quarkus.productmanagement.domain.model.ProductEntity;
 import com.devonfw.quarkus.productmanagement.domain.repo.ProductRepository;
 import com.devonfw.quarkus.productmanagement.service.v1.mapper.ProductMapper;
@@ -24,15 +27,15 @@
 @Slf4j
 public class UcFindProductImpl implements UcFindProduct {
   @Inject
-  ProductRepository ProductRepository;
+  ProductRepository productRepository;
 
   @Inject
   ProductMapper mapper;
 
   @Override
   public Page<ProductDto> findProducts(ProductSearchCriteriaDto dto) {
 
-    Iterable<ProductEntity> productsIterator = this.ProductRepository.findAll();
+    Iterable<ProductEntity> productsIterator = this.productRepository.findAll();
     List<ProductEntity> products = new ArrayList<ProductEntity>();
     productsIterator.forEach(products::add);
     List<ProductDto> productsDto = this.mapper.map(products);
@@ -42,62 +45,66 @@ public Page<ProductDto> findProducts(ProductSearchCriteriaDto dto) {
   @Override
   public Page<ProductDto> findProductsByCriteriaApi(ProductSearchCriteriaDto dto) {
 
-    List<ProductEntity> products = this.ProductRepository.findAllCriteriaApi(dto).getContent();
+    List<ProductEntity> products = this.productRepository.findAllCriteriaApi(dto).getContent();
     List<ProductDto> productsDto = this.mapper.map(products);
     return new PageImpl<>(productsDto, PageRequest.of(dto.getPageNumber(), dto.getPageSize()), productsDto.size());
   }
 
   @Override
   public Page<ProductDto> findProductsByQueryDsl(ProductSearchCriteriaDto dto) {
 
-    List<ProductEntity> products = this.ProductRepository.findAllQueryDsl(dto).getContent();
+    List<ProductEntity> products = this.productRepository.findAllQueryDsl(dto).getContent();
     List<ProductDto> productsDto = this.mapper.map(products);
     return new PageImpl<>(productsDto, PageRequest.of(dto.getPageNumber(), dto.getPageSize()), productsDto.size());
   }
 
   @Override
   public Page<ProductDto> findProductsByTitleQuery(ProductSearchCriteriaDto dto) {
 
-    List<ProductEntity> products = this.ProductRepository.findByTitleQuery(dto).getContent();
+    List<ProductEntity> products = this.productRepository.findByTitleQuery(dto).getContent();
     List<ProductDto> productsDto = this.mapper.map(products);
     return new PageImpl<>(productsDto, PageRequest.of(dto.getPageNumber(), dto.getPageSize()), productsDto.size());
   }
 
   @Override
   public Page<ProductDto> findProductsByTitleNativeQuery(ProductSearchCriteriaDto dto) {
 
-    List<ProductEntity> products = this.ProductRepository.findByTitleNativeQuery(dto).getContent();
+    List<ProductEntity> products = this.productRepository.findByTitleNativeQuery(dto).getContent();
     List<ProductDto> productsDto = this.mapper.map(products);
     return new PageImpl<>(productsDto, PageRequest.of(dto.getPageNumber(), dto.getPageSize()), productsDto.size());
   }
 
   @Override
   public Page<ProductDto> findProductsOrderedByTitle() {
 
-    List<ProductEntity> products = this.ProductRepository.findAllByOrderByTitle().getContent();
+    List<ProductEntity> products = this.productRepository.findAllByOrderByTitle().getContent();
     List<ProductDto> productsDto = this.mapper.map(products);
     return new PageImpl<>(productsDto);
   }
 
   @Override
   public ProductDto findProduct(String id) {
 
-    ProductEntity product = this.ProductRepository.findById(Long.valueOf(id)).get();
-    if (product != null) {
-      return this.mapper.map(product);
-    } else {
-      return null;
+    try {
+      Optional<ProductEntity> product = this.productRepository.findById(Long.valueOf(id));
+      if (product.isPresent()) {
+        return this.mapper.map(product.get());
+      } else {
+        throw new NotFoundException();
+      }
+    } catch (NumberFormatException e) {
+      throw new InvalidParameterException("Unable to parse ID: " + id);
     }
   }
 
   @Override
   public ProductDto findProductByTitle(String title) {
 
-    ProductEntity product = this.ProductRepository.findByTitle(title);
-    if (product != null) {
-      return this.mapper.map(product);
+    Optional<ProductEntity> product = this.productRepository.findByTitle(title);
+    if (product.isPresent()) {
+      return this.mapper.map(product.get());
     } else {
-      return null;
+      throw new NotFoundException();
     }
   }
 }

src/main/java/com/devonfw/quarkus/productmanagement/logic/UcManageProduct.java

@@ -6,5 +6,5 @@
 public interface UcManageProduct {
   ProductDto saveProduct(NewProductDto dto);
 
-  ProductDto deleteProduct(String id);
+  void deleteProduct(String id);
 }