DiscoveryEventUtils.java

Go to the documentation of this file.

/*
 * Autopsy
 *
 * Copyright 2019-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 com.google.common.eventbus.EventBus;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.sleuthkit.autopsy.discovery.search.DiscoveryKeyUtils.GroupKey;
import org.sleuthkit.autopsy.discovery.search.SearchData.Type;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.BlackboardArtifact;

public final class DiscoveryEventUtils {
 
    private final static EventBus discoveryEventBus = new EventBus();

    public static EventBus getDiscoveryEventBus() {
        return discoveryEventBus;
    }

    private DiscoveryEventUtils() {
        //Utility class private constructor intentionally left blank.
    }

    public static final class SearchStartedEvent {
 
        private final Type type;

        public SearchStartedEvent(Type type) {
            this.type = type;
        }

        public Type getType() {
            return type;
        }
 
    }

    public static final class ClearInstanceSelectionEvent {

        public ClearInstanceSelectionEvent() {
            //no arg constructor
        }
    }

    public static final class CancelBackgroundTasksEvent {
 
        public CancelBackgroundTasksEvent() {
            //no-arg constructor
        }
    }

    public static final class PopulateInstancesListEvent {
 
        private final List<AbstractFile> instances;

        public PopulateInstancesListEvent(List<AbstractFile> files) {
            instances = files;
        }

        public List<AbstractFile> getInstances() {
            return Collections.unmodifiableList(instances);
        }
    }

    public static final class PopulateDomainTabsEvent {
 
        private final String domain;

        public PopulateDomainTabsEvent(String domain) {
            this.domain = domain;
        }

        public String getDomain() {
            return domain;
        }
    }

    public static final class SearchCompleteEvent {
 
        private final Map<GroupKey, Integer> groupMap;
        private final List<AbstractFilter> searchFilters;
        private final DiscoveryAttributes.AttributeType groupingAttribute;
        private final Group.GroupSortingAlgorithm groupSort;
        private final ResultsSorter.SortingMethod sortMethod;

        public SearchCompleteEvent(Map<GroupKey, Integer> groupMap, List<AbstractFilter> searchfilters,
                DiscoveryAttributes.AttributeType groupingAttribute, Group.GroupSortingAlgorithm groupSort,
                ResultsSorter.SortingMethod sortMethod) {
            this.groupMap = groupMap;
            this.searchFilters = searchfilters;
            this.groupingAttribute = groupingAttribute;
            this.groupSort = groupSort;
            this.sortMethod = sortMethod;
        }

        public Map<GroupKey, Integer> getGroupMap() {
            return Collections.unmodifiableMap(groupMap);
        }

        public List<AbstractFilter> getFilters() {
            return Collections.unmodifiableList(searchFilters);
        }

        public DiscoveryAttributes.AttributeType getGroupingAttr() {
            return groupingAttribute;
        }

        public Group.GroupSortingAlgorithm getGroupSort() {
            return groupSort;
        }

        public ResultsSorter.SortingMethod getResultSort() {
            return sortMethod;
        }
 
    }

    public static final class ArtifactSearchResultEvent {
 
        private final List<BlackboardArtifact> listOfArtifacts = new ArrayList<>();
        private final BlackboardArtifact.ARTIFACT_TYPE artifactType;
        private final boolean grabFocus;

        public ArtifactSearchResultEvent(BlackboardArtifact.ARTIFACT_TYPE artifactType, List<BlackboardArtifact> listOfArtifacts, boolean shouldGrabFocus) {
            if (listOfArtifacts != null) {
                this.listOfArtifacts.addAll(listOfArtifacts);
            }
            this.artifactType = artifactType;
            this.grabFocus = shouldGrabFocus;
        }

        public List<BlackboardArtifact> getListOfArtifacts() {
            return Collections.unmodifiableList(listOfArtifacts);
        }

        public BlackboardArtifact.ARTIFACT_TYPE getArtifactType() {
            return artifactType;
        }

        public boolean shouldGrabFocus() {
            return grabFocus;
        }
 
    }

    public static final class MiniTimelineResultEvent {
 
        private final List<MiniTimelineResult> results = new ArrayList<>();
        private final String domain;
        private final boolean grabFocus;

        public MiniTimelineResultEvent(List<MiniTimelineResult> results, String domain, boolean shouldGrabFocus) {
            if (results != null) {
                this.results.addAll(results);
            }
            this.grabFocus = shouldGrabFocus;
            this.domain = domain;
        }

        public List<MiniTimelineResult> getResultList() {
            return Collections.unmodifiableList(results);
        }

        public String getDomain() {
            return domain;
        }

        public boolean shouldGrabFocus() {
            return grabFocus;
        }
    }

    public static final class PageRetrievedEvent {
 
        private final List<Result> results;
        private final int page;
        private final Type resultType;

        public PageRetrievedEvent(Type resultType, int page, List<Result> results) {
            this.results = results;
            this.page = page;
            this.resultType = resultType;
        }

        public List<Result> getSearchResults() {
            return Collections.unmodifiableList(results);
        }

        public int getPageNumber() {
            return page;
        }

        public Type getType() {
            return resultType;
        }
    }

    public static final class NoResultsEvent {

        public NoResultsEvent() {
            //no arg constructor
        }
    }

    public static final class SearchCancelledEvent {

        public SearchCancelledEvent() {
            //no arg constructor
        }
 
    }

    public static final class GroupSelectedEvent {
 
        private final Type resultType;
        private final GroupKey groupKey;
        private final int groupSize;
        private final List<AbstractFilter> searchfilters;
        private final DiscoveryAttributes.AttributeType groupingAttribute;
        private final Group.GroupSortingAlgorithm groupSort;
        private final ResultsSorter.SortingMethod sortMethod;

        public GroupSelectedEvent(List<AbstractFilter> searchfilters,
                DiscoveryAttributes.AttributeType groupingAttribute, Group.GroupSortingAlgorithm groupSort,
                ResultsSorter.SortingMethod sortMethod, GroupKey groupKey, int groupSize, Type resultType) {
            this.searchfilters = searchfilters;
            this.groupingAttribute = groupingAttribute;
            this.groupSort = groupSort;
            this.sortMethod = sortMethod;
            this.groupKey = groupKey;
            this.groupSize = groupSize;
            this.resultType = resultType;
        }

        public Type getResultType() {
            return resultType;
        }

        public GroupKey getGroupKey() {
            return groupKey;
        }

        public int getGroupSize() {
            return groupSize;
        }

        public Group.GroupSortingAlgorithm getGroupSort() {
            return groupSort;
        }

        public ResultsSorter.SortingMethod getResultSort() {
            return sortMethod;
        }

        public List<AbstractFilter> getFilters() {
            return Collections.unmodifiableList(searchfilters);
        }

        public DiscoveryAttributes.AttributeType getGroupingAttr() {
            return groupingAttribute;
        }
 
    }

    public static class DetailsVisibleEvent {
 
        private final boolean showDetailsArea;

        public DetailsVisibleEvent(boolean isVisible) {
            showDetailsArea = isVisible;
        }

        public boolean isShowDetailsArea() {
            return showDetailsArea;
        }
    }
 
}