TskEvent.java

Go to the documentation of this file.

/*
 * Sleuth Kit Data Model
 *
 * Copyright 2020-2021 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.datamodel;
 
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;

public interface TskEvent {

        default Optional<Long> getDataSourceId() {
                return Optional.ofNullable(null);
        }

        abstract static class TskObjectsEvent<T> implements TskEvent {
 
                private final List<T> dataModelObjects;

                TskObjectsEvent(List<T> dataModelObjects) {
                        this.dataModelObjects = new ArrayList<>();
                        this.dataModelObjects.addAll(dataModelObjects);
                }

                List<T> getDataModelObjects() {
                        return Collections.unmodifiableList(dataModelObjects);
                }
 
        }

        public final static class AggregateScoresChangedEvent extends TskObjectsEvent<ScoreChange> {
 
                private final Long dataSourceObjectId;

                AggregateScoresChangedEvent(Long dataSourceObjectId, ImmutableSet<ScoreChange> scoreChanges) {
                        super(scoreChanges.asList());
                        this.dataSourceObjectId = dataSourceObjectId;
                        scoreChanges.stream().forEach(chg -> {
                                if (!chg.getDataSourceObjectId().equals(dataSourceObjectId)) {
                                        throw new IllegalArgumentException("All data source object IDs in List<ScoreChange> must match dataSourceObjectId");
                                }
                        });
                }
 
                @Override
                public Optional<Long> getDataSourceId() {
                        return Optional.ofNullable(dataSourceObjectId);
                }

                public List<ScoreChange> getScoreChanges() {
                        return getDataModelObjects();
                }
 
        }

        public final static class AnalysisResultsDeletedTskEvent extends TskObjectsEvent<Long> {

                AnalysisResultsDeletedTskEvent(List<Long> deletedResultObjIds) {
                        super(deletedResultObjIds);
                }

                public List<Long> getAnalysisResultObjectIds() {
                        return getDataModelObjects();
                }
 
        }

        abstract static class HostsTskEvent extends TskObjectsEvent<Host> {

                HostsTskEvent(List<Host> hosts) {
                        super(hosts);
                }

                public List<Host> getHosts() {
                        return getDataModelObjects();
                }
 
        }

        public final static class HostsAddedTskEvent extends HostsTskEvent {

                HostsAddedTskEvent(List<Host> hosts) {
                        super(hosts);
                }
 
        }

        public final static class HostsUpdatedTskEvent extends HostsTskEvent {

                HostsUpdatedTskEvent(List<Host> hosts) {
                        super(hosts);
                }
 
        }

        public final static class HostsDeletedTskEvent extends TskObjectsEvent<Long> {

                HostsDeletedTskEvent(List<Long> hostIds) {
                        super(hostIds);
                }

                public List<Long> getHostIds() {
                        return getDataModelObjects();
                }
 
        }

        abstract static class OsAccountsTskEvent extends TskObjectsEvent<OsAccount> {

                OsAccountsTskEvent(List<OsAccount> osAccounts) {
                        super(osAccounts);
                }

                public List<OsAccount> getOsAcounts() {
                        return getDataModelObjects();
                }
 
        }

        public final static class OsAccountsAddedTskEvent extends OsAccountsTskEvent {

                OsAccountsAddedTskEvent(List<OsAccount> osAccounts) {
                        super(osAccounts);
                }
 
        }

        public final static class OsAccountsUpdatedTskEvent extends OsAccountsTskEvent {

                OsAccountsUpdatedTskEvent(List<OsAccount> osAccounts) {
                        super(osAccounts);
                }
 
        }

        public final static class OsAccountsDeletedTskEvent extends TskObjectsEvent<Long> {

                OsAccountsDeletedTskEvent(List<Long> accountObjectIds) {
                        super(accountObjectIds);
                }

                public List<Long> getOsAccountObjectIds() {
                        return getDataModelObjects();
                }
 
        }

        public final static class OsAccountsMergedTskEvent extends TskObjectsEvent<MergedAccountsPair> {

                OsAccountsMergedTskEvent(List<MergedAccountsPair> mergedAccounts) {
                        super(mergedAccounts);
                }
 

                public List<MergedAccountsPair> getMergedAccountPairs() {
                        return getDataModelObjects();
                }
 
        }

        public final static class MergedAccountsPair {
 
                private final Long sourceOsAccountId;
                private final Long destinationOsAccountId;
 
                public MergedAccountsPair(Long sourceOsAccountId, Long destinationOsAccountId) {
                        this.sourceOsAccountId = sourceOsAccountId;
                        this.destinationOsAccountId = destinationOsAccountId;
                }

                public Long getSourceOsAccountId() {
                        return sourceOsAccountId;
                }

                public Long getDestinationOsAccountId() {
                        return destinationOsAccountId;
                }
        }
        
        public final static class OsAcctInstancesAddedTskEvent extends TskObjectsEvent<OsAccountInstance> {

                OsAcctInstancesAddedTskEvent(List<OsAccountInstance> osAcctInstances) {
                        super(osAcctInstances);
                }

                public List<OsAccountInstance> getOsAccountInstances() {
                        return getDataModelObjects();
                }
 
        }

        static abstract class PersonsTskEvent extends TskObjectsEvent<Person> {

                PersonsTskEvent(List<Person> persons) {
                        super(persons);
                }

                public List<Person> getPersons() {
                        return getDataModelObjects();
                }
 
        }

        public final static class PersonsAddedTskEvent extends PersonsTskEvent {

                PersonsAddedTskEvent(List<Person> persons) {
                        super(persons);
                }
 
        }

        public final static class PersonsUpdatedTskEvent extends PersonsTskEvent {

                PersonsUpdatedTskEvent(List<Person> persons) {
                        super(persons);
                }
 
        }

        public final static class PersonsDeletedTskEvent extends TskObjectsEvent<Long> {

                PersonsDeletedTskEvent(List<Long> personObjectIDs) {
                        super(personObjectIDs);
                }

                public List<Long> getPersonIds() {
                        return getDataModelObjects();
                }
 
        }

        public final static class HostsAddedToPersonTskEvent extends TskObjectsEvent<Host> {
 
                private final Person person;

                HostsAddedToPersonTskEvent(Person person, List<Host> hosts) {
                        super(hosts);
                        this.person = person;
                }

                public Person getPerson() {
                        return person;
                }

                public List<Host> getHosts() {
                        return getDataModelObjects();
                }
 
        }

        public final static class HostsRemovedFromPersonTskEvent extends TskObjectsEvent<Long> {
 
                private final Person person;

                HostsRemovedFromPersonTskEvent(Person person, List<Long> hostIds) {
                        super(hostIds);
                        this.person = person;
                }

                public Person getPerson() {
                        return person;
                }

                public List<Long> getHostIds() {
                        return getDataModelObjects();
                }
 
        }
 
        static abstract class TagNamesTskEvent extends TskObjectsEvent<TagName> {
 
                public TagNamesTskEvent(List<TagName> tagNames) {
                        super(tagNames);
                }

                public List<TagName> getTagNames() {
                        return getDataModelObjects();
                }
 
        }

        public final static class TagNamesAddedTskEvent extends TagNamesTskEvent {

                public TagNamesAddedTskEvent(List<TagName> tagNames) {
                        super(tagNames);
                }
        }

        public final static class TagNamesUpdatedTskEvent extends TagNamesTskEvent {

                public TagNamesUpdatedTskEvent(List<TagName> tagNames) {
                        super(tagNames);
                }
        }

        public final static class TagNamesDeletedTskEvent extends TskObjectsEvent<Long> {

                public TagNamesDeletedTskEvent(List<Long> tagNameIds) {
                        super(tagNameIds);
                }

                public List<Long> getTagNameIds() {
                        return getDataModelObjects();
                }
 
        }

        public final static class TagSetsAddedTskEvent extends TskObjectsEvent<TagSet> {

                public TagSetsAddedTskEvent(List<TagSet> tagSets) {
                        super(tagSets);
                }

                public List<TagSet> getTagSets() {
                        return getDataModelObjects();
                }
        }

        public final static class TagSetsDeletedTskEvent extends TskObjectsEvent<Long> {

                public TagSetsDeletedTskEvent(List<Long> tagSetIds) {
                        super(tagSetIds);
                }

                public List<Long> getTagSetIds() {
                        return getDataModelObjects();
                }
        }
}