MapWaypoint.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.geolocation;

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JMenuItem;
import org.jxmapviewer.viewer.GeoPosition;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.actions.AddBlackboardArtifactTagAction;
import org.sleuthkit.autopsy.actions.AddContentTagAction;
import org.sleuthkit.autopsy.actions.DeleteFileBlackboardArtifactTagAction;
import org.sleuthkit.autopsy.actions.DeleteFileContentTagAction;
import org.sleuthkit.autopsy.coreutils.ImageUtils;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.datamodel.DataModelActionsFactory;
import org.sleuthkit.autopsy.datamodel.FileNode;
import org.sleuthkit.autopsy.directorytree.ExportCSVAction;
import org.sleuthkit.autopsy.directorytree.ExternalViewerAction;
import org.sleuthkit.autopsy.directorytree.ExternalViewerShortcutAction;
import org.sleuthkit.autopsy.directorytree.ExtractAction;
import org.sleuthkit.autopsy.directorytree.actionhelpers.ExtractActionHelper;
import org.sleuthkit.autopsy.geolocation.datamodel.Waypoint;
import org.sleuthkit.autopsy.timeline.actions.ViewArtifactInTimelineAction;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.BlackboardArtifact;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.TskCoreException;

@SuppressWarnings("deprecation")
final class MapWaypoint extends KdTree.XYZPoint implements org.jxmapviewer.viewer.Waypoint {

    private static final Logger logger = Logger.getLogger(MapWaypoint.class.getName());
    private final static String HTML_PROP_FORMAT = "<b>%s: </b>%s<br>";
    static private final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX", Locale.US);

    private static final Map<Integer, Color> artifactTypesToColors = new HashMap<>();

    static {
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_GPS_BOOKMARK.getTypeID(), Color.BLUE);
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_GPS_LAST_KNOWN_LOCATION.getTypeID(), Color.RED);
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_GPS_ROUTE.getTypeID(), Color.CYAN);
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_GPS_SEARCH.getTypeID(), Color.GREEN);
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_GPS_TRACK.getTypeID(), Color.ORANGE);
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_GPS_TRACKPOINT.getTypeID(), Color.ORANGE);
        artifactTypesToColors.put(BlackboardArtifact.ARTIFACT_TYPE.TSK_METADATA_EXIF.getTypeID(), Color.MAGENTA);
    }

    private final Waypoint dataModelWaypoint;
    private final GeoPosition position;

    static Set<MapWaypoint> getWaypoints(List<Waypoint> dmWaypoints) {
        Set<MapWaypoint> mapPoints = new LinkedHashSet<>();

        if (dmWaypoints != null) {

            for (Waypoint point : dmWaypoints) {
                mapPoints.add(new MapWaypoint(point));
            }
        }

        return mapPoints;
    }

    static List<Waypoint> getDataModelWaypoints(List<MapWaypoint> mapWaypoints) {
        List<Waypoint> waypoints = new ArrayList<>();

        if (mapWaypoints != null) {
            for (MapWaypoint point : mapWaypoints) {
                waypoints.add(point.dataModelWaypoint);
            }
        }

        return waypoints;
    }

    static MapWaypoint getDummyWaypoint(GeoPosition position) {
        return new MapWaypoint(position);
    }

    private MapWaypoint(Waypoint dataModelWaypoint) {
        super(dataModelWaypoint.getLatitude(), dataModelWaypoint.getLongitude());
        this.dataModelWaypoint = dataModelWaypoint;
        position = new GeoPosition(dataModelWaypoint.getLatitude(), dataModelWaypoint.getLongitude());
    }

    private MapWaypoint(GeoPosition position) {
        super(position.getLatitude(), position.getLongitude());
        dataModelWaypoint = null;
        this.position = position;
    }

    ImageIcon getImage() {
        if (dataModelWaypoint.getImage() != null && ImageUtils.isImageThumbnailSupported(dataModelWaypoint.getImage())) {
            BufferedImage buffImage = ImageUtils.getThumbnail(dataModelWaypoint.getImage(), 150);
            return new ImageIcon(buffImage);
        }

        return null;
    }

    @Override
    public GeoPosition getPosition() {
        return position;
    }

    String getLabel() {
        return dataModelWaypoint.getLabel();
    }

    String getHTMLFormattedWaypointDetails() {
        return getFormattedDetails(dataModelWaypoint);
    }

    int getArtifactTypeID() {
        return dataModelWaypoint.getArtifact().getArtifactTypeID();
    }

    JMenuItem[] getMenuItems() throws TskCoreException {
        List<JMenuItem> menuItems = new ArrayList<>();
        BlackboardArtifact artifact = dataModelWaypoint.getArtifact();
        Content content = artifact.getSleuthkitCase().getContentById(artifact.getObjectID());

        menuItems.addAll(getTimelineMenuItems(dataModelWaypoint.getArtifact()));
        menuItems.addAll(getDataModelActionFactoryMenuItems(artifact, content));
        menuItems.add(DeleteFileContentTagAction.getInstance().getMenuForFiles(Arrays.asList((AbstractFile) content)));
        menuItems.add(DeleteFileBlackboardArtifactTagAction.getInstance().getMenuForArtifacts(Arrays.asList(artifact)));

        return menuItems.toArray(new JMenuItem[0]);
    }

    private List<JMenuItem> getTimelineMenuItems(BlackboardArtifact artifact) {
        List<JMenuItem> menuItems = new ArrayList<>();
        //if this artifact has a time stamp add the action to view it in the timeline
        try {
            if (ViewArtifactInTimelineAction.hasSupportedTimeStamp(artifact)) {
                menuItems.add(new JMenuItem(new ViewArtifactInTimelineAction(artifact)));
            }
        } catch (TskCoreException ex) {
            logger.log(Level.SEVERE, String.format("Error getting arttribute(s) from blackboard artifact %d.", artifact.getArtifactID()), ex); //NON-NLS
        }

        return menuItems;
    }

    @Messages({
        "MayWaypoint_ExternalViewer_label=Open in ExternalViewer"
    })
    private List<JMenuItem> getDataModelActionFactoryMenuItems(BlackboardArtifact artifact, Content content) {
        List<JMenuItem> menuItems = new ArrayList<>();

        List<Action> actions = DataModelActionsFactory.getActions(content, true);
        for (Action action : actions) {
            if (action == null) {
                menuItems.add(null);
            } else if (action instanceof ExportCSVAction) {
                // Do nothing we don't need this menu item.
            } else if (action instanceof AddContentTagAction) {
                menuItems.add(((AddContentTagAction) action).getMenuForContent(Arrays.asList((AbstractFile) content)));
            } else if (action instanceof AddBlackboardArtifactTagAction) {
                menuItems.add(((AddBlackboardArtifactTagAction) action).getMenuForContent(Arrays.asList(artifact)));
            } else if (action instanceof ExternalViewerShortcutAction) {
                // Replace with an ExternalViewerAction
                ExternalViewerAction newAction = new ExternalViewerAction(Bundle.MayWaypoint_ExternalViewer_label(), new FileNode((AbstractFile) content));
                menuItems.add(new JMenuItem(newAction));
            } else if (action instanceof ExtractAction) {
                menuItems.add(new JMenuItem(new WaypointExtractAction((AbstractFile) content)));
            } else {
                menuItems.add(new JMenuItem(action));
            }
        }
        return menuItems;
    }

    private String getFormattedDetails(Waypoint point) {
        StringBuilder result = new StringBuilder(); //NON-NLS

        result.append("<html>").append(formatAttribute("Name", point.getLabel()));

        Long timestamp = point.getTimestamp();
        if (timestamp != null) {
            result.append(formatAttribute("Timestamp", getTimeStamp(timestamp)));
        }

        result.append(formatAttribute("Latitude", point.getLatitude().toString()))
                .append(formatAttribute("Longitude", point.getLongitude().toString()));

        if (point.getAltitude() != null) {
            result.append(formatAttribute("Altitude", point.getAltitude().toString()));
        }

        List<Waypoint.Property> list = point.getOtherProperties();
        for (Waypoint.Property prop : list) {
            String value = prop.getValue();
            if (value != null && !value.isEmpty()) {
                result.append(formatAttribute(prop.getDisplayName(), value));
            }
        }

        result.append("</html>");

        return result.toString();
    }

    private String formatAttribute(String title, String value) {
        return String.format(HTML_PROP_FORMAT, title, value);
    }

    private String getTimeStamp(long timeStamp) {
        return DATE_FORMAT.format(new java.util.Date(timeStamp * 1000));
    }

    static Color getColor(int artifactTypeId) {
        return artifactTypesToColors.getOrDefault(artifactTypeId, Color.GRAY);
    }

    Color getColor() {
        return getColor(dataModelWaypoint.getArtifact().getArtifactTypeID());
    }

    @Messages({
        "WaypointExtractAction_label=Extract Files(s)"
    })
    final class WaypointExtractAction extends AbstractAction {

        private static final long serialVersionUID = 1L;
        final private AbstractFile file;

        WaypointExtractAction(AbstractFile file) {
            super(Bundle.WaypointExtractAction_label());
            this.file = file;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            ExtractActionHelper helper = new ExtractActionHelper();
            helper.extract(e, Arrays.asList(file));

        }
    }
}