SearchResults.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2019 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.filequery;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.sleuthkit.autopsy.filequery.FileSearch.GroupKey;

class SearchResults {

    private final FileGroup.GroupSortingAlgorithm groupSortingType;
    private final FileSearch.AttributeType attrType;
    private final FileSorter fileSorter;

    private final Map<FileSearch.GroupKey, FileGroup> groupMap = new HashMap<>();
    private List<FileGroup> groupList = new ArrayList<>();

    private static final long MAX_OUTPUT_FILES = 2000; // For debug UI - maximum number of lines to print

    SearchResults(FileGroup.GroupSortingAlgorithm groupSortingType, FileSearch.AttributeType attrType,
            FileSorter.SortingMethod fileSortingMethod) {
        this.groupSortingType = groupSortingType;
        this.attrType = attrType;
        this.fileSorter = new FileSorter(fileSortingMethod);
    }

    SearchResults() {
        this.groupSortingType = FileGroup.GroupSortingAlgorithm.BY_GROUP_NAME;
        this.attrType = new FileSearch.FileSizeAttribute();
        this.fileSorter = new FileSorter(FileSorter.SortingMethod.BY_FILE_NAME);
    }

    void add(List<ResultFile> files) {
        for (ResultFile file : files) {
            // Add the file to the appropriate group, creating it if necessary
            FileSearch.GroupKey groupKey = attrType.getGroupKey(file);

            if (!groupMap.containsKey(groupKey)) {
                groupMap.put(groupKey, new FileGroup(groupSortingType, groupKey));
            }
            groupMap.get(groupKey).addFile(file);
        }
    }

    void sortGroupsAndFiles() {

        // First sortGroupsAndFiles the files
        for (FileGroup group : groupMap.values()) {
            group.sortFiles(fileSorter);
        }

        // Now put the groups in a list and sortGroupsAndFiles them
        groupList = new ArrayList<>(groupMap.values());
        Collections.sort(groupList);
    }

    @Override
    public String toString() {
        String result = "";
        if (groupList == null) {
            return result;
        }

        long count = 0;
        for (FileGroup group : groupList) {
            result += group.getDisplayName() + "\n";

            for (ResultFile file : group.getFiles()) {
                result += "    " + file.toString() + "\n";
                count++;
                if (count > MAX_OUTPUT_FILES) {
                    result += "(truncated)";
                    return result;
                }
            }
        }
        return result;
    }

    List<String> getGroupNamesWithCounts() {
        return groupList.stream().map(p -> p.getDisplayName() + " (" + p.getFiles().size() + ")").collect(Collectors.toList());
    }

    List<ResultFile> getResultFilesInGroup(String groupName) {
        if (groupName != null) {
            final String modifiedGroupName = groupName.replaceAll(" \\([0-9]+\\)$", "");

            java.util.Optional<FileGroup> fileGroup = groupList.stream().filter(p -> p.getDisplayName().equals(modifiedGroupName)).findFirst();
            if (fileGroup.isPresent()) {
                return fileGroup.get().getFiles();
            }
        }
        return new ArrayList<>();
    }

    Map<GroupKey, List<ResultFile>> toLinkedHashMap() throws FileSearchException {
        Map<GroupKey, List<ResultFile>> map = new LinkedHashMap<>();

        // Sort the groups and files
        sortGroupsAndFiles();

        // groupList is sorted and a LinkedHashMap will preserve that order.
        for (FileGroup group : groupList) {
            map.put(group.getGroupKey(), group.getFiles());
        }

        return map;
    }
}