Fix alphabetic sorting

pom.xml

@@ -10,7 +10,7 @@
     </parent>
     <groupId>com.cloud</groupId>
     <artifactId>NetworkCloudDrive</artifactId>
-    <version>0.4.8</version>
+    <version>0.4.9-SNAPSHOT</version>
     <name>NetworkCloudDrive</name>
     <description>NetworkCloudDrive project built with Spring Boot</description>
     <url/>

src/main/java/com/cloud/NetworkCloudDrive/DAO/SQLiteDAO.java

@@ -19,7 +19,6 @@
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.io.FileNotFoundException;
 import java.nio.file.FileSystemException;
 import java.sql.SQLException;
 import java.util.List;
@@ -333,7 +332,7 @@ public FolderMetadata getFolderMetadataFromIdPathAndName(String idPath, String n
         dummyFolderMetadata.setPath(idPath);
         dummyFolderMetadata.setId(null);
         dummyFolderMetadata.setCreatedAt(null);
-        dummyFolderMetadata.setUserid(userId); //current logged in user id
+        dummyFolderMetadata.setUserid(userId); //current logged-in user id
         Example<FolderMetadata> folderMetadataExample = Example.of(dummyFolderMetadata);
         Optional<FolderMetadata> optionalFolderMetadata = sqLiteFolderRepository.findOne(folderMetadataExample);
         if (optionalFolderMetadata.isEmpty())

src/main/java/com/cloud/NetworkCloudDrive/Models/DTO/FileListItemDTO.java

@@ -1,10 +1,11 @@
 package com.cloud.NetworkCloudDrive.Models.DTO;
 
 import com.cloud.NetworkCloudDrive.Models.FileMetadata;
+import com.cloud.NetworkCloudDrive.Models.Implementations.AlphanumericalSorter;
 
 import java.time.Instant;
 
-public class FileListItemDTO {
+public class FileListItemDTO  extends AlphanumericalSorter implements Comparable<FileListItemDTO> {
     private long id;
     private String name;
     private String mimeType;
@@ -60,4 +61,9 @@ public boolean isHasThumbnail() {
     public void setHasThumbnail(boolean hasThumbnail) {
         this.hasThumbnail = hasThumbnail;
     }
+
+    @Override
+    public int compareTo(FileListItemDTO fl2) {
+        return Integer.compare(calculateRank(this.name.toLowerCase()), calculateRank(fl2.getName().toLowerCase()));
+    }
 }

src/main/java/com/cloud/NetworkCloudDrive/Models/DTO/FolderListItemDTO.java

@@ -1,10 +1,11 @@
 package com.cloud.NetworkCloudDrive.Models.DTO;
 
 import com.cloud.NetworkCloudDrive.Models.FolderMetadata;
+import com.cloud.NetworkCloudDrive.Models.Implementations.AlphanumericalSorter;
 
 import java.time.Instant;
 
-public class FolderListItemDTO {
+public class FolderListItemDTO extends AlphanumericalSorter implements Comparable<FolderListItemDTO> {
     private long id;
     private String name;
     private String path;
@@ -43,4 +44,10 @@ public Instant getCreatedAt() {
     public void setCreatedAt(Instant createdAt) {
         this.createdAt = createdAt;
     }
+
+    @Override
+    public int compareTo(FolderListItemDTO f2) {
+        return Integer.compare(calculateRank(this.name.toLowerCase()), calculateRank(f2.getName().toLowerCase()));
+    }
 }
+

src/main/java/com/cloud/NetworkCloudDrive/Models/Implementations/ASCIIRanker.java

@@ -0,0 +1,54 @@
+package com.cloud.NetworkCloudDrive.Models.Implementations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ASCIIRanker {
+
+    public int compareByGroups(String firstItem, String secondItem) {
+        boolean secondIsBigger = false;
+        int length;
+        if (firstItem.length() > secondItem.length()) {
+            length = secondItem.length();
+        } else {
+            secondIsBigger = true;
+            length = firstItem.length();
+        }
+
+        List<Integer> digits = new ArrayList<>();
+        List<String> characters = new ArrayList<>();
+
+        for (int i = 0; i < length; i++) {
+        /*
+        file1.txt !^
+        fil2.txt <-- *** ^^^
+
+        fil2.txt
+        file1.txt
+
+        file1.txt
+        file2.txt
+        file12.txt
+         */
+            char firstStringChar = firstItem.charAt(i);
+            char secondStringChar = secondItem.charAt(i);
+            if (Character.isDigit(firstStringChar)) {
+
+            }
+        }
+        return 1;
+    }
+
+    /*
+    should only be used when all characters in comparing strings are same
+    then can be used to rank them between each other using ASCII scores
+     */
+    public int calculateRank(String word) {
+        int rank = 0;
+        for (int i = 0; i < word.length(); i++) {
+            char ch = word.charAt(i);
+            rank += ch;
+        }
+        return rank;
+    }
+}

src/main/java/com/cloud/NetworkCloudDrive/Models/Implementations/AlphanumericalSorter.java

@@ -0,0 +1,64 @@
+package com.cloud.NetworkCloudDrive.Models.Implementations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AlphanumericalSorter {
+
+    public int compareByGroups(String firstItem, String secondItem) {
+        boolean secondIsBigger = false;
+        int length;
+        if (firstItem.length() > secondItem.length()) {
+            length = secondItem.length();
+        } else {
+            secondIsBigger = true;
+            length = firstItem.length();
+        }
+
+        List<Integer> digits = new ArrayList<>();
+        List<Character[]> characters = new ArrayList<>();
+
+        for (int i = 0; i < length; i++) {
+        /*
+        file1.txt !^
+        fil2.txt <-- *** ^^^
+
+        fil2.txt
+        file1.txt
+
+        file1.txt
+        file2.txt
+        file12.txt
+         */
+            char firstStringChar = firstItem.charAt(i);
+            char secondStringChar = secondItem.charAt(i);
+            if (Character.isDigit(firstStringChar)) {
+                digits.add(firstStringChar - '0');
+                continue;
+            }
+            characters.add(new Character[]{firstStringChar, secondStringChar});
+        }
+        return 1;
+    }
+
+    private boolean handleStrings(char[] firstChars, char[] secondChars) {
+        for (int i = 0; i < firstChars.length; i++) {
+            int j = i + 1;
+
+        }
+        return false;
+    }
+
+    /*
+    should only be used when all characters in comparing strings are same
+    then can be used to rank them between each other using ASCII scores
+     */
+    public int calculateRank(String word) {
+        int rank = 0;
+        for (int i = 0; i < word.length(); i++) {
+            char ch = word.charAt(i);
+            rank += ch;
+        }
+        return rank;
+    }
+}

src/main/java/com/cloud/NetworkCloudDrive/Services/FileSystemService.java

@@ -100,8 +100,8 @@ public Map<String, List<?>> getListOfMetadataFromPath(List<Path> filePaths, Sort
         List<List<?>> results = checkAndCollectFilesAndFolders(filePaths);
         return sortAndFilterUtility.sortFileList(
                 sortListEnum,
-                (Stream<FileListItemDTO>) results.get(0).stream(),
-                (Stream<FolderListItemDTO>) results.get(1).stream()
+                (List<FileListItemDTO>) results.get(0),
+                (List<FolderListItemDTO>) results.get(1)
         );
     }
 

src/main/java/com/cloud/NetworkCloudDrive/Services/Tasks/MaintenanceService.java

@@ -146,8 +146,6 @@ public boolean scanDirectory(Path startingPath, Predicate<Path> filter, boolean
     public ThumbnailScanResults recursiveThumbnailScanInvoker(long folderId) throws SQLException {
         ThumbnailScanResults thumbnailScanResults = new ThumbnailScanResults();
         List<Long> folderMetadataContainingPath = sqLiteDAO.findAllStartsWithIdPathReturnsLongList(sqLiteDAO.getIdPath(folderId));
-        logger.info("size {}", folderMetadataContainingPath.size());
-        folderMetadataContainingPath.forEach(l -> logger.info("item {}", l));
         //temp
         if (folderId == 0) {
             folderMetadataContainingPath.add(0L);

src/main/java/com/cloud/NetworkCloudDrive/Utilities/SortAndFilterUtility.java

@@ -6,61 +6,65 @@
 import com.cloud.NetworkCloudDrive.Models.Enum.SortListEnum;
 import org.springframework.stereotype.Component;
 
-import java.util.Comparator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 @Component
 public class SortAndFilterUtility {
 
     public SortAndFilterUtility() {}
 
-    public Map<String, List<?>> sortFileList(SortListEnum sortListEnum, Stream<FileListItemDTO> fileList, Stream<FolderListItemDTO> folderList) {
-        Comparator<FileListItemDTO> fileListItemDTOComparator = null;
-        Comparator<FolderListItemDTO> folderListItemDTOComparator = null;
+    public Map<String, List<?>> sortFileList(SortListEnum sortListEnum, List<FileListItemDTO> fileList, List<FolderListItemDTO> folderList) {
         switch (sortListEnum) {
-            case ALPHABETICAL:
-                fileListItemDTOComparator = Comparator.comparing(f -> f.getName().toLowerCase());
-                folderListItemDTOComparator = Comparator.comparing(fl -> fl.getName().toLowerCase());
-                break;
-            case REVERSE_ALPHABETICAL:
-                fileListItemDTOComparator = Comparator.comparing(f -> f.getName().toLowerCase(), Comparator.reverseOrder());
-                folderListItemDTOComparator = Comparator.comparing(fl -> fl.getName().toLowerCase(), Comparator.reverseOrder());
-                break;
+            case ALPHABETICAL, REVERSE_ALPHABETICAL:
+                return sortName(sortListEnum, fileList, folderList);
             case NEWEST:
-                fileListItemDTOComparator = Comparator.comparing(FileListItemDTO::getCreatedAt, Comparator.reverseOrder());
-                folderListItemDTOComparator = Comparator.comparing(FolderListItemDTO::getCreatedAt, Comparator.reverseOrder());
+                fileList.sort(Comparator.comparing(FileListItemDTO::getCreatedAt).reversed());
+                folderList.sort(Comparator.comparing(FolderListItemDTO::getCreatedAt).reversed());
                 break;
             case OLDEST:
-                fileListItemDTOComparator = Comparator.comparing(FileListItemDTO::getCreatedAt);
-                folderListItemDTOComparator = Comparator.comparing(FolderListItemDTO::getCreatedAt);
+                fileList.sort(Comparator.comparing(FileListItemDTO::getCreatedAt));
+                folderList.sort(Comparator.comparing(FolderListItemDTO::getCreatedAt));
                 break;
             case FOLDERS_FIRST:
                 LinkedHashMap<String, List<?>> linkedHashMap = new LinkedHashMap<>();
-                linkedHashMap.put("folders", folderList.toList());
-                linkedHashMap.put("files", fileList.toList());
+                linkedHashMap.put("folders", folderList);
+                linkedHashMap.put("files", fileList);
                 return linkedHashMap;
             case SIZE:
-                fileListItemDTOComparator = Comparator.comparingLong(FileListItemDTO::getSize).reversed();
+                fileList.sort(Comparator.comparing(FileListItemDTO::getCreatedAt).reversed());
                 break;
             case SIZE_LOWEST:
-                fileListItemDTOComparator = Comparator.comparingLong(FileListItemDTO::getSize);
+                fileList.sort(Comparator.comparing(FileListItemDTO::getCreatedAt));
                 break;
-            default:
-                return Map.of(
-                        "files", fileList.toList(),
-                        "folders", folderList.toList()
-                );
         }
+        return returnMappedLists(fileList, folderList);
+    }
+
+    private Map<String, List<?>> returnMappedLists(List<FileListItemDTO> fileListItemDTO, List<FolderListItemDTO> folderListItemDTO) {
         return Map.of(
-                "files", (fileListItemDTOComparator != null ? fileList.sorted(fileListItemDTOComparator).toList() : fileList.toList()),
-                "folders", (folderListItemDTOComparator != null ? folderList.sorted(folderListItemDTOComparator).toList() : folderList.toList())
+                "files", fileListItemDTO,
+                "folders", folderListItemDTO
         );
     }
 
+    private Map<String, List<?>> sortName(SortListEnum sortOption, List<FileListItemDTO> fileListItemDTO, List<FolderListItemDTO> folderListItemDTO) {
+
+        switch (sortOption) {
+            case ALPHABETICAL:
+                fileListItemDTO.sort(Comparator.naturalOrder());
+                folderListItemDTO.sort(Comparator.naturalOrder());
+                break;
+            case REVERSE_ALPHABETICAL:
+                fileListItemDTO.sort(Comparator.reverseOrder());
+                folderListItemDTO.sort(Comparator.reverseOrder());
+                break;
+        }
+        return returnMappedLists(fileListItemDTO, folderListItemDTO);
+    }
+
     public Map<String, List<?>> filterFileList(FilterListEnum filterListEnum, Stream<FileListItemDTO> fileList, Stream<FolderListItemDTO> folderList, String filterCase) {
         Predicate<FileListItemDTO> fileListItemDTOPredicate = null;
         Predicate<FolderListItemDTO> folderListItemDTOPredicate = null;