FF-444 - Search Endpoint (#121)

* basic function skeleton

* Wrote Logic

* FF-447 add search integration tests

* added url decoding when searching.

Co-authored-by: qvalentin <[email protected]>

Author: open-schnick

src/main/java/de/filefighter/rest/domain/filesystem/business/FileSystemBusinessService.java

@@ -1,5 +1,6 @@
 package de.filefighter.rest.domain.filesystem.business;
 
+import de.filefighter.rest.configuration.RestConfiguration;
 import de.filefighter.rest.domain.common.Pair;
 import de.filefighter.rest.domain.common.exceptions.FileFighterDataException;
 import de.filefighter.rest.domain.filesystem.data.InteractionType;
@@ -260,4 +261,49 @@ public Pair<List<FileSystemItem>, String> downloadFileSystemEntity(List<Long> id
         }
         return new Pair<>(returnList, zipName);
     }
+
+    public List<FileSystemItem> searchFileSystemEntity(String sanitizedSearch, User authenticatedUser) {
+        // check for username with the same name
+        User userWithTheName;
+        List<FileSystemEntity> foundEntities = fileSystemRepository.findAllByNameContainingIgnoreCase(sanitizedSearch);
+
+        try {
+            userWithTheName = userBusinessService.findUserByUsername(sanitizedSearch);
+
+            if (userWithTheName.getUserId() != RestConfiguration.RUNTIME_USER_ID) {
+                // there is a user with the name -> add the users root to list.
+                foundEntities.add(fileSystemHelperService.getRootEntityForUser(userWithTheName));
+            }
+        } catch (UserNotFoundException ignored) {
+            log.debug("Searched for {}, was not a username.", sanitizedSearch);
+        }
+
+        if (null == foundEntities)
+            throw new FileSystemItemNotFoundException();
+
+        List<FileSystemEntity> visibleEntities = foundEntities.stream()
+                .filter(entity -> fileSystemHelperService.userIsAllowedToInteractWithFileSystemEntity(entity, authenticatedUser, InteractionType.READ))
+                .collect(Collectors.toList());
+
+        return visibleEntities.stream()
+                .map(entity -> {
+                    String username = fileSystemHelperService.getOwnerUsernameForEntity(entity);
+                    String path;
+                    if (entity.isFile() || entity.getTypeId() != FileSystemType.FOLDER.getId()) {
+                        FileSystemEntity parent = fileSystemRepository.findByItemIdsContaining(entity.getFileSystemId());
+                        if (null == parent)
+                            throw new FileFighterDataException("Couldn't find parent entity for id: " + entity.getFileSystemId());
+                        path = parent.getPath();
+                        if (path.equals("/")) {
+                            path += entity.getName();
+                        } else {
+                            path += "/" + entity.getName();
+                        }
+                    } else {
+                        path = entity.getPath();
+                    }
+                    return fileSystemHelperService.createDTO(entity, authenticatedUser, "/" + username + path);
+                })
+                .collect(Collectors.toList());
+    }
 }

src/main/java/de/filefighter/rest/domain/filesystem/business/FileSystemHelperService.java

@@ -25,6 +25,7 @@
 import java.time.Instant;
 import java.util.*;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static de.filefighter.rest.domain.filesystem.business.FileSystemBusinessService.DELETION_FAILED_MSG;
 
@@ -410,7 +411,7 @@ public Function<FileSystemEntity, String> getParentNameEntity() {
         };
     }
 
-    private String getOwnerUsernameForEntity(FileSystemEntity entity) {
+    public String getOwnerUsernameForEntity(FileSystemEntity entity) {
         User owner;
         try {
             owner = userBusinessService.findUserById(entity.getOwnerId());
@@ -420,6 +421,21 @@ private String getOwnerUsernameForEntity(FileSystemEntity entity) {
         return owner.getUsername();
     }
 
+    public FileSystemEntity getRootEntityForUser(User userWithTheName) {
+        List<FileSystemEntity> rootForUser = fileSystemRepository.findByPath("/")
+                .stream()
+                .filter(entity -> entity.getOwnerId() == userWithTheName.getUserId())
+                .collect(Collectors.toList());
+
+        if (rootForUser.isEmpty())
+            throw new FileFighterDataException("Found not root folder for user with id: " + userWithTheName.getUserId());
+
+        if (rootForUser.size() > 1)
+            throw new FileFighterDataException("Found more than one root folder for user with id: " + userWithTheName.getUserId());
+
+        return rootForUser.get(0);
+    }
+
     public double getTotalFileSize() {
         List<FileSystemEntity> entities = fileSystemRepository.findByPath("/");
         if (null == entities)

src/main/java/de/filefighter/rest/domain/filesystem/data/persistence/FileSystemRepository.java

@@ -19,6 +19,8 @@ public interface FileSystemRepository extends MongoRepository<FileSystemEntity,
 
     List<FileSystemEntity> findAllByFileSystemIdInAndNameIgnoreCase(List<Long> fileSystemId, String name);
 
+    List<FileSystemEntity> findAllByNameContainingIgnoreCase(String name);
+
     // this does work tho.
     FileSystemEntity findByItemIdsContaining(long id);
 

src/main/java/de/filefighter/rest/domain/filesystem/rest/FileSystemRestController.java

@@ -11,6 +11,8 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 
 import static de.filefighter.rest.configuration.RestConfiguration.*;
@@ -48,12 +50,12 @@ public ResponseEntity<FileSystemItem> getFileOrFolderInfo(
     }
 
     @GetMapping(FS_BASE_URI + "search")
-    public ResponseEntity<FileSystemItem> searchFileOrFolderByName(
+    public ResponseEntity<List<FileSystemItem>> searchFileOrFolderByName(
             @RequestParam(name = "name", defaultValue = "name") String name,
             @RequestHeader(value = "Authorization") String accessToken
     ) {
 
-        log.info("Searching for file or folder with name {}", name);
+        log.info("Searching for file or folder with name {} decoded: ({})", name, URLDecoder.decode(name, StandardCharsets.UTF_8));
         return fileSystemRestService.findFileOrFolderByNameAndAccessToken(name, accessToken);
     }
 

src/main/java/de/filefighter/rest/domain/filesystem/rest/FileSystemRestService.java

@@ -17,6 +17,8 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 
 @Service
@@ -96,8 +98,12 @@ public ResponseEntity<List<FileSystemItem>> deleteFileSystemItemWithIdAndAccessT
     }
 
     @Override
-    public ResponseEntity<FileSystemItem> findFileOrFolderByNameAndAccessToken(String name, String accessToken) {
-        return null;
+    public ResponseEntity<List<FileSystemItem>> findFileOrFolderByNameAndAccessToken(String name, String accessToken) {
+        User authenticatedUser = authenticationService.bearerAuthenticationWithAccessToken(accessToken);
+        String sanitizedSearch = inputSanitizerService.sanitizeString(name);
+        sanitizedSearch = URLDecoder.decode(sanitizedSearch, StandardCharsets.UTF_8);
+
+        return new ResponseEntity<>(fileSystemBusinessService.searchFileSystemEntity(sanitizedSearch, authenticatedUser), HttpStatus.OK);
     }
 
     @Override

src/main/java/de/filefighter/rest/domain/filesystem/rest/FileSystemRestServiceInterface.java

@@ -15,7 +15,7 @@ public interface FileSystemRestServiceInterface {
 
     ResponseEntity<FileSystemItem> getInfoAboutFileOrFolderByIdAndAccessToken(long fsItemId, String accessToken);
 
-    ResponseEntity<FileSystemItem> findFileOrFolderByNameAndAccessToken(String name, String accessToken);
+    ResponseEntity<List<FileSystemItem>> findFileOrFolderByNameAndAccessToken(String name, String accessToken);
 
     ResponseEntity<List<FileSystemItem>> uploadFileSystemItemWithAccessToken(long rootItemId, FileSystemUpload fileSystemUpload, String accessToken);
 

src/test/java/de/filefighter/rest/cucumber/CrudFileSystemSteps.java

@@ -4,6 +4,9 @@
 import io.cucumber.java.en.When;
 import org.springframework.http.HttpMethod;
 
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 
 import static de.filefighter.rest.configuration.RestConfiguration.*;
@@ -41,4 +44,14 @@ public void userWithTokenWantsToGetTheInfoOfFileSystemItemWithTheFileSystemId(St
 
     }
 
+    @When("user with token {string} searches for {string}")
+    public void userWithTokenSearchesFor(String accessTokenValue, String searchValue) throws UnsupportedEncodingException {
+
+        String authHeaderString = AUTHORIZATION_BEARER_PREFIX + accessTokenValue;
+
+        HashMap<String, String> authHeader = new HashMap<>();
+        authHeader.put("Authorization", authHeaderString);
+
+        executeRestApiCall(HttpMethod.GET, BASE_API_URI + FS_BASE_URI  + "/search?name="+ URLEncoder.encode(searchValue, StandardCharsets.UTF_8.toString()), authHeader);
+    }
 }

src/test/java/de/filefighter/rest/domain/filesystem/rest/FileSystemRestControllerUnitTest.java

@@ -59,14 +59,16 @@ void getFileOrFolderInfo() {
     @Test
     void searchFileOrFolderByName() {
         FileSystemItem file = FileSystemItem.builder().build();
-        ResponseEntity<FileSystemItem> expectedModel = new ResponseEntity<>(file, OK);
+        List<FileSystemItem> list = new ArrayList<>();
+        list.add(file);
+        ResponseEntity<List<FileSystemItem>> expectedModel = new ResponseEntity<>(list, OK);
 
         String name = "randomFile.exe";
         String token = "token";
 
         when(fileSystemRestServiceMock.findFileOrFolderByNameAndAccessToken(name, token)).thenReturn(expectedModel);
 
-        ResponseEntity<FileSystemItem> actualModel = fileSystemRestController.searchFileOrFolderByName(name, token);
+        ResponseEntity<List<FileSystemItem>> actualModel = fileSystemRestController.searchFileOrFolderByName(name, token);
         assertEquals(expectedModel, actualModel);
     }
 

src/test/resources/SearchFiles.feature

@@ -0,0 +1,87 @@
+Feature: Search Files and Directories
+  As a user
+  I want to be able to search for files or folders by their name.
+
+  Background:
+    Given database is empty
+    And runtime user exists
+    And user with userId 1234 exists and has username "Richard", password "badPassword"
+    And user with userId 420 exists and has username "Nasir", password "AlsoBadPassword"
+    And accessToken with value "Richard" exists for user 1234
+    And accessToken with value "Nasir" exists for user 420
+    And user with userId 1234 has HomeFolder with Id 1234
+    And user with userId 420 has HomeFolder with Id 420
+    And fileSystemItem with the fileSystemId 42 exists, has owner with userId 1234 has the path "/bla" and name "bla"
+    And fileSystemItem with the fileSystemId 72 exists, has owner with userId 1234 and name "wow.txt"
+    And fileSystemItem with the fileSystemId 42 is a folder and contains the fileSystemId 72
+
+  Scenario: Successful interaction, found file in personal folder
+    When user with token "Richard" searches for "wow"
+    Then response status code is 200
+    And the response contains a entity with the path "/richard/bla/wow.txt" that has key "name" with value "wow.txt"
+
+  Scenario: Successful interaction, found file in personal folder, ignore case
+    When user with token "Richard" searches for "WOW.TXT"
+    Then response status code is 200
+    And the response contains a entity with the path "/richard/bla/wow.txt" that has key "name" with value "wow.txt"
+
+  Scenario: Successful interaction, found folder in personal folder
+    When user with token "Richard" searches for "bla"
+    Then response status code is 200
+    And the response contains a entity with the path "/richard/bla" that has key "fileSystemId" with value "42"
+
+  Scenario: Successful interaction, found files in personal folder by half the name
+    Given fileSystemItem with the fileSystemId 73 exists, has owner with userId 1234 and name "SuchAlongFileName.txt"
+    And fileSystemItem with the fileSystemId 42 is a folder and contains the fileSystemId 73
+    And fileSystemItem with the fileSystemId 74 exists, has owner with userId 1234 and name "AnotherlongFileName.xml"
+    And fileSystemItem with the fileSystemId 42 is a folder and contains the fileSystemId 74
+    When user with token "Richard" searches for "FileName"
+    Then response status code is 200
+    And the response contains a entity with the path "/richard/bla/suchalongfilename.txt" that has key "fileSystemId" with value "73"
+    And the response contains a entity with the path "/richard/bla/anotherlongfilename.xml" that has key "fileSystemId" with value "74"
+
+  Scenario: nothing found
+    When user with token "Richard" searches for "ugabuga"
+    Then response status code is 200
+    And the response contains an empty list for files and folders
+
+  Scenario: no permissions
+    When user with token "Nasir" searches for "wow"
+    Then response status code is 200
+    And the response contains an empty list for files and folders
+
+  Scenario: Successful interaction, found file in shared folder
+    Given user with the userId 420 is allowed to VIEW the fileSystemItem with the fileSystemId 42
+    And user with the userId 420 is allowed to VIEW the fileSystemItem with the fileSystemId 72
+    When user with token "Nasir" searches for "wow"
+    Then response status code is 200
+    And the response contains a entity with the path "/richard/bla/wow.txt" that has key "name" with value "wow.txt"
+
+  Scenario: Successful interaction, found folder in personal folder
+    Given user with the userId 420 is allowed to VIEW the fileSystemItem with the fileSystemId 42
+    And user with the userId 420 is allowed to VIEW the fileSystemItem with the fileSystemId 72
+    When user with token "Richard" searches for "bla"
+    Then response status code is 200
+    And the response contains a entity with the path "/richard/bla" that has key "fileSystemId" with value "42"
+
+
+
+  Scenario Outline: Search for <filename> with <search>
+    Given fileSystemItem with the fileSystemId 73 exists, has owner with userId 1234 and name "<filename>"
+    And fileSystemItem with the fileSystemId 42 is a folder and contains the fileSystemId 73
+    When user with token "Richard" searches for "<search>"
+    Then response status code is 200
+    And the response contains the file with fileSystemId 73 and name "<filename>"
+
+    Examples:
+    |filename |search |
+    |HansWurst |st |
+    |Esel.txt |.txt |
+    |HinterhältigesWiesel.wav |Hältiges |
+    |HilfeHilfe |hilfe |
+    |DuDummeSau |du |
+    |NichtDasNagetier |Tier |
+    |DuBauer |auer |
+    |DasIstWahreMacht |d  |
+    |DIesESMALWerdeICHEuchBesiegen |DiesesMalWerdeIchEuchBesiegen |
+    |filename |filename |