ContentViewerTagManager.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.services.contentviewertags;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.datamodel.ContentTag;
import org.sleuthkit.datamodel.TskCoreException;

public class ContentViewerTagManager {

    //Used to convert Java beans into the physical representation that will be stored
    //in the database.
    private static final ObjectMapper SERIALIZER = new ObjectMapper();

    public static final String TABLE_NAME = "beta_tag_app_data";
    public static final String TABLE_SCHEMA_SQLITE = "(app_data_id INTEGER PRIMARY KEY, "
            + "content_tag_id INTEGER NOT NULL, app_data TEXT NOT NULL, "
            + "FOREIGN KEY(content_tag_id) REFERENCES content_tags(tag_id))";
    public static final String TABLE_SCHEMA_POSTGRESQL = "(app_data_id BIGSERIAL PRIMARY KEY, "
            + "content_tag_id INTEGER NOT NULL, app_data TEXT NOT NULL, "
            + "FOREIGN KEY(content_tag_id) REFERENCES content_tags(tag_id))";

    private static final String INSERT_TAG_DATA = "(content_tag_id, app_data) VALUES (%d, '%s')";
    private static final String UPDATE_TAG_DATA = "SET content_tag_id = %d, app_data = '%s' WHERE app_data_id = %d";
    private static final String SELECT_TAG_DATA = "* FROM " + TABLE_NAME + " WHERE content_tag_id = %d";
    private static final String DELETE_TAG_DATA = "WHERE app_data_id = %d";

    public static <T> ContentViewerTag<T> saveTag(ContentTag contentTag, T tagDataBean) 
            throws SerializationException, TskCoreException, NoCurrentCaseException {
        try {
            long contentTagId = contentTag.getId();
            String serialAppData = SERIALIZER.writeValueAsString(tagDataBean);
            String insertTemplateInstance = String.format(INSERT_TAG_DATA,
                    contentTagId, serialAppData);
            long insertId = Case.getCurrentCaseThrows()
                    .getSleuthkitCase()
                    .getCaseDbAccessManager()
                    .insert(TABLE_NAME, insertTemplateInstance);
            return new ContentViewerTag<>(insertId, contentTag, tagDataBean);
        } catch (JsonProcessingException ex) {
            throw new SerializationException("Unable to convert object instance into a storable format", ex);
        }
    }

    public static <T> ContentViewerTag<T> updateTag(ContentViewerTag<T> oldTag, T tagDataBean)
            throws SerializationException, TskCoreException, NoCurrentCaseException {
        try {
            String serialAppData = SERIALIZER.writeValueAsString(tagDataBean);
            String updateTemplateInstance = String.format(UPDATE_TAG_DATA,
                    oldTag.getContentTag().getId(), serialAppData, oldTag.getId());
            Case.getCurrentCaseThrows()
                    .getSleuthkitCase()
                    .getCaseDbAccessManager()
                    .update(TABLE_NAME, updateTemplateInstance);
            return new ContentViewerTag<>(oldTag.getId(), oldTag.getContentTag(), tagDataBean);
        } catch (JsonProcessingException ex) {
            throw new SerializationException("Unable to convert object instance into a storable format", ex);
        }
    }

    public static <T> ContentViewerTag<T> getTag(ContentTag contentTag, Class<T> clazz) throws TskCoreException, NoCurrentCaseException {
        String selectTemplateInstance = String.format(SELECT_TAG_DATA, contentTag.getId());
        final ResultWrapper<ContentViewerTag<T>> result = new ResultWrapper<>();
        Case.getCurrentCaseThrows()
                .getSleuthkitCase()
                .getCaseDbAccessManager()
                .select(selectTemplateInstance, (ResultSet rs) -> {
                    try {
                        if (rs.next()) {
                            long tagId = rs.getLong(1);
                            String appDetails = rs.getString(3);
                            try {
                                T instance = SERIALIZER.readValue(appDetails, clazz);
                                result.setResult(new ContentViewerTag<>(tagId, contentTag, instance));
                            } catch (IOException ex) {
                                //Databind for type T failed. Not a system error
                                //but rather a logic error on the part of the caller.
                                result.setResult(null);
                            }
                        }
                    } catch (SQLException ex) {
                        result.setException(ex);
                    }
                });

        if (result.hasException()) {
            throw new TskCoreException("Unable to select tag from case db", result.getException());
        }

        return result.getResult();
    }

    private static class ResultWrapper<T> {

        private T result;
        private SQLException ex = null;

        public void setResult(T result) {
            this.result = result;
        }

        public void setException(SQLException ex) {
            this.ex = ex;
        }

        public boolean hasException() {
            return this.ex != null;
        }

        public SQLException getException() {
            return ex;
        }

        public T getResult() {
            return result;
        }
    }

    public static <T> void deleteTag(ContentViewerTag<T> contentViewerTag) throws TskCoreException, NoCurrentCaseException {
        String deleteTemplateInstance = String.format(DELETE_TAG_DATA, contentViewerTag.getId());
        Case.getCurrentCaseThrows()
                .getSleuthkitCase()
                .getCaseDbAccessManager()
                .delete(TABLE_NAME, deleteTemplateInstance);
    }

    public static class ContentViewerTag<T> {

        private final long id;
        private final ContentTag contentTag;
        private final T details;

        private ContentViewerTag(long id, ContentTag contentTag, T details) {
            this.id = id;
            this.contentTag = contentTag;
            this.details = details;
        }

        public long getId() {
            return id;
        }

        public ContentTag getContentTag() {
            return contentTag;
        }

        public T getDetails() {
            return details;
        }
    }

    public static class SerializationException extends Exception {

        public SerializationException(String message, Exception source) {
            super(message, source);
        }
    }

    //Prevent this class from being instantiated.
    private ContentViewerTagManager() {
    }
}