core/gropius.model.architecture

gropius.model.architecture

Types

@DomainNode(searchQueryName = "searchAffectedByIssues")

@AdditionalFilter(beanName = "relatedToFilter")

abstract class AffectedByIssue : BaseNode

Entities that can be affected by an Issue, meaning that this entity is in some regard impacted by e.g. a bug described by an issue, or the non-present of a feature described by an issue.

Component

@DomainNode(topLevelQueryName = "components", searchQueryName = "searchComponents")

@Authorization(name = "READ", allowFromRelated = ["versions"])

@Authorization(name = "RELATE_FROM_COMPONENT", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "ADD_TO_PROJECTS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

class Component(name: String, description: String, repositoryURL: URI?, val templatedFields: MutableMap<String, String>) : Trackable, MutableTemplatedNode, NodeWithPermissions<ComponentPermission>

Entity which represents a software component, e.g. a library, a microservice, or a deployment platform, .... The type of software component is defined by the template. Can have issues, labels and artefacts as this is a Trackable. Defines InterfaceSpecifications, but visible/invisible InterfaceSpecificationVersions depend on the ComponentVersion. Can be affected by Issues. READ is granted via an associated ComponentPermission or if READ is granted on any Project including any ComponentVersion in `versions` of this Component.

ComponentVersion

@DomainNode(searchQueryName = "searchComponentVersions")

@Authorization(name = "READ", allowFromRelated = ["component", "includingProjects"])

@Authorization(name = "ADMIN", allowFromRelated = ["component"])

@Authorization(name = "RELATE_FROM_COMPONENT", allowFromRelated = ["component"])

@Authorization(name = "ADD_TO_PROJECTS", allowFromRelated = ["component"])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allowFromRelated = ["component"])

@Authorization(name = "RELATED_ISSUE_AFFECTED_ENTITY", allowFromRelated = ["component"])

@Authorization(name = "PART_OF_PROJECT", allowFromRelated = ["includingProjects"])

class ComponentVersion(var version: String, var tags: List<String>, val templatedFields: MutableMap<String, String>) : RelationPartner, Versioned, MutableTemplatedNode

Version of a component. Can specifies visible/invisible InterfaceSpecifications. Can be used in Relations, affected by issues and included by Projects. READ is granted if READ is granted on `component`.

IMS

@DomainNode(topLevelQueryName = "imss", searchQueryName = "searchIMSs")

@Authorization(name = "READ", allow = [Rule(beanRef = "relatedToNodePermissionRule")])

@Authorization(name = "ADMIN", allow = [Rule(beanRef = "relatedToNodePermissionRule")])

@Authorization(name = "SYNC_TRACKABLES", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

class IMS(name: String, description: String, val templatedFields: MutableMap<String, String>) : SyncPermissionTarget, MutableTemplatedNode, NodeWithPermissions<IMSPermission>

Entity which represents an issue management system (like GitHub, Jira, Redmine, ...). Trackables can be added to this via an IMSProject, so that their issues are synced to this IMS. READ is granted via an associated IMSPermission.

IMSIssue

@DomainNode

@Authorization(name = "READ", allowFromRelated = ["imsProject"])

class IMSIssue(val templatedFields: MutableMap<String, String>) : BaseNode, TemplatedNode

Issue on an IMS, represents an Issue synced to an IMS. The representation of the Issue on the IMS depends on the type of IMS. READ is granted if read is granted on `issue`.

IMSProject

@DomainNode(searchQueryName = "searchIMSProjects")

@Authorization(name = "READ", allow = [Rule(beanRef = "relatedToAdminNodePermission", options = ["2"])], allowFromRelated = ["trackable"])

@Authorization(name = "MANAGE_IMS", allowFromRelated = ["trackable"])

@Authorization(name = "RELATED_TO_NODE_PERMISSION", allowFromRelated = ["ims"])

class IMSProject(name: String, description: String, val templatedFields: MutableMap<String, String>) : SyncPermissionTarget, MutableTemplatedNode

Project on an IMS, represents a Trackable synced to an IMS. The representation on the IMS depends on the type of IMS, e.g. for GitHub, a project is a repository. READ is granted if READ is granted on `trackable` or `ims`.

Interface

@DomainNode

@Authorization(name = "READ", allowFromRelated = ["interfaceDefinition"])

@Authorization(name = "ADMIN", allowFromRelated = ["interfaceDefinition"])

@Authorization(name = "RELATE_FROM_COMPONENT", allowFromRelated = ["interfaceDefinition"])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allowFromRelated = ["interfaceDefinition"])

@Authorization(name = "RELATED_ISSUE_AFFECTED_ENTITY", allowFromRelated = ["interfaceDefinition"])

@Authorization(name = "PART_OF_PROJECT", allowFromRelated = ["interfaceDefinition"])

class Interface : RelationPartner

An interface which is part of a specific ComponentVersion. Its semantics depend on the InterfaceSpecification it is specified by, e.g. an Interface can represent a REST API. Can be used in Relations and affected by Issues. READ is granted if READ is granted on `interfaceDefinition`.

InterfaceDefinition

@DomainNode

@Authorization(name = "READ", allowFromRelated = ["componentVersion"])

@Authorization(name = "ADMIN", allowFromRelated = ["componentVersion"])

@Authorization(name = "RELATE_FROM_COMPONENT", allowFromRelated = ["componentVersion"])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allowFromRelated = ["componentVersion"])

@Authorization(name = "RELATED_ISSUE_AFFECTED_ENTITY", allowFromRelated = ["componentVersion"])

@Authorization(name = "PART_OF_PROJECT", allowFromRelated = ["componentVersion"])

class InterfaceDefinition(var visibleSelfDefined: Boolean, var invisibleSelfDefined: Boolean) : BaseNode

InterfaceDefinition on a ComponentVersion Specifies if it is visible/invisible self-defined. Specifies if it is visible/invisible derived (and by which Relations) READ is granted if READ is granted on `componentVersion`

InterfacePart

@DomainNode

@Authorization(name = "READ", allowFromRelated = ["partOf"])

@Authorization(name = "ADMIN", allowFromRelated = ["partOf"])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allowFromRelated = ["partOf"])

@Authorization(name = "RELATED_ISSUE_AFFECTED_ENTITY", allowFromRelated = ["partOf"])

class InterfacePart(name: String, description: String, val templatedFields: MutableMap<String, String>) : NamedAffectedByIssue, MutableTemplatedNode

Part of an Interface(Specification). Its semantics depend on the InterfaceSpecification, e.g. for a REST API interface, this could represent a single endpoint of the API. Relations can specify for both start and end included InterfaceParts. Can be affected by Issues, and be used as start / end of ServiceEffectSpecifications. READ is granted if READ is granted on `definedOn`.

InterfaceSpecification

@DomainNode(searchQueryName = "searchInterfaceSpecifications")

@Authorization(name = "READ", allowFromRelated = ["component", "versions"])

@Authorization(name = "ADMIN", allowFromRelated = ["component"])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allowFromRelated = ["component"])

@Authorization(name = "RELATED_ISSUE_AFFECTED_ENTITY", allowFromRelated = ["versions", "component"])

class InterfaceSpecification(name: String, description: String, val templatedFields: MutableMap<String, String>) : NamedAffectedByIssue, MutableTemplatedNode

Specification of an Interface. Defined on a Component, but can be visible and invisible on different ComponentVersions. Can be affected by Issues, and be used as start / end of ServiceEffectSpecifications. Defines InterfaceParts, but active parts depend on the InterfaceSpecificationVersion. READ is granted if READ is granted on `component`, or any InterfaceSpecificationVersion in `versions`.

InterfaceSpecificationVersion

@DomainNode(searchQueryName = "searchInterfaceSpecificationVersions")

@Authorization(name = "READ", allowFromRelated = ["interfaceSpecification", "interfaceDefinitions"])

@Authorization(name = "ADMIN", allowFromRelated = ["interfaceSpecification"])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allowFromRelated = ["interfaceSpecification"])

@Authorization(name = "RELATED_ISSUE_AFFECTED_ENTITY", allowFromRelated = ["interfaceDefinitions", "interfaceSpecification"])

class InterfaceSpecificationVersion(var version: String, var tags: List<String>, val templatedFields: MutableMap<String, String>) : AffectedByIssue, Versioned, MutableTemplatedNode

A specific version of an InterfaceSpecification. Defines which InterfaceParts are active. Can be both visible (generates an Interface) and invisible (does not generate an Interface) on different Components. Can be derived by Relations, and affected by Issues. READ is granted if READ is granted on `interfaceSpecification`, or any InterfaceDefinition in `definitions`

IntraComponentDependencyParticipant

@DomainNode

@Authorization(name = "READ", allowFromRelated = ["interface", "usedAsIncomingAt", "usedAsOutgoingAt"])

class IntraComponentDependencyParticipant : BaseNode

Participant of a a IntraComponentDependencySpecification Consists of an Interface it refers to, and optionally a subset of its active InterfaceParts. READ is granted if READ is granted on the associated ComponentVersion

IntraComponentDependencySpecification

@DomainNode

@Authorization(name = "ADMIN", allowFromRelated = ["componentVersion"])

class IntraComponentDependencySpecification(name: String, description: String) : NamedNode

Describes a dependency between Interfaces of a Component. Both ends can optionally affected InterfaceParts. Semantically, any InterfaceSpecification(Version) in `outgoing` depends on any InterfaceSpecification(Version) in `incoming`. This can result in a propagation of Issues, if any location in `in` is in some regard affected by an Issue, all locations in `out` are affected by this Issue, too.

NamedAffectedByIssue

@DomainNode

abstract class NamedAffectedByIssue(var name: String, var description: String) : AffectedByIssue, Named

Affected by issue with a name and description

Project

@DomainNode(topLevelQueryName = "projects", searchQueryName = "searchProjects")

@AggregatedNodeRelationship(name = "componentIssues", description = "The set of Issues which are part of any of the Components of this Project.", property = "components", path = [AggregationEntry(property = "component"), AggregationEntry(property = "issues")])

@Authorization(name = "MANAGE_COMPONENTS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "MANAGE_VIEWS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

class Project(name: String, description: String, repositoryURL: URI?) : Trackable, NodeWithPermissions<ProjectPermission> , Layout

A project of the Gropius system. Consists of a set of ComponentVersions, which form a graph with the Relations between them. Can be affected by issues. Can have issues, labels and artefacts as this is a Trackable. READ is granted via an associated ProjectPermission.

Relation

@DomainNode

@Authorization(name = "READ", allowFromRelated = ["start"])

class Relation(val templatedFields: MutableMap<String, String>) : BaseNode, MutableTemplatedNode

A relation between RelationPartners (ComponentVersions and Interfaces). Relations are always directional. Relations can derive Interfaces from `end` to `start` if both `start` and `end` are ComponentVersions and the template of this Relation allows it. The template defines which RelationPartners are possible as `start` / `end`. For both start and end, if it is an Interface, it is possible to define the InterfaceParts this includes. Caution: This is **not** a supertype of IssueRelation. READ is granted if READ is granted on `start`.

RelationPartner

@DomainNode

@AdditionalFilter(beanName = "partOfProject")

abstract class RelationPartner : AffectedByIssue

Entity which can be used as start / end of Relations. Can be affected by Issues.

SyncPermissionTarget

@ExtensionField(beanName = "syncSelfAllowedFieldBean")

@ExtensionField(beanName = "syncOthersAllowedFieldBean")

abstract class SyncPermissionTarget(name: String, description: String) : NamedNode

A target where users can configure how the sync should behave.

Trackable

@DomainNode(topLevelQueryName = "trackables", searchQueryName = "searchTrackables")

@AggregatedNodeRelationship(name = "assignedUsers", description = "The set of Users assigned to any issue", property = "issues", path = [AggregationEntry(property = "assignments"), AggregationEntry(property = "user")])

@AggregatedNodeRelationship(name = "usedIssueTemplates", description = "The set of IssueTemplates used by any issue", property = "issues", path = [AggregationEntry(property = "template")])

@AggregatedNodeRelationship(name = "usedIssueTypes", description = "The set of IssueTypes used by any issue", property = "issues", path = [AggregationEntry(property = "type")])

@AggregatedNodeRelationship(name = "usedIssueStates", description = "The set of IssueStates used by any issue", property = "issues", path = [AggregationEntry(property = "state")])

@AggregatedNodeRelationship(name = "usedIssuePriorities", description = "The set of IssuePriorities used by any issue", property = "issues", path = [AggregationEntry(property = "priority")])

@AggregatedNodeRelationship(name = "usedLabels", description = "The set of Labels used by any issue (including Labels not on this Trackable)", property = "issues", path = [AggregationEntry(property = "labels")])

@AggregatedNodeRelationship(name = "affectedEntities", description = "The set of entities affected by any Issue", property = "issues", path = [AggregationEntry(property = "affects")])

@Authorization(name = "READ", allow = [Rule(beanRef = "relatedToNodePermissionRule")])

@Authorization(name = "ADMIN", allow = [Rule(beanRef = "relatedToNodePermissionRule")])

@Authorization(name = "MANAGE_IMS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "CREATE_ISSUES", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN", "MANAGE_ISSUES", "MODERATOR"])])

@Authorization(name = "MODERATOR", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "COMMENT", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN", "MANAGE_ISSUES", "MODERATOR"])])

@Authorization(name = "MANAGE_LABELS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "MANAGE_ARTEFACTS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "MANAGE_ISSUES", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "EXPORT_ISSUES", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "EXPORT_LABELS", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

@Authorization(name = "AFFECT_ENTITIES_WITH_ISSUES", allow = [Rule(beanRef = "relatedToNodePermissionRule", options = ["ADMIN"])])

abstract class Trackable(name: String, description: String, var repositoryURL: URI?) : NamedAffectedByIssue

An entity which can have Issues, Labels and Artefacts. Has pinned issues. Can be synced to an IMS by creating an IMSProject. Can be affected by Issues.

Versioned

interface Versioned

Entity with a version