Add AbstractService and get route for configurationFile controller.

src/main/java/org/cerberus/controllers/ApplicationController.java

@@ -4,9 +4,11 @@ import org.cerberus.entities.persistence.Application;
 import org.cerberus.entities.persistence.User;
 import org.cerberus.services.ApplicationService;
 import org.cerberus.services.SecurityService;
+import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
 
 import java.security.Principal;
+import java.util.UUID;
 
 import static org.cerberus.core.constant.RoleSecurity.ADMIN;
 import static org.cerberus.core.constant.RoleSecurity.MAINTAINER;
@@ -23,6 +25,11 @@ public class ApplicationController {
         this.securityService = securityService;
     }
 
+    @GetMapping("/{id}")
+    public Application findById(@PathVariable("id") UUID id) {
+        return applicationService.findByIdOrElseThrow(id);
+    }
+
     @PostMapping
     public Application create(@RequestBody Application application, Principal connectedUser) {
         User user = securityService.getAdminUser(connectedUser);
@@ -34,4 +41,11 @@ public class ApplicationController {
         securityService.checkHasAnyRole(connectedUser, application, ADMIN, MAINTAINER);
         return applicationService.update(application);
     }
+
+    @DeleteMapping("/{id}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    public void delete(@PathVariable("id") UUID id, Principal connectedUser) {
+        securityService.checkHasAnyRole(connectedUser, id, ADMIN, MAINTAINER);
+        applicationService.delete(id);
+    }
 }

src/main/java/org/cerberus/controllers/ConfigurationFileController.java

@@ -18,11 +18,19 @@ public class ConfigurationFileController {
     private SecurityService securityService;
 
     ConfigurationFileController(ConfigurationFileService configurationFileService,
-                                       SecurityService securityService) {
+                                SecurityService securityService) {
         this.configurationFileService = configurationFileService;
         this.securityService = securityService;
     }
 
+    @GetMapping("/{id}")
+    public ConfigurationFile findById(@PathVariable("applicationId") UUID applicationId,
+                                      @PathVariable("id") UUID configurationFileId,
+                                      Principal connectedUser) {
+        securityService.checkHasAnyRole(connectedUser, applicationId, ADMIN, MAINTAINER);
+        return configurationFileService.findByApplicationIdAndId(applicationId, configurationFileId);
+    }
+
     @PostMapping
     public void create(@PathVariable("applicationId") UUID applicationId,
                        @RequestBody ConfigurationFile configurationFile,

src/main/java/org/cerberus/core/exceptions/NotFoundException.java

@@ -0,0 +1,15 @@
+package org.cerberus.core.exceptions;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(value = HttpStatus.NOT_FOUND)
+public class NotFoundException extends BusinessException {
+    public NotFoundException(String message) {
+        super(message);
+    }
+
+    public NotFoundException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/org/cerberus/repositories/ApplicationRepository.java

@@ -9,5 +9,5 @@ import java.util.UUID;
 
 public interface ApplicationRepository extends JpaRepository<Application, UUID> {
     @Query(value = "SELECT EXISTS(SELECT id FROM application WHERE name = :name)", nativeQuery = true)
-    Boolean alreadyExists(@Param("name") String name);
+    Boolean existsByName(@Param("name") String name);
 }

src/main/java/org/cerberus/services/AbstractService.java

@@ -0,0 +1,48 @@
+package org.cerberus.services;
+
+import org.cerberus.core.exceptions.NotFoundException;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.lang.NonNull;
+
+import java.util.Optional;
+import java.util.UUID;
+
+abstract class AbstractService<E> {
+    private JpaRepository<E, UUID> repository;
+
+    AbstractService(JpaRepository<E, UUID> repository) {
+        this.repository = repository;
+    }
+
+    public Optional<E> findById(UUID id) {
+        return repository.findById(id);
+    }
+
+    /**
+     * Find the entity by its ID or throw a {@link NotFoundException} if no entity matches to the ID.
+     * @param id Entity ID.
+     * @return The entity.
+     */
+    public @NonNull E findByIdOrElseThrow(UUID id) {
+        return findById(id).orElseThrow(this::newNotFoundException);
+    }
+
+    public void delete(UUID id) {
+        if(!repository.existsById(id)) {
+            throwNotFoundException();
+        }
+        repository.deleteById(id);
+    }
+
+    public boolean existsById(UUID id) {
+        return repository.existsById(id);
+    }
+
+    protected void throwNotFoundException() {
+        throw newNotFoundException();
+    }
+
+    protected NotFoundException newNotFoundException() {
+        return new NotFoundException("Entity doesn't exists.");
+    }
+}

src/main/java/org/cerberus/services/ApplicationService.java

@@ -8,22 +8,19 @@ import org.cerberus.validators.ApplicationValidator;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.Optional;
-import java.util.UUID;
-
 import static org.cerberus.core.constant.Role.MAINTAINER;
 import static org.cerberus.core.utils.StringUtils.concat;
 
 @Service
-public class ApplicationService {
+public class ApplicationService extends AbstractService<Application> {
-
     private ApplicationRepository applicationRepository;
     private ApplicationRoleService applicationRoleService;
     private ApplicationValidator applicationValidator;
 
-    public ApplicationService(ApplicationRepository applicationRepository,
+    ApplicationService(ApplicationRepository applicationRepository,
-                              ApplicationRoleService applicationRoleService,
+                       ApplicationRoleService applicationRoleService,
-                              ApplicationValidator applicationValidator) {
+                       ApplicationValidator applicationValidator) {
+        super(applicationRepository);
         this.applicationRepository = applicationRepository;
         this.applicationRoleService = applicationRoleService;
         this.applicationValidator = applicationValidator;
@@ -33,7 +30,7 @@ public class ApplicationService {
     public Application create(Application application, User user) {
         applicationValidator.validate(application);
 
-        if(applicationRepository.alreadyExists(application.getName())) {
+        if(applicationRepository.existsByName(application.getName())) {
             throw new BadRequestException(concat("The application ", application.getName(), " already exists."));
         }
 
@@ -50,8 +47,4 @@ public class ApplicationService {
         applicationRepository.save(application);
         return application;
     }
-
-    public Optional<Application> findById(UUID id) {
-        return applicationRepository.findById(id);
-    }
 }

src/main/java/org/cerberus/services/ConfigurationFileService.java

@@ -10,19 +10,27 @@ import org.springframework.stereotype.Service;
 import java.util.UUID;
 
 @Service
-public class ConfigurationFileService {
+public class ConfigurationFileService extends AbstractService<ConfigurationFile> {
     private ApplicationService applicationService;
     private ConfigurationFileRepository configurationFileRepository;
     private ConfigurationFileValidator configurationFileValidator;
 
     ConfigurationFileService(ApplicationService applicationService,
-                                    ConfigurationFileRepository configurationFileRepository,
+                             ConfigurationFileRepository configurationFileRepository,
-                                    ConfigurationFileValidator configurationFileValidator) {
+                             ConfigurationFileValidator configurationFileValidator) {
+        super(configurationFileRepository);
         this.applicationService = applicationService;
         this.configurationFileRepository = configurationFileRepository;
         this.configurationFileValidator = configurationFileValidator;
     }
 
+    public ConfigurationFile findByApplicationIdAndId(UUID applicationId, UUID configurationFileId) {
+        if(!applicationService.existsById(applicationId)) {
+            throwNotFoundException();
+        }
+        return findByIdOrElseThrow(configurationFileId);
+    }
+
     public void create(UUID applicationId, ConfigurationFile configurationFile) {
         if(applicationId == null || StringUtils.isNull(applicationId.toString())) {
             throw new BadRequestException("Application id is required.");