DiscoveryKeyUtils.java

Go to the documentation of this file.

/*
 * Autopsy
 *
 * Copyright 2020-2021 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.time.DayOfWeek;
import java.time.Instant;
import java.time.ZonedDateTime;
import java.time.temporal.TemporalAdjusters;
import java.util.Collections;
import java.util.Set;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.TimeZone;
import java.util.logging.Level;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.centralrepository.datamodel.CentralRepository;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.TimeZoneUtils;
import org.sleuthkit.autopsy.discovery.search.SearchData.PageViews;
import org.sleuthkit.autopsy.discovery.ui.MonthAbbreviation;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;

public class DiscoveryKeyUtils {

    private final static Logger logger = Logger.getLogger(DiscoveryKeyUtils.class.getName());

    static class SearchKey implements Comparable<SearchKey> {

        private final String keyString;
        private final Group.GroupSortingAlgorithm groupSortingType;
        private final DiscoveryAttributes.AttributeType groupAttributeType;
        private final ResultsSorter.SortingMethod sortingMethod;
        private final List<AbstractFilter> filters;
        private final SleuthkitCase sleuthkitCase;
        private final CentralRepository centralRepository;
        private final SearchContext context;

        SearchKey(String userName, List<AbstractFilter> filters,
                DiscoveryAttributes.AttributeType groupAttributeType,
                Group.GroupSortingAlgorithm groupSortingType,
                ResultsSorter.SortingMethod sortingMethod,
                SleuthkitCase sleuthkitCase, CentralRepository centralRepository, SearchContext context) {
            this.groupAttributeType = groupAttributeType;
            this.groupSortingType = groupSortingType;
            this.sortingMethod = sortingMethod;
            this.filters = filters;
            this.context = context;

            StringBuilder searchStringBuilder = new StringBuilder();
            searchStringBuilder.append(userName);
            for (AbstractFilter filter : filters) {
                searchStringBuilder.append(filter.toString());
            }
            searchStringBuilder.append(groupAttributeType).append(groupSortingType).append(sortingMethod);
            keyString = searchStringBuilder.toString();
            this.sleuthkitCase = sleuthkitCase;
            this.centralRepository = centralRepository;
        }

        SearchKey(String userName, List<AbstractFilter> filters,
                DiscoveryAttributes.AttributeType groupAttributeType,
                Group.GroupSortingAlgorithm groupSortingType,
                ResultsSorter.SortingMethod sortingMethod) {
            this(userName, filters, groupAttributeType, groupSortingType,
                    sortingMethod, null, null, null);
            //this constructor should only be used putting things directly into a map or getting if present since casedb, cr, and search context will be null
        }

        @Override
        public int compareTo(SearchKey otherSearchKey) {
            return getKeyString().compareTo(otherSearchKey.getKeyString());
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof SearchKey)) {
                return false;
            }

            SearchKey otherSearchKey = (SearchKey) otherKey;
            if (this.sleuthkitCase != otherSearchKey.getSleuthkitCase()
                    || this.centralRepository != otherSearchKey.getCentralRepository()) {
                return false;
            }

            return getKeyString().equals(otherSearchKey.getKeyString());
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 79 * hash + Objects.hashCode(getKeyString());
            return hash;
        }

        SearchContext getContext() throws DiscoveryException {
            if (context == null) {
                throw new DiscoveryException("The key in use was created without a context and does not support retrieving information from the databases.");
            }
            return context;
        }

        String getKeyString() {
            return keyString;
        }

        List<AbstractFilter> getFilters() {
            return Collections.unmodifiableList(this.filters);
        }

        Group.GroupSortingAlgorithm getGroupSortingType() {
            return groupSortingType;
        }

        DiscoveryAttributes.AttributeType getGroupAttributeType() {
            return groupAttributeType;
        }

        ResultsSorter.SortingMethod getFileSortingMethod() {
            return sortingMethod;
        }

        SleuthkitCase getSleuthkitCase() {
            return this.sleuthkitCase;
        }

        CentralRepository getCentralRepository() {
            return this.centralRepository;
        }
    }

    public abstract static class GroupKey implements Comparable<GroupKey> {

        abstract String getDisplayName();

        @Override
        abstract public boolean equals(Object otherKey);

        @Override
        abstract public int hashCode();

        int compareClassNames(GroupKey otherGroupKey) {
            return this.getClass().getName().compareTo(otherGroupKey.getClass().getName());
        }

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

    static class FileSizeGroupKey extends GroupKey {

        private final SearchData.FileSize fileSize;

        FileSizeGroupKey(Result file) {
            ResultFile resultFile = (ResultFile) file;
            if (resultFile.getFileType() == SearchData.Type.VIDEO) {
                fileSize = SearchData.FileSize.fromVideoSize(resultFile.getFirstInstance().getSize());
            } else {
                fileSize = SearchData.FileSize.fromImageSize(resultFile.getFirstInstance().getSize());
            }
        }

        @Override
        String getDisplayName() {
            return getFileSize().toString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FileSizeGroupKey) {
                FileSizeGroupKey otherFileSizeGroupKey = (FileSizeGroupKey) otherGroupKey;
                return Integer.compare(getFileSize().getRanking(), otherFileSizeGroupKey.getFileSize().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FileSizeGroupKey)) {
                return false;
            }

            FileSizeGroupKey otherFileSizeGroupKey = (FileSizeGroupKey) otherKey;
            return getFileSize().equals(otherFileSizeGroupKey.getFileSize());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getFileSize().getRanking());
        }

        SearchData.FileSize getFileSize() {
            return fileSize;
        }
    }

    static class FileTypeGroupKey extends GroupKey {

        private final SearchData.Type fileType;

        FileTypeGroupKey(Result file) {
            fileType = ((ResultFile) file).getFileType();
        }

        @Override
        String getDisplayName() {
            return getFileType().toString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FileTypeGroupKey) {
                FileTypeGroupKey otherFileTypeGroupKey = (FileTypeGroupKey) otherGroupKey;
                return Integer.compare(getFileType().getRanking(), otherFileTypeGroupKey.getFileType().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FileTypeGroupKey)) {
                return false;
            }

            FileTypeGroupKey otherFileTypeGroupKey = (FileTypeGroupKey) otherKey;
            return getFileType().equals(otherFileTypeGroupKey.getFileType());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getFileType().getRanking());
        }

        SearchData.Type getFileType() {
            return fileType;
        }
    }

    static class KeywordListGroupKey extends GroupKey {

        private final List<String> keywordListNames;
        private final String keywordListNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.KeywordListGroupKey.noKeywords=None"})
        KeywordListGroupKey(ResultFile file) {
            keywordListNames = file.getKeywordListNames();
            if (keywordListNames.isEmpty()) {
                keywordListNamesString = Bundle.DiscoveryKeyUtils_KeywordListGroupKey_noKeywords();
            } else {
                keywordListNamesString = String.join(",", keywordListNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getKeywordListNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof KeywordListGroupKey) {
                KeywordListGroupKey otherKeywordListNamesGroupKey = (KeywordListGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (getKeywordListNames().isEmpty()) {
                    if (otherKeywordListNamesGroupKey.getKeywordListNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherKeywordListNamesGroupKey.getKeywordListNames().isEmpty()) {
                    return -1;
                }

                return getKeywordListNamesString().compareTo(otherKeywordListNamesGroupKey.getKeywordListNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof KeywordListGroupKey)) {
                return false;
            }

            KeywordListGroupKey otherKeywordListGroupKey = (KeywordListGroupKey) otherKey;
            return getKeywordListNamesString().equals(otherKeywordListGroupKey.getKeywordListNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getKeywordListNamesString());
        }

        List<String> getKeywordListNames() {
            return Collections.unmodifiableList(keywordListNames);
        }

        String getKeywordListNamesString() {
            return keywordListNamesString;
        }
    }

    static class FileTagGroupKey extends GroupKey {

        private final List<String> tagNames;
        private final String tagNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.FileTagGroupKey.noSets=None"})
        FileTagGroupKey(ResultFile file) {
            tagNames = file.getTagNames();

            if (tagNames.isEmpty()) {
                tagNamesString = Bundle.DiscoveryKeyUtils_FileTagGroupKey_noSets();
            } else {
                tagNamesString = String.join(",", tagNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getTagNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FileTagGroupKey) {
                FileTagGroupKey otherFileTagGroupKey = (FileTagGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (getTagNames().isEmpty()) {
                    if (otherFileTagGroupKey.getTagNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherFileTagGroupKey.getTagNames().isEmpty()) {
                    return -1;
                }

                return getTagNamesString().compareTo(otherFileTagGroupKey.getTagNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }
            if (!(otherKey instanceof FileTagGroupKey)) {
                return false;
            }
            FileTagGroupKey otherFileTagGroupKey = (FileTagGroupKey) otherKey;
            return getTagNamesString().equals(otherFileTagGroupKey.getTagNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getTagNamesString());
        }

        List<String> getTagNames() {
            return Collections.unmodifiableList(tagNames);
        }

        String getTagNamesString() {
            return tagNamesString;
        }
    }

    static class ParentPathGroupKey extends GroupKey {

        private String parentPath;
        private Long parentID;

        ParentPathGroupKey(ResultFile file) {
            Content parent;
            try {
                parent = file.getFirstInstance().getParent();
            } catch (TskCoreException ignored) {
                parent = null;
            }
            //Find the directory this file is in if it is an embedded file
            while (parent != null && parent instanceof AbstractFile && ((AbstractFile) parent).isFile()) {
                try {
                    parent = parent.getParent();
                } catch (TskCoreException ignored) {
                    parent = null;
                }
            }
            setParentPathAndID(parent, file);
        }

        private void setParentPathAndID(Content parent, ResultFile file) {
            if (parent != null) {
                try {
                    parentPath = parent.getUniquePath();
                    parentID = parent.getId();
                } catch (TskCoreException ignored) {
                    //catch block left blank purposefully next if statement will handle case when exception takes place as well as when parent is null
                }

            }
            if (parentPath == null) {
                if (file.getFirstInstance().getParentPath() != null) {
                    parentPath = file.getFirstInstance().getParentPath();
                } else {
                    parentPath = ""; // NON-NLS
                }
                parentID = -1L;
            }
        }

        @Override
        String getDisplayName() {
            return getParentPath();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof ParentPathGroupKey) {
                ParentPathGroupKey otherParentPathGroupKey = (ParentPathGroupKey) otherGroupKey;
                int comparisonResult = getParentPath().compareTo(otherParentPathGroupKey.getParentPath());
                if (comparisonResult == 0) {
                    comparisonResult = getParentID().compareTo(otherParentPathGroupKey.getParentID());
                }
                return comparisonResult;
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof ParentPathGroupKey)) {
                return false;
            }

            ParentPathGroupKey otherParentPathGroupKey = (ParentPathGroupKey) otherKey;
            return getParentPath().equals(otherParentPathGroupKey.getParentPath()) && getParentID().equals(otherParentPathGroupKey.getParentID());
        }

        @Override
        public int hashCode() {
            int hashCode = 11;
            hashCode = 61 * hashCode + Objects.hash(getParentPath());
            hashCode = 61 * hashCode + Objects.hash(getParentID());
            return hashCode;
        }

        String getParentPath() {
            return parentPath;
        }

        Long getParentID() {
            return parentID;
        }
    }

    static class DataSourceGroupKey extends GroupKey {

        private final long dataSourceID;
        private String displayName;

        @NbBundle.Messages({
            "# {0} - Data source name",
            "# {1} - Data source ID",
            "DiscoveryKeyUtils.DataSourceGroupKey.datasourceAndID={0}(ID: {1})",
            "# {0} - Data source ID",
            "DiscoveryKeyUtils.DataSourceGroupKey.idOnly=Data source (ID: {0})"})
        DataSourceGroupKey(Result result) {
            //get the id first so that it can be used when logging if necessary
            dataSourceID = result.getDataSourceObjectId();
            try {
                // The data source should be cached so this won't actually be a database query.
                Content ds = result.getDataSource();
                displayName = Bundle.DiscoveryKeyUtils_DataSourceGroupKey_datasourceAndID(ds.getName(), ds.getId());
            } catch (TskCoreException ex) {
                logger.log(Level.WARNING, "Error looking up data source with ID " + dataSourceID, ex); // NON-NLS
                displayName = Bundle.DiscoveryKeyUtils_DataSourceGroupKey_idOnly(dataSourceID);
            }
        }

        @Override
        String getDisplayName() {
            return displayName;
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof DataSourceGroupKey) {
                DataSourceGroupKey otherDataSourceGroupKey = (DataSourceGroupKey) otherGroupKey;
                return Long.compare(getDataSourceID(), otherDataSourceGroupKey.getDataSourceID());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof DataSourceGroupKey)) {
                return false;
            }

            DataSourceGroupKey otherDataSourceGroupKey = (DataSourceGroupKey) otherKey;
            return getDataSourceID() == otherDataSourceGroupKey.getDataSourceID();
        }

        @Override
        public int hashCode() {
            return Objects.hash(getDataSourceID());
        }

        long getDataSourceID() {
            return dataSourceID;
        }
    }

    static class NoGroupingGroupKey extends GroupKey {

        NoGroupingGroupKey() {
            // Nothing to save - all files will get the same GroupKey
        }

        @NbBundle.Messages({
            "DiscoveryKeyUtils.NoGroupingGroupKey.allFiles=All Files"})
        @Override
        String getDisplayName() {
            return Bundle.DiscoveryKeyUtils_NoGroupingGroupKey_allFiles();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            // As long as the other key is the same type, they are equal
            if (otherGroupKey instanceof NoGroupingGroupKey) {
                return 0;
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }
            // As long as the other key is the same type, they are equal
            return otherKey instanceof NoGroupingGroupKey;
        }

        @Override
        public int hashCode() {
            return 0;
        }
    }

    static class DomainCategoryGroupKey extends GroupKey {

        private final Set<String> webCategories = new HashSet<>();
        private final String displayName;

        DomainCategoryGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                ResultDomain domain = (ResultDomain) result;
                this.webCategories.addAll(domain.getWebCategories());
                displayName = String.join(",", webCategories);
            } else {
                throw new IllegalArgumentException("Input result should be of type ResultDomain");
            }
        }

        @Override
        String getDisplayName() {

            return this.displayName;
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey instanceof GroupKey) {
                return compareTo((GroupKey) otherKey) == 0;
            }
            return false;
        }

        @Override
        public int hashCode() {
            return Objects.hash(webCategories);
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof DomainCategoryGroupKey) {
                if (webCategories.size() != ((DomainCategoryGroupKey) otherGroupKey).getWebCategories().size()) {
                    return 1;
                }
                if (webCategories.containsAll(((DomainCategoryGroupKey) otherGroupKey).getWebCategories())) {
                    return 0;
                } else {
                    return -1;
                }
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        Set<String> getWebCategories() {
            return Collections.unmodifiableSet(webCategories);
        }
    }

    static class PreviouslyNotableGroupKey extends GroupKey {

        private final SearchData.PreviouslyNotable notableStatus;

        PreviouslyNotableGroupKey(Result result) {
            this.notableStatus = result.getPreviouslyNotableInCR();
        }

        @Override
        String getDisplayName() {
            return this.notableStatus.toString();
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey instanceof GroupKey) {
                return compareTo((GroupKey) otherKey) == 0;
            }
            return false;
        }

        @Override
        public int hashCode() {
            return Objects.hash(getStatus().getRanking());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof PreviouslyNotableGroupKey) {
                PreviouslyNotableGroupKey otherFrequencyGroupKey = (PreviouslyNotableGroupKey) otherGroupKey;
                return Integer.compare(getStatus().getRanking(), otherFrequencyGroupKey.getStatus().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        SearchData.PreviouslyNotable getStatus() {
            return notableStatus;
        }
    }

    static class FrequencyGroupKey extends GroupKey {

        private final SearchData.Frequency frequency;

        FrequencyGroupKey(Result result) {
            frequency = result.getFrequency();
        }

        @Override
        String getDisplayName() {
            return getFrequency().toString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FrequencyGroupKey) {
                FrequencyGroupKey otherFrequencyGroupKey = (FrequencyGroupKey) otherGroupKey;
                return Integer.compare(getFrequency().getRanking(), otherFrequencyGroupKey.getFrequency().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FrequencyGroupKey)) {
                return false;
            }

            FrequencyGroupKey otherFrequencyGroupKey = (FrequencyGroupKey) otherKey;
            return getFrequency().equals(otherFrequencyGroupKey.getFrequency());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getFrequency().getRanking());
        }

        SearchData.Frequency getFrequency() {
            return frequency;
        }
    }

    static class HashHitsGroupKey extends GroupKey {

        private final List<String> hashSetNames;
        private final String hashSetNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.HashHitsGroupKey.noHashHits=None"})
        HashHitsGroupKey(ResultFile file) {
            hashSetNames = file.getHashSetNames();

            if (hashSetNames.isEmpty()) {
                hashSetNamesString = Bundle.DiscoveryKeyUtils_HashHitsGroupKey_noHashHits();
            } else {
                hashSetNamesString = String.join(",", hashSetNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getHashSetNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof HashHitsGroupKey) {
                HashHitsGroupKey otherHashHitsGroupKey = (HashHitsGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (getHashSetNames().isEmpty()) {
                    if (otherHashHitsGroupKey.getHashSetNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherHashHitsGroupKey.getHashSetNames().isEmpty()) {
                    return -1;
                }

                return getHashSetNamesString().compareTo(otherHashHitsGroupKey.getHashSetNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof HashHitsGroupKey)) {
                return false;
            }

            HashHitsGroupKey otherHashHitsGroupKey = (HashHitsGroupKey) otherKey;
            return getHashSetNamesString().equals(otherHashHitsGroupKey.getHashSetNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getHashSetNamesString());
        }

        List<String> getHashSetNames() {
            return Collections.unmodifiableList(hashSetNames);
        }

        String getHashSetNamesString() {
            return hashSetNamesString;
        }
    }

    static class InterestingItemGroupKey extends GroupKey {

        private final List<String> interestingItemSetNames;
        private final String interestingItemSetNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.InterestingItemGroupKey.noSets=None"})
        InterestingItemGroupKey(ResultFile file) {
            interestingItemSetNames = file.getInterestingSetNames();

            if (interestingItemSetNames.isEmpty()) {
                interestingItemSetNamesString = Bundle.DiscoveryKeyUtils_InterestingItemGroupKey_noSets();
            } else {
                interestingItemSetNamesString = String.join(",", interestingItemSetNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getInterestingItemSetNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof InterestingItemGroupKey) {
                InterestingItemGroupKey otherInterestingItemGroupKey = (InterestingItemGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (this.getInterestingItemSetNames().isEmpty()) {
                    if (otherInterestingItemGroupKey.getInterestingItemSetNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherInterestingItemGroupKey.getInterestingItemSetNames().isEmpty()) {
                    return -1;
                }

                return getInterestingItemSetNamesString().compareTo(otherInterestingItemGroupKey.getInterestingItemSetNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof InterestingItemGroupKey)) {
                return false;
            }

            InterestingItemGroupKey otherInterestingItemGroupKey = (InterestingItemGroupKey) otherKey;
            return getInterestingItemSetNamesString().equals(otherInterestingItemGroupKey.getInterestingItemSetNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getInterestingItemSetNamesString());
        }

        List<String> getInterestingItemSetNames() {
            return Collections.unmodifiableList(interestingItemSetNames);
        }

        String getInterestingItemSetNamesString() {
            return interestingItemSetNamesString;
        }
    }

    static class LastActivityDateGroupKey extends GroupKey {

        private ZonedDateTime currentWeekCutOff;

        LastActivityDateGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                ResultDomain domainResult = ((ResultDomain) result);
                currentWeekCutOff = getCurrentWeekCutOff(domainResult.getActivityEnd(), domainResult);
            } else {
                throw new IllegalArgumentException("Expected a domain result only.");
            }
        }

        @NbBundle.Messages({
            "# {0} - month abbreviation",
            "# {1} - day of month",
            "# {2} - year",
            "DiscoveryAttributes.ActivityDateGroupKey.getDisplayNameTemplate=Week of {0} {1}, {2}"
        })
        @Override
        String getDisplayName() {
            MonthAbbreviation currentCutOffMonth = MonthAbbreviation.fromMonthValue(currentWeekCutOff.getMonthValue());
            return Bundle.DiscoveryAttributes_ActivityDateGroupKey_getDisplayNameTemplate(
                    currentCutOffMonth.toString(), Integer.toString(currentWeekCutOff.getDayOfMonth()),
                    Integer.toString(currentWeekCutOff.getYear()));
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof LastActivityDateGroupKey)) {
                return false;
            }

            LastActivityDateGroupKey dateGroupKey = (LastActivityDateGroupKey) otherKey;
            return getDisplayName().equals(dateGroupKey.getDisplayName());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getDisplayName());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof LastActivityDateGroupKey) {
                LastActivityDateGroupKey otherDateGroupKey = (LastActivityDateGroupKey) otherGroupKey;
                return Long.compare(otherDateGroupKey.currentWeekCutOff.toEpochSecond(), currentWeekCutOff.toEpochSecond());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }
    }

    private static ZonedDateTime getCurrentWeekCutOff(long epochSeconds, ResultDomain domainResult) {
        Instant startActivityAsInsant = Instant.ofEpochSecond(epochSeconds);
        // Determines the timezone using the settings panel or value parsed from the
        // parent data source
        TimeZone currentTimeZone = TimeZoneUtils.getTimeZone();
        // Convert to a datetime using epoch and timezone.
        ZonedDateTime startActivityAsDateTime = ZonedDateTime.ofInstant(startActivityAsInsant, currentTimeZone.toZoneId());
        // Get the closest Sunday, which is the cut off for the current week.
        // Use this cut off to perform grouping and comparing.
        return startActivityAsDateTime.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));
    }

    static class FirstActivityDateGroupKey extends GroupKey {

        private ZonedDateTime currentWeekCutOff;

        FirstActivityDateGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                ResultDomain domainResult = ((ResultDomain) result);
                currentWeekCutOff = getCurrentWeekCutOff(domainResult.getActivityStart(), domainResult);
            } else {
                throw new IllegalArgumentException("Expected a domain result only.");
            }
        }

        @Override
        String getDisplayName() {
            MonthAbbreviation currentCutOffMonth = MonthAbbreviation.fromMonthValue(currentWeekCutOff.getMonthValue());
            return Bundle.DiscoveryAttributes_ActivityDateGroupKey_getDisplayNameTemplate(
                    currentCutOffMonth.toString(), Integer.toString(currentWeekCutOff.getDayOfMonth()),
                    Integer.toString(currentWeekCutOff.getYear()));
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FirstActivityDateGroupKey)) {
                return false;
            }

            FirstActivityDateGroupKey dateGroupKey = (FirstActivityDateGroupKey) otherKey;
            return getDisplayName().equals(dateGroupKey.getDisplayName());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getDisplayName());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FirstActivityDateGroupKey) {
                FirstActivityDateGroupKey otherDateGroupKey = (FirstActivityDateGroupKey) otherGroupKey;
                return Long.compare(otherDateGroupKey.currentWeekCutOff.toEpochSecond(), currentWeekCutOff.toEpochSecond());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }
    }

    static class PageViewsGroupKey extends GroupKey {

        private final String displayName;
        private final PageViews pageViews;

        PageViewsGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                Long totalPageViews = ((ResultDomain) result).getTotalPageViews();
                if (totalPageViews == null) {
                    totalPageViews = 0L;
                }
                pageViews = PageViews.fromPageViewCount(totalPageViews);
                displayName = pageViews.toString();
            } else {
                throw new IllegalArgumentException("Expected a domain instance only.");
            }
        }

        @Override
        String getDisplayName() {
            return displayName;
        }

        @Override
        public int hashCode() {
            return Objects.hash(displayName);
        }

        PageViews getPageViews() {
            return pageViews;
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof PageViewsGroupKey)) {
                return false;
            }

            PageViewsGroupKey pageViewsKey = (PageViewsGroupKey) otherKey;
            return pageViews.equals(pageViewsKey.getPageViews());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof PageViewsGroupKey) {
                PageViewsGroupKey pageViewsKey = (PageViewsGroupKey) otherGroupKey;
                return getPageViews().compareTo(pageViewsKey.getPageViews());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }
    }

    static class ObjectDetectedGroupKey extends GroupKey {

        private final List<String> objectDetectedNames;
        private final String objectDetectedNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.ObjectDetectedGroupKey.noSets=None"})
        ObjectDetectedGroupKey(ResultFile file) {
            objectDetectedNames = file.getObjectDetectedNames();
            if (objectDetectedNames.isEmpty()) {
                objectDetectedNamesString = Bundle.DiscoveryKeyUtils_ObjectDetectedGroupKey_noSets();
            } else {
                objectDetectedNamesString = String.join(",", objectDetectedNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getObjectDetectedNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof ObjectDetectedGroupKey) {
                ObjectDetectedGroupKey otherObjectDetectedGroupKey = (ObjectDetectedGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (this.getObjectDetectedNames().isEmpty()) {
                    if (otherObjectDetectedGroupKey.getObjectDetectedNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherObjectDetectedGroupKey.getObjectDetectedNames().isEmpty()) {
                    return -1;
                }

                return getObjectDetectedNamesString().compareTo(otherObjectDetectedGroupKey.getObjectDetectedNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof ObjectDetectedGroupKey)) {
                return false;
            }

            ObjectDetectedGroupKey otherObjectDetectedGroupKey = (ObjectDetectedGroupKey) otherKey;
            return getObjectDetectedNamesString().equals(otherObjectDetectedGroupKey.getObjectDetectedNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getObjectDetectedNamesString());
        }

        List<String> getObjectDetectedNames() {
            return Collections.unmodifiableList(objectDetectedNames);
        }

        String getObjectDetectedNamesString() {
            return objectDetectedNamesString;
        }
    }

    private DiscoveryKeyUtils() {
        //private constructor in a utility class intentionally left blank
    }
}