TagsManager.java

Go to the documentation of this file.

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

import java.io.Closeable;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.datamodel.BlackboardArtifact;
import org.sleuthkit.datamodel.BlackboardArtifactTag;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.ContentTag;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TagName;
import org.sleuthkit.datamodel.TskCoreException;

public class TagsManager implements Closeable {

    private static final Logger LOGGER = Logger.getLogger(TagsManager.class.getName());
    @NbBundle.Messages("TagsManager.predefTagNames.bookmark.text=Bookmark")
    private static final Set<String> STANDARD_TAG_DISPLAY_NAMES = new HashSet<>(Arrays.asList(Bundle.TagsManager_predefTagNames_bookmark_text()));
    private final SleuthkitCase caseDb;

    TagsManager(SleuthkitCase caseDb) {
        this.caseDb = caseDb;
    }

    public List<TagName> getAllTagNames() throws TskCoreException {
        return caseDb.getAllTagNames();
    }

    public List<TagName> getTagNamesInUse() throws TskCoreException {
        return caseDb.getTagNamesInUse();
    }

    public synchronized Map<String, TagName> getDisplayNamesToTagNamesMap() throws TskCoreException {
        Map<String, TagName> tagNames = new HashMap<>();
        Set<TagNameDefiniton> customTypes = TagNameDefiniton.getTagNameDefinitions();
        for (TagNameDefiniton tagType : customTypes) {
            tagNames.put(tagType.getDisplayName(), null);
        }
        for (TagName tagName : caseDb.getAllTagNames()) {
            tagNames.put(tagName.getDisplayName(), tagName);
        }
        return new HashMap<>(tagNames);
    }

    public synchronized TagName addTagName(String displayName) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, "", TagName.HTML_COLOR.NONE);
    }

    public synchronized TagName addTagName(String displayName, String description) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, description, TagName.HTML_COLOR.NONE);
    }

    public synchronized TagName addTagName(String displayName, String description, TagName.HTML_COLOR color) throws TagNameAlreadyExistsException, TskCoreException {
        try {
            TagName tagName = caseDb.addTagName(displayName, description, color);
            if (!STANDARD_TAG_DISPLAY_NAMES.contains(displayName)) {
                Set<TagNameDefiniton> customTypes = TagNameDefiniton.getTagNameDefinitions();
                customTypes.add(new TagNameDefiniton(displayName, description, color));
                TagNameDefiniton.setTagNameDefinitions(customTypes);
            }
            return tagName;
        } catch (TskCoreException ex) {
            List<TagName> existingTagNames = caseDb.getAllTagNames();
            for (TagName tagName : existingTagNames) {
                if (tagName.getDisplayName().equals(displayName)) {
                    throw new TagNameAlreadyExistsException();
                }
            }
            throw ex;
        }
    }

    public ContentTag addContentTag(Content content, TagName tagName) throws TskCoreException {
        return addContentTag(content, tagName, "", -1, -1);
    }

    public ContentTag addContentTag(Content content, TagName tagName, String comment) throws TskCoreException {
        return addContentTag(content, tagName, comment, -1, -1);
    }

    public ContentTag addContentTag(Content content, TagName tagName, String comment, long beginByteOffset, long endByteOffset) throws TskCoreException {
        ContentTag tag;
        tag = caseDb.addContentTag(content, tagName, comment, beginByteOffset, endByteOffset);
        try {
            Case.getCurrentCase().notifyContentTagAdded(tag);
        } catch (IllegalStateException ex) {
            throw new TskCoreException("Added a tag to a closed case", ex);
        }
        return tag;
    }

    public void deleteContentTag(ContentTag tag) throws TskCoreException {
        caseDb.deleteContentTag(tag);
        try {
            Case.getCurrentCase().notifyContentTagDeleted(tag);
        } catch (IllegalStateException ex) {
            throw new TskCoreException("Deleted a tag from a closed case", ex);
        }
    }

    public synchronized List<ContentTag> getAllContentTags() throws TskCoreException {
        return caseDb.getAllContentTags();
    }

    public synchronized long getContentTagsCountByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getContentTagsCountByTagName(tagName);
    }

    public synchronized ContentTag getContentTagByTagID(long tagId) throws TskCoreException {
        return caseDb.getContentTagByID(tagId);
    }

    public synchronized List<ContentTag> getContentTagsByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getContentTagsByTagName(tagName);
    }

    public synchronized List<ContentTag> getContentTagsByContent(Content content) throws TskCoreException {
        return caseDb.getContentTagsByContent(content);
    }

    public synchronized BlackboardArtifactTag addBlackboardArtifactTag(BlackboardArtifact artifact, TagName tagName) throws TskCoreException {
        return addBlackboardArtifactTag(artifact, tagName, "");
    }

    public synchronized BlackboardArtifactTag addBlackboardArtifactTag(BlackboardArtifact artifact, TagName tagName, String comment) throws TskCoreException {
        BlackboardArtifactTag tag = caseDb.addBlackboardArtifactTag(artifact, tagName, comment);
        try {
            Case.getCurrentCase().notifyBlackBoardArtifactTagAdded(tag);
        } catch (IllegalStateException ex) {
            throw new TskCoreException("Added a tag to a closed case", ex);
        }
        return tag;
    }

    public synchronized void deleteBlackboardArtifactTag(BlackboardArtifactTag tag) throws TskCoreException {
        caseDb.deleteBlackboardArtifactTag(tag);
        try {
            Case.getCurrentCase().notifyBlackBoardArtifactTagDeleted(tag);
        } catch (IllegalStateException ex) {
            throw new TskCoreException("Deleted a tag from a closed case", ex);
        }
    }

    public synchronized List<BlackboardArtifactTag> getAllBlackboardArtifactTags() throws TskCoreException {
        return caseDb.getAllBlackboardArtifactTags();
    }

    public synchronized long getBlackboardArtifactTagsCountByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsCountByTagName(tagName);
    }

    public synchronized BlackboardArtifactTag getBlackboardArtifactTagByTagID(long tagId) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagByID(tagId);
    }

    public synchronized List<BlackboardArtifactTag> getBlackboardArtifactTagsByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsByTagName(tagName);
    }

    public synchronized List<BlackboardArtifactTag> getBlackboardArtifactTagsByArtifact(BlackboardArtifact artifact) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsByArtifact(artifact);
    }

    public static boolean containsIllegalCharacters(String content) {
        return (content.contains("\\")
                || content.contains(":")
                || content.contains("*")
                || content.contains("?")
                || content.contains("\"")
                || content.contains("<")
                || content.contains(">")
                || content.contains("|")
                || content.contains(",")
                || content.contains(";"));

    }

    public static class TagNameAlreadyExistsException extends Exception {

        private static final long serialVersionUID = 1L;
    }

    @Deprecated
    public synchronized boolean tagNameExists(String tagDisplayName) {
        try {
            Map<String, TagName> tagNames = getDisplayNamesToTagNamesMap();
            return tagNames.containsKey(tagDisplayName) && (tagNames.get(tagDisplayName) != null);
        } catch (TskCoreException ex) {
            LOGGER.log(Level.SEVERE, "Error querying case database for tag names", ex);
            return false;
        }
    }

    @Override
    @Deprecated
    public synchronized void close() throws IOException {
    }
}