ViewContextAction.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2018 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.directorytree;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.beans.PropertyVetoException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import org.sleuthkit.autopsy.coreutils.Logger;
import javax.swing.AbstractAction;
import org.openide.nodes.AbstractNode;
import org.openide.explorer.ExplorerManager;
import org.openide.explorer.view.TreeView;
import org.openide.nodes.Children;
import org.openide.nodes.Node;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.CasePreferences;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.autopsy.core.UserPreferences;
import org.sleuthkit.autopsy.coreutils.MessageNotifyUtil;
import org.sleuthkit.autopsy.datamodel.AbstractAbstractFileNode;
import org.sleuthkit.autopsy.datamodel.AbstractFsContentNode;
import org.sleuthkit.autopsy.datamodel.BlackboardArtifactNode;
import org.sleuthkit.autopsy.datamodel.ContentNodeSelectionInfo;
import org.sleuthkit.autopsy.datamodel.DataSourcesNode;
import org.sleuthkit.autopsy.datamodel.DisplayableItemNode;
import org.sleuthkit.autopsy.datamodel.RootContentChildren;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.BlackboardArtifact;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.ContentVisitor;
import org.sleuthkit.datamodel.DataSource;
import org.sleuthkit.datamodel.FileSystem;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskData;
import org.sleuthkit.datamodel.TskDataException;
import org.sleuthkit.datamodel.VolumeSystem;

public class ViewContextAction extends AbstractAction {

    private static final long serialVersionUID = 1L;
    private static final Logger logger = Logger.getLogger(ViewContextAction.class.getName());
    private final Content content;

    public ViewContextAction(String displayName, BlackboardArtifactNode artifactNode) {
        super(displayName);
        this.content = artifactNode.getLookup().lookup(Content.class);
        if (this.content != null && this.content instanceof AbstractFile) {
            AbstractFile file = (AbstractFile) content;
            //disable the action if the content is a file and the file is hidden
            if ((TskData.FileKnown.KNOWN == file.getKnown() && UserPreferences.hideKnownFilesInDataSourcesTree())
                    || (TskData.TSK_DB_FILES_TYPE_ENUM.SLACK == file.getType() && UserPreferences.hideSlackFilesInDataSourcesTree())) {
                this.setEnabled(false);
            }
        }
    }

    public ViewContextAction(String displayName, AbstractFsContentNode<? extends AbstractFile> fileSystemContentNode) {
        super(displayName);
        this.content = fileSystemContentNode.getLookup().lookup(Content.class);
    }

    public ViewContextAction(String displayName, AbstractAbstractFileNode<? extends AbstractFile> abstractAbstractFileNode) {
        super(displayName);
        this.content = abstractAbstractFileNode.getLookup().lookup(Content.class);
    }

    public ViewContextAction(String displayName, Content content) {
        super(displayName);
        this.content = content;
    }

    @Override
    @Messages({
        "ViewContextAction.errorMessage.cannotFindDirectory=Failed to locate directory.",
        "ViewContextAction.errorMessage.cannotSelectDirectory=Failed to select directory in tree.",
        "ViewContextAction.errorMessage.cannotFindNode=Failed to locate data source node in tree."
    })
    public void actionPerformed(ActionEvent event) {
        EventQueue.invokeLater(() -> {

            /*
             * Get the parent content for the content to be selected in the
             * results view. If the parent content is null, then the specified
             * content is a data source, and the parent tree view node is the
             * "Data Sources" node. Otherwise, the tree view needs to be
             * searched to find the parent treeview node.
             */
            Content parentContent = null;
            try {
                parentContent = content.getParent();
            } catch (TskCoreException ex) {
                MessageNotifyUtil.Message.error(Bundle.ViewContextAction_errorMessage_cannotFindDirectory());
                logger.log(Level.SEVERE, String.format("Could not get parent of Content object: %s", content), ex); //NON-NLS
                return;
            }

            /*
             * Get the "Data Sources" node from the tree view.
             */
            DirectoryTreeTopComponent treeViewTopComponent = DirectoryTreeTopComponent.findInstance();
            ExplorerManager treeViewExplorerMgr = treeViewTopComponent.getExplorerManager();
            Node parentTreeViewNode = null;
            if (Objects.equals(CasePreferences.getGroupItemsInTreeByDataSource(), true)) { // 'Group by Data Source' view

                SleuthkitCase skCase;
                String dsname;
                try {
                    // get the objid/name of the datasource of the selected content.
                    skCase = Case.getCurrentCaseThrows().getSleuthkitCase();
                    long contentDSObjid = content.getDataSource().getId();
                    DataSource datasource = skCase.getDataSource(contentDSObjid);
                    dsname = datasource.getName();
                    Children rootChildren = treeViewExplorerMgr.getRootContext().getChildren();
                    
                    if (null != parentContent) {
                        // the tree view needs to be searched to find the parent treeview node.
                        /* NOTE: we can't do a lookup by data source name here, becase if there 
                        are multiple data sources with the same name, then "getChildren().findChild(dsname)"
                        simply returns the first one that it finds. Instead we have to loop over all
                        data sources with that name, and make sure we find the correct one.
                         */                        
                        for (int i = 0; i < rootChildren.getNodesCount(); i++) {
                            // in the root, look for a data source node with the name of interest
                            Node treeNode = rootChildren.getNodeAt(i);
                            if (!(treeNode.getName().equals(dsname))) {
                                continue;
                            }

                            // for this data source, get the "Data Sources" child node
                            Node datasourceGroupingNode = treeNode.getChildren().findChild(DataSourcesNode.NAME);

                            // check whether this is the data source we are looking for
                            parentTreeViewNode = findParentNodeInTree(parentContent, datasourceGroupingNode);
                            if (parentTreeViewNode != null) {
                                // found the data source node
                                break;
                            }
                        }
                    } else {
                        /* If the parent content is null, then the specified
                        * content is a data source, and the parent tree view node is the
                        * "Data Sources" node. */
                        Node datasourceGroupingNode = rootChildren.findChild(dsname);
                        if (!Objects.isNull(datasourceGroupingNode)) {
                            Children dsChildren = datasourceGroupingNode.getChildren();
                            parentTreeViewNode = dsChildren.findChild(DataSourcesNode.NAME);
                        }
                    }

                    if (parentTreeViewNode == null) {
                        MessageNotifyUtil.Message.error(Bundle.ViewContextAction_errorMessage_cannotFindNode());
                        logger.log(Level.SEVERE, "Failed to locate data source node in tree."); //NON-NLS
                        return;
                    }
                } catch (NoCurrentCaseException | TskDataException | TskCoreException ex) {
                    MessageNotifyUtil.Message.error(Bundle.ViewContextAction_errorMessage_cannotFindNode());
                    logger.log(Level.SEVERE, "Failed to locate data source node in tree.", ex); //NON-NLS
                    return;
                }
            } else {  // Classic view 
                // Start the search at the DataSourcesNode
                parentTreeViewNode = treeViewExplorerMgr.getRootContext().getChildren().findChild(DataSourcesNode.NAME);

                if (null != parentContent) {
                    // the tree view needs to be searched to find the parent treeview node.
                    Node potentialParentTreeViewNode = findParentNodeInTree(parentContent, parentTreeViewNode);
                    if (potentialParentTreeViewNode != null) {
                        parentTreeViewNode = potentialParentTreeViewNode;
                    }
                }
            }

            /*
             * Set the child selection info of the parent tree node, then select
             * the parent node in the tree view. The results view will retrieve
             * this selection info and use it to complete this action when the
             * tree view top component responds to the selection of the parent
             * node by pushing it into the results view top component.
             */
            DisplayableItemNode undecoratedParentNode = (DisplayableItemNode) ((DirectoryTreeFilterNode) parentTreeViewNode).getOriginal();
            undecoratedParentNode.setChildNodeSelectionInfo(new ContentNodeSelectionInfo(content));
            if (content instanceof BlackboardArtifact) {
                BlackboardArtifact artifact = ((BlackboardArtifact) content);
                long associatedId = artifact.getObjectID();
                try {
                    Content associatedFileContent = artifact.getSleuthkitCase().getContentById(associatedId);
                    undecoratedParentNode.setChildNodeSelectionInfo(new ContentNodeSelectionInfo(associatedFileContent));
                } catch (TskCoreException ex) {
                    logger.log(Level.SEVERE, "Could not find associated content from artifact with id %d", artifact.getId());
                }
            }

            TreeView treeView = treeViewTopComponent.getTree();
            treeView.expandNode(parentTreeViewNode);
            if (treeViewTopComponent.getSelectedNode().equals(parentTreeViewNode)) {
                //In the case where our tree view already has the destination directory selected 
                //due to an optimization in the ExplorerManager.setExploredContextAndSelection method 
                //the property change we listen for to call DirectoryTreeTopComponent.respondSelection 
                //will not be sent so we call it manually ourselves after making 
                //the directory listing the active tab.
                treeViewTopComponent.setDirectoryListingActive();
                treeViewTopComponent.respondSelection(treeViewExplorerMgr.getSelectedNodes(), new Node[]{parentTreeViewNode});
            } else {
                try {
                    treeViewExplorerMgr.setExploredContextAndSelection(parentTreeViewNode, new Node[]{parentTreeViewNode});
                } catch (PropertyVetoException ex) {
                    MessageNotifyUtil.Message.error(Bundle.ViewContextAction_errorMessage_cannotSelectDirectory());
                    logger.log(Level.SEVERE, "Failed to select the parent node in the tree view", ex); //NON-NLS
                }
            }
        });
    }

    private Node findParentNodeInTree(Content parentContent, Node node) {
        /*
         * Get an ordered list of the ancestors of the specified
         * content, starting with its data source.
         *
         */
        AncestorVisitor ancestorVisitor = new AncestorVisitor();
        List<Content> contentBranch = parentContent.accept(ancestorVisitor);
        Collections.reverse(contentBranch);

        Node dummyRootNode = new DirectoryTreeFilterNode(new AbstractNode(new RootContentChildren(contentBranch)), true);
        Children ancestorChildren = dummyRootNode.getChildren();

        /*
        * Search the tree for the parent node. Note that this algorithm
        * simply discards "extra" ancestor nodes not shown in the tree,
        * such as the root directory of the file system for file system
        * content.
         */
        Children treeNodeChildren = node.getChildren();
        Node parentTreeViewNode = null;
        for (int i = 0; i < ancestorChildren.getNodesCount(); i++) {
            Node ancestorNode = ancestorChildren.getNodeAt(i);
            for (int j = 0; j < treeNodeChildren.getNodesCount(); j++) {
                Node treeNode = treeNodeChildren.getNodeAt(j);
                if (ancestorNode.getName().equals(treeNode.getName())) {
                    parentTreeViewNode = treeNode;
                    treeNodeChildren = treeNode.getChildren();
                    break;
                }
            }
        }
        return parentTreeViewNode;
    }

    private static class AncestorVisitor extends ContentVisitor.Default<List<Content>> {

        List<Content> lineage = new ArrayList<>();

        @Override
        protected List<Content> defaultVisit(Content content) {
            lineage.add(content);
            Content parent = null;
            try {
                parent = content.getParent();
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, String.format("Could not get parent of Content object: %s", content), ex); //NON-NLS
            }
            return parent == null ? lineage : parent.accept(this);
        }

        @Override
        public List<Content> visit(VolumeSystem volumeSystem) {
            /*
             * Volume systems are not shown in the tree view. This is not
             * strictly necesssary given the algorithm above, but it is a simple
             * optimization.
             */
            return skipToParent(volumeSystem);
        }

        @Override
        public List<Content> visit(FileSystem fileSystem) {
            /*
             * File systems are not shown in the tree view. This is not strictly
             * necesssary given the algorithm above, but it is a simple
             * optimization.
             */
            return skipToParent(fileSystem);
        }

        private List<Content> skipToParent(Content content) {
            Content parent = null;
            try {
                parent = content.getParent();
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, String.format("Could not get parent of Content object: %s", content), ex); //NON-NLS
            }
            return parent == null ? lineage : parent.accept(this);
        }
    }

}