TagsManager.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.casemodule.services;

import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
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.casemodule.NoCurrentCaseException;
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;
import org.sleuthkit.datamodel.TskData;

public class TagsManager implements Closeable {

    private static final Logger LOGGER = Logger.getLogger(TagsManager.class.getName());

    private final SleuthkitCase caseDb;

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

    }
    @NbBundle.Messages({"TagsManager.notableTagEnding.text= (Notable)"})
    public static String getNotableTagLabel(){
        return Bundle.TagsManager_notableTagEnding_text();
    }

    public static Set<String> getTagDisplayNames() throws TskCoreException {
        Set<String> tagDisplayNames = new HashSet<>();
        Set<TagNameDefinition> customNames = TagNameDefinition.getTagNameDefinitions();
        customNames.forEach((tagType) -> {
            tagDisplayNames.add(tagType.getDisplayName());
        });
        try {
            TagsManager tagsManager = Case.getOpenCase().getServices().getTagsManager();
            for (TagName tagName : tagsManager.getAllTagNames()) {
                tagDisplayNames.add(tagName.getDisplayName());
            }
        } catch (NoCurrentCaseException ignored) {
            /*
             * No current case, nothing more to add to the set.
             */
        }
        return tagDisplayNames;
    }

    public static List<String> getNotableTagDisplayNames() {
        List<String> tagDisplayNames = new ArrayList<>();
        for (TagNameDefinition tagDef : TagNameDefinition.getTagNameDefinitions()) {
            if (tagDef.getKnownStatus() == TskData.FileKnown.BAD) {
                tagDisplayNames.add(tagDef.getDisplayName());
            }
        }
        return tagDisplayNames;
    }

    TagsManager(SleuthkitCase caseDb) {
        this.caseDb = caseDb;
        for (TagNameDefinition tagName : TagNameDefinition.getTagNameDefinitions()) {
            tagName.saveToCase(caseDb);
        }
    }

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

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

    public Map<String, TagName> getDisplayNamesToTagNamesMap() throws TskCoreException {
        Map<String, TagName> tagNames = new HashMap<>();
        Set<TagNameDefinition> customTypes = TagNameDefinition.getTagNameDefinitions();
        for (TagNameDefinition 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, TskData.FileKnown.UNKNOWN);
    }

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

    public synchronized TagName addTagName(String displayName, String description, TagName.HTML_COLOR color) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, description, color, TskData.FileKnown.UNKNOWN);
    }

    public synchronized TagName addTagName(String displayName, String description, TagName.HTML_COLOR color, TskData.FileKnown knownStatus) throws TagNameAlreadyExistsException, TskCoreException {
        try {
            TagName tagName = caseDb.addOrUpdateTagName(displayName, description, color, knownStatus);
            Set<TagNameDefinition> customTypes = TagNameDefinition.getTagNameDefinitions();
            customTypes.add(new TagNameDefinition(displayName, description, color, knownStatus));
            TagNameDefinition.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.getOpenCase().notifyContentTagAdded(tag);
        } catch (NoCurrentCaseException 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.getOpenCase().notifyContentTagDeleted(tag);
        } catch (NoCurrentCaseException ex) {
            throw new TskCoreException("Deleted a tag from a closed case", ex);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    public static class TagNameAlreadyExistsException extends Exception {

        private static final long serialVersionUID = 1L;
    }

    @Deprecated
    public 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;
        }
    }

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

}