ResultsSorter.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2020 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.discovery.search;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.openide.util.NbBundle;
import org.sleuthkit.datamodel.TskCoreException;

public class ResultsSorter implements Comparator<Result> {

    private final List<Comparator<Result>> comparators = new ArrayList<>();

    public ResultsSorter(SortingMethod method) {

        // Set up the primary comparators that should applied to the results
        switch (method) {
            case BY_DATA_SOURCE:
                comparators.add(getDataSourceComparator());
                break;
            case BY_FILE_SIZE:
                comparators.add(getFileSizeComparator());
                break;
            case BY_FILE_TYPE:
                comparators.add(getTypeComparator());
                comparators.add(getMIMETypeComparator());
                break;
            case BY_FREQUENCY:
                comparators.add(getFrequencyComparator());
                break;
            case BY_KEYWORD_LIST_NAMES:
                comparators.add(getKeywordListNameComparator());
                break;
            case BY_FULL_PATH:
                comparators.add(getParentPathComparator());
                break;
            case BY_FILE_NAME:
                comparators.add(getFileNameComparator());
                break;
            case BY_DOMAIN_NAME:
                comparators.add(getDomainNameComparator());
                break;
            case BY_PAGE_VIEWS:
                comparators.add(getPageViewComparator());
                break;
            case BY_LAST_ACTIVITY:
                comparators.add(getLastActivityDateTimeComparator());
                break;
            case BY_DOWNLOADS:
                comparators.add(getWebDownloadsComparator());
                break;
            default:
                // The default comparator will be added afterward
                break;
        }

        // Add the default comparator to the end. This will ensure a consistent sort
        // order regardless of the order the results were added to the list.
        comparators.add(getDefaultComparator());
    }

    @Override
    public int compare(Result result1, Result result2) {

        int result = 0;
        for (Comparator<Result> comp : comparators) {
            result = comp.compare(result1, result2);
            if (result != 0) {
                return result;
            }
        }

        // The results are the same
        return result;
    }

    private static Comparator<Result> getDataSourceComparator() {
        return (Result result1, Result result2) -> Long.compare(result1.getDataSourceObjectId(), result2.getDataSourceObjectId());
    }

    private static Comparator<Result> getTypeComparator() {
        return (Result result1, Result result2) -> Integer.compare(result1.getType().getRanking(), result2.getType().getRanking());
    }

    private static Comparator<Result> getKeywordListNameComparator() {
        return (Result result1, Result result2) -> {
            // Put empty lists at the bottom
            if (result1.getType() == SearchData.Type.DOMAIN) {
                return 0;
            }
            ResultFile file1 = (ResultFile) result1;
            ResultFile file2 = (ResultFile) result2;
            if (file1.getKeywordListNames().isEmpty()) {
                if (file2.getKeywordListNames().isEmpty()) {
                    return 0;
                }
                return 1;
            } else if (file2.getKeywordListNames().isEmpty()) {
                return -1;
            }

            String list1 = String.join(",", file1.getKeywordListNames());
            String list2 = String.join(",", file2.getKeywordListNames());
            return compareStrings(list1, list2);
        };
    }

    private static Comparator<Result> getParentPathComparator() {

        return new Comparator<Result>() {
            @Override
            public int compare(Result result1, Result result2) {
                if (result1.getType() == SearchData.Type.DOMAIN) {
                    return 0;
                }
                ResultFile file1 = (ResultFile) result1;
                ResultFile file2 = (ResultFile) result2;
                String file1ParentPath;
                try {
                    file1ParentPath = file1.getFirstInstance().getParent().getUniquePath();
                } catch (TskCoreException ingored) {
                    file1ParentPath = file1.getFirstInstance().getParentPath();
                }
                String file2ParentPath;
                try {
                    file2ParentPath = file2.getFirstInstance().getParent().getUniquePath();
                } catch (TskCoreException ingored) {
                    file2ParentPath = file2.getFirstInstance().getParentPath();
                }
                return compareStrings(file1ParentPath.toLowerCase(), file2ParentPath.toLowerCase());
            }
        };
    }

    private static Comparator<Result> getFrequencyComparator() {
        return (Result result1, Result result2) -> Integer.compare(result1.getFrequency().getRanking(), result2.getFrequency().getRanking());
    }

    private static Comparator<Result> getMIMETypeComparator() {
        return (Result result1, Result result2) -> {
            if (result1.getType() == SearchData.Type.DOMAIN) {
                return 0;
            }
            return compareStrings(((ResultFile) result1).getFirstInstance().getMIMEType(), ((ResultFile) result2).getFirstInstance().getMIMEType());
        };
    }

    private static Comparator<Result> getFileSizeComparator() {
        return (Result result1, Result result2) -> {
            if (result1.getType() == SearchData.Type.DOMAIN) {
                return 0;
            }
            return -1 * Long.compare(((ResultFile) result1).getFirstInstance().getSize(), ((ResultFile) result2).getFirstInstance().getSize()); // Sort large to small
        };
    }

    private static Comparator<Result> getFileNameComparator() {
        return (Result result1, Result result2) -> {
            if (result1.getType() == SearchData.Type.DOMAIN) {
                return 0;
            }
            return compareStrings(((ResultFile) result1).getFirstInstance().getName().toLowerCase(), (((ResultFile) result2).getFirstInstance().getName().toLowerCase()));
        };
    }

    private static Comparator<Result> getDomainNameComparator() {
        return (Result domain1, Result domain2) -> {
            if (domain1.getType() != SearchData.Type.DOMAIN) {
                return 0;
            }

            ResultDomain first = (ResultDomain) domain1;
            ResultDomain second = (ResultDomain) domain2;
            return compareStrings(first.getDomain().toLowerCase(), second.getDomain().toLowerCase());
        };
    }

    private static Comparator<Result> getPageViewComparator() {
        return (Result domain1, Result domain2) -> {
            if (domain1.getType() != SearchData.Type.DOMAIN
                    || domain2.getType() != SearchData.Type.DOMAIN) {
                return 0;
            }

            ResultDomain first = (ResultDomain) domain1;
            ResultDomain second = (ResultDomain) domain2;

            long firstPageViews = first.getTotalPageViews();
            long secondPageViews = second.getTotalPageViews();
            return Long.compare(secondPageViews, firstPageViews);
        };
    }

    private static Comparator<Result> getLastActivityDateTimeComparator() {
        return (Result domain1, Result domain2) -> {
            if (domain1.getType() != SearchData.Type.DOMAIN
                    || domain2.getType() != SearchData.Type.DOMAIN) {
                return 0;
            }
            ResultDomain first = (ResultDomain) domain1;
            ResultDomain second = (ResultDomain) domain2;

            long firstActivityEnd = first.getActivityEnd();
            long secondActivityEnd = second.getActivityEnd();
            return Long.compare(secondActivityEnd, firstActivityEnd);
        };
    }

    private static Comparator<Result> getWebDownloadsComparator() {
        return (Result domain1, Result domain2) -> {
            if (domain1.getType() != SearchData.Type.DOMAIN
                    || domain2.getType() != SearchData.Type.DOMAIN) {
                return 0;
            }
            ResultDomain first = (ResultDomain) domain1;
            ResultDomain second = (ResultDomain) domain2;

            long firstFilesDownloaded = first.getFilesDownloaded();
            long secondFilesDownloaded = second.getFilesDownloaded();
            return Long.compare(secondFilesDownloaded, firstFilesDownloaded);
        };
    }

    private static Comparator<Result> getDefaultComparator() {
        return (Result result1, Result result2) -> {
            // Compare file names and then object ID (to ensure a consistent sort)
            if (result1.getType() == SearchData.Type.DOMAIN) {
                return getFrequencyComparator().compare(result1, result2);
            } else {
                ResultFile file1 = (ResultFile) result1;
                ResultFile file2 = (ResultFile) result2;
                int result = getFileNameComparator().compare(file1, file2);
                if (result == 0) {
                    return Long.compare(file1.getFirstInstance().getId(), file2.getFirstInstance().getId());
                }
                return result;
            }

        };
    }

    private static int compareStrings(String s1, String s2) {
        String string1 = s1 == null ? "" : s1;
        String string2 = s2 == null ? "" : s2;
        return string1.compareTo(string2);

    }

    @NbBundle.Messages({
        "FileSorter.SortingMethod.datasource.displayName=Data Source",
        "FileSorter.SortingMethod.filename.displayName=File Name",
        "FileSorter.SortingMethod.filesize.displayName=File Size",
        "FileSorter.SortingMethod.filetype.displayName=File Type",
        "FileSorter.SortingMethod.frequency.displayName=Central Repo Frequency",
        "FileSorter.SortingMethod.keywordlist.displayName=Keyword List Names",
        "FileSorter.SortingMethod.fullPath.displayName=Full Path",
        "FileSorter.SortingMethod.domain.displayName=Domain Name",
        "FileSorter.SortingMethod.pageViews.displayName=Page Views",
        "FileSorter.SortingMethod.downloads.displayName=File Downloads",
        "FileSorter.SortingMethod.activity.displayName=Last Activity Date"})
    public enum SortingMethod {
        BY_FILE_NAME(new ArrayList<>(),
                Bundle.FileSorter_SortingMethod_filename_displayName()), // Sort alphabetically by file name
        BY_DATA_SOURCE(new ArrayList<>(),
                Bundle.FileSorter_SortingMethod_datasource_displayName()), // Sort in increasing order of data source ID
        BY_FILE_SIZE(new ArrayList<>(),
                Bundle.FileSorter_SortingMethod_filesize_displayName()), // Sort in decreasing order of size
        BY_FILE_TYPE(Arrays.asList(new DiscoveryAttributes.FileTypeAttribute()),
                Bundle.FileSorter_SortingMethod_filetype_displayName()), // Sort in order of file type (defined in FileType enum), with secondary sort on MIME type
        BY_FREQUENCY(Arrays.asList(new DiscoveryAttributes.FrequencyAttribute()),
                Bundle.FileSorter_SortingMethod_frequency_displayName()), // Sort by decreasing rarity in the central repository
        BY_KEYWORD_LIST_NAMES(Arrays.asList(new DiscoveryAttributes.KeywordListAttribute()),
                Bundle.FileSorter_SortingMethod_keywordlist_displayName()), // Sort alphabetically by list of keyword list names found
        BY_FULL_PATH(new ArrayList<>(),
                Bundle.FileSorter_SortingMethod_fullPath_displayName()), // Sort alphabetically by path
        BY_DOMAIN_NAME(Arrays.asList(new DiscoveryAttributes.DomainCategoryAttribute()), Bundle.FileSorter_SortingMethod_domain_displayName()),
        BY_PAGE_VIEWS(Arrays.asList(new DiscoveryAttributes.DomainCategoryAttribute()), Bundle.FileSorter_SortingMethod_pageViews_displayName()),
        BY_DOWNLOADS(Arrays.asList(new DiscoveryAttributes.DomainCategoryAttribute()), Bundle.FileSorter_SortingMethod_downloads_displayName()),
        BY_LAST_ACTIVITY(Arrays.asList(new DiscoveryAttributes.DomainCategoryAttribute()), Bundle.FileSorter_SortingMethod_activity_displayName());

        private final String displayName;
        private final List<DiscoveryAttributes.AttributeType> requiredAttributes;

        SortingMethod(List<DiscoveryAttributes.AttributeType> attributes, String displayName) {
            this.requiredAttributes = attributes;
            this.displayName = displayName;
        }

        @Override
        public String toString() {
            return displayName;
        }

        public List<DiscoveryAttributes.AttributeType> getRequiredAttributes() {
            return Collections.unmodifiableList(requiredAttributes);
        }

        public static List<SortingMethod> getOptionsForOrderingFiles() {
            return Arrays.asList(BY_FILE_SIZE, BY_FULL_PATH, BY_FILE_NAME, BY_DATA_SOURCE);
        }

        public static List<SortingMethod> getOptionsForOrderingDomains() {
            return Arrays.asList(BY_PAGE_VIEWS, BY_DOWNLOADS, BY_LAST_ACTIVITY, BY_DOMAIN_NAME);
        }

    }
}