DataSourceBrowser.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.casemodule.datasourcesummary;

import java.awt.EventQueue;
import java.beans.PropertyVetoException;
import javax.swing.ListSelectionModel;
import org.netbeans.swing.outline.DefaultOutlineModel;
import org.netbeans.swing.outline.Outline;
import org.openide.explorer.ExplorerManager;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Observer;
import java.util.logging.Level;
import org.sleuthkit.autopsy.coreutils.Logger;
import javax.swing.event.ListSelectionListener;
import org.openide.nodes.Node;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.autopsy.casemodule.datasourcesummary.DataSourceSummaryNode.DataSourceSummaryEntryNode;
import static javax.swing.SwingConstants.RIGHT;
import javax.swing.SwingUtilities;
import javax.swing.table.TableColumn;
import org.sleuthkit.datamodel.DataSource;
import org.sleuthkit.datamodel.IngestJobInfo;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;

final class DataSourceBrowser extends javax.swing.JPanel implements ExplorerManager.Provider {

    private static final long serialVersionUID = 1L;
    private static final Logger logger = Logger.getLogger(DataSourceBrowser.class.getName());
    private static final int COUNT_COLUMN_WIDTH = 20;
    private static final int INGEST_STATUS_WIDTH = 50;
    private static final int USAGE_COLUMN_WIDTH = 110;
    private static final int DATA_SOURCE_COLUMN_WIDTH = 280;
    private final Outline outline;
    private final org.openide.explorer.view.OutlineView outlineView;
    private final ExplorerManager explorerManager;
    private final List<DataSourceSummary> dataSourceSummaryList;
    private final RightAlignedTableCellRenderer rightAlignedRenderer = new RightAlignedTableCellRenderer();

    DataSourceBrowser(Map<Long, String> usageMap, Map<Long, Long> fileCountsMap) {
        initComponents();
        rightAlignedRenderer.setHorizontalAlignment(RIGHT);
        explorerManager = new ExplorerManager();
        outlineView = new org.openide.explorer.view.OutlineView();
        this.setVisible(true);
        outlineView.setPropertyColumns(
                Bundle.DataSourceSummaryNode_column_status_header(), Bundle.DataSourceSummaryNode_column_status_header(),
                Bundle.DataSourceSummaryNode_column_type_header(), Bundle.DataSourceSummaryNode_column_type_header(),
                Bundle.DataSourceSummaryNode_column_files_header(), Bundle.DataSourceSummaryNode_column_files_header(),
                Bundle.DataSourceSummaryNode_column_results_header(), Bundle.DataSourceSummaryNode_column_results_header(),
                Bundle.DataSourceSummaryNode_column_tags_header(), Bundle.DataSourceSummaryNode_column_tags_header());
        outline = outlineView.getOutline();

        outline.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        dataSourceSummaryList = getDataSourceSummaryList(usageMap, fileCountsMap);
        outline.setRootVisible(false);
        add(outlineView, java.awt.BorderLayout.CENTER);
        explorerManager.setRootContext(new DataSourceSummaryNode(dataSourceSummaryList));
        ((DefaultOutlineModel) outline.getOutlineModel()).setNodesColumnLabel(Bundle.DataSourceSummaryNode_column_dataSourceName_header());
        for (TableColumn column : Collections.list(outline.getColumnModel().getColumns())) {
            if (column.getHeaderValue().toString().equals(Bundle.DataSourceSummaryNode_column_files_header())
                    || column.getHeaderValue().toString().equals(Bundle.DataSourceSummaryNode_column_results_header())
                    || column.getHeaderValue().toString().equals(Bundle.DataSourceSummaryNode_column_tags_header())) {
                column.setCellRenderer(rightAlignedRenderer);
                column.setPreferredWidth(COUNT_COLUMN_WIDTH);
            } else if (column.getHeaderValue().toString().equals(Bundle.DataSourceSummaryNode_column_type_header())) {
                column.setPreferredWidth(USAGE_COLUMN_WIDTH);
            } else if (column.getHeaderValue().toString().equals(Bundle.DataSourceSummaryNode_column_status_header())) {
                column.setPreferredWidth(INGEST_STATUS_WIDTH);
            } else {
                column.setPreferredWidth(DATA_SOURCE_COLUMN_WIDTH);
            }
        }
        this.setVisible(true);
    }

    void selectDataSource(Long dataSourceId) {
        EventQueue.invokeLater(() -> {
            if (dataSourceId != null) {
                for (Node node : explorerManager.getRootContext().getChildren().getNodes()) {
                    if (node instanceof DataSourceSummaryEntryNode && ((DataSourceSummaryEntryNode) node).getDataSource().getId() == dataSourceId) {
                        try {
                            explorerManager.setExploredContextAndSelection(node, new Node[]{node});
                            return;
                        } catch (PropertyVetoException ex) {
                            logger.log(Level.WARNING, "Failed to select the datasource in the explorer view", ex); //NON-NLS
                        }
                    }
                }
            }
            //if no data source was selected and there are data sources to select select the first one
            if (explorerManager.getRootContext().getChildren().getNodes().length > 0) {
                outline.getSelectionModel().setSelectionInterval(0, 0);
            }
        });
    }

    void addObserver(Observer observer) {
        ((DataSourceSummaryNode) explorerManager.getRootContext()).addObserver(observer);
    }

    private List<DataSourceSummary> getDataSourceSummaryList(Map<Long, String> usageMap, Map<Long, Long> fileCountsMap) {
        List<DataSourceSummary> summaryList = new ArrayList<>();

        final Map<Long, Long> artifactCountsMap = DataSourceInfoUtilities.getCountsOfArtifacts();
        final Map<Long, Long> tagCountsMap = DataSourceInfoUtilities.getCountsOfTags();
        try {
            SleuthkitCase skCase = Case.getCurrentCaseThrows().getSleuthkitCase();
            for (DataSource dataSource : skCase.getDataSources()) {
                summaryList.add(new DataSourceSummary(dataSource, usageMap.get(dataSource.getId()),
                        fileCountsMap.get(dataSource.getId()), artifactCountsMap.get(dataSource.getId()), tagCountsMap.get(dataSource.getId())));
            }
        } catch (TskCoreException | NoCurrentCaseException ex) {
            logger.log(Level.WARNING, "Unable to datasources or their counts, providing empty results", ex);
        }
        return summaryList;
    }

    void addListSelectionListener(ListSelectionListener listener) {
        outline.getSelectionModel().addListSelectionListener(listener);
    }

    DataSource getSelectedDataSource() {
        Node selectedNode[] = explorerManager.getSelectedNodes();
        if (selectedNode.length == 1 && selectedNode[0] instanceof DataSourceSummaryEntryNode) {
            return ((DataSourceSummaryEntryNode) selectedNode[0]).getDataSource();
        }
        return null;
    }

    void refresh(long dataSourceId, IngestJobInfo.IngestJobStatusType newStatus) {

        //attempt to update the status of any datasources that had status which was STARTED
        for (DataSourceSummary summary : dataSourceSummaryList) {
            if (summary.getDataSource().getId() == dataSourceId) {
                summary.setIngestStatus(newStatus);
            }
        }
        //figure out which nodes were previously selected
        Node[] selectedNodes = explorerManager.getSelectedNodes();
        SwingUtilities.invokeLater(() -> {
            explorerManager.setRootContext(new DataSourceSummaryNode(dataSourceSummaryList));
            List<Node> nodesToSelect = new ArrayList<>();
            for (Node node : explorerManager.getRootContext().getChildren().getNodes()) {
                if (node instanceof DataSourceSummaryEntryNode) {
                    //there should only be one selected node as multi-select is disabled
                    for (Node selectedNode : selectedNodes) {
                        if (((DataSourceSummaryEntryNode) node).getDataSource().equals(((DataSourceSummaryEntryNode) selectedNode).getDataSource())) {
                            nodesToSelect.add(node);
                        }
                    }
                }
            }
            //reselect the previously selected Nodes
            try {
                explorerManager.setSelectedNodes(nodesToSelect.toArray(new Node[nodesToSelect.size()]));
            } catch (PropertyVetoException ex) {
                logger.log(Level.WARNING, "Error selecting previously selected nodes", ex);
            }

        });

    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        setLayout(new java.awt.BorderLayout());
    }// </editor-fold>//GEN-END:initComponents

    @Override
    public ExplorerManager getExplorerManager() {
        return explorerManager;
    }

    // Variables declaration - do not modify//GEN-BEGIN:variables
    // End of variables declaration//GEN-END:variables
}