If you can't find the product or version you're looking for, visit support.ataccama.com/downloads

Traits

You can use traits to further configure entities and their properties in ONE, namely to change their appearance or introduce additional functionality.

For example, the term entity has the following traits assigned:

fe:mmdEntity: Lets you change the default icon or set the display name for the entity in singular and plural form.
core:copyable: Makes the Duplicate button available on instances of this entity. This lets you easily create copies of a particular asset.
relationships:enabled: Makes the relationship graph available for this entity.

There are two types of traits used in the application:

Traits on properties.
Traits on entities.

Common use cases

See the following examples of common use cases for traits.

Change the display name and icon of an entity

When you create a custom entity, by default, the display name of the entity is derived from a transformation of the entity name. For example:

'certificationExample' would display as 'Certification example'.
'kpi' becomes 'Kpi'.

The custom entity is also assigned a default icon that is displayed in the navigation bar and in the relationship graph.

You could edit the navigation item of the entity in Global Settings > Navigation to configure the name and icon that are displayed in the navigation. However, this does not work globally.

To specify the icon and the display name in singular and plural forms globally, you can use the fe:mmdEntity trait.

For example, if you assign the fe:mmdEntity trait to the keyPerformanceIndicator and configure its properties as follows:

{
    "iconName": "book",
    "displayNameSingular": "KPI",
    "displayNamePlural": "KPIs"
}

The keyPerformanceIndicator is displayed with the specified icon and singular and plural names where appropriate.

To see the available icons and their names:

Go to Global Settings > Navigation.
Edit any navigation item.
Scroll through the available icons in the Icon list.

Make sure you specify the iconName in camel case in the properties of fe:mmdEntity. For example, the Presentation document icon would be specified as:

{
    "iconName": "presentationDocument"
}

Change the display name of a property

Display names of properties are automatically derived from the property name. For example:

The property 'businessDefinition' becomes 'Business definition' in the UI.
'cisoApprovedBy' becomes 'Ciso approved by'.

This does not work well for properties that need a more descriptive display name.

To change the display name, assign the fe:mmdProperty and configure the displayName property.

{
    "displayName": "CISO PPA approved by"
}

Enable the Relationships tab

By default, the relationships tab is not available for custom entities. To enable the relationships tab, assign the relationships:enabled trait to your entity.

For information about the relationships tab, see Catalog Items, View related assets section.

Color code terms

When you create a new term type, you can use the fe:term trait to give it a distinct color.

To define the color for a term, assign the fe:term trait and add a color property in the following format:

{
    "color": "#FAA0A0"
}

For example, a term type without the fe:term assigned appears in the application like so:

After you assign the fe:term trait and add a color property, the term displays with the assigned color:

Change how arrays of properties are displayed

The valueList:property trait lets you change how lists of properties are displayed. If you assign this trait to an array of properties, the properties are displayed as tags instead of a list. This display logic can be seen on the terms entity.

Traits reference

See the following tables for a list of property and entity traits available in ONE.

Property traits

Trait name Trait properties Description

fe:mmdProperty

{
    "displayName": "My property"
}

Assign this trait to change the display name of a property.

fe:createByDefault

If you add this trait to a parent entity, a single embedded entity (SEE) is automatically created when the parent entity is created.

Adding this trait to a single embedded entity is required if you want to include scalar default values for it.

valueList:property

This trait changes the way arrays of properties are displayed in the application. With this trait, they are displayed as properties instead of list of entities (for example, terms).

To use this trait with an embedded object array property, it is required to add a referenced object property named target to the entity you are embedding. The target property must reference the parent entity.

core:classification

{
    "type": "<some_type>",
    "level": <some_level>
}

If this trait is used, the policy is enforced on the target entity. This means that whenever requested entities are marked as classified the policy enforcement is involved. Otherwise, policies are not enforced.

Assigning this trait to a property does not mean that some policy is applied or data is masked.

It only means that policies are involved in querying the data. If no policy is evaluated then there is no data masking.

core:dataMasking

If some policy is evaluated as true for the requested data (policy is applied) then the data which is requested is being masked.

This trait should be only be applied to simple properties (of type integer, string, etc.). It is not supported on objects, references, and other complex types.

Assigning this property to those objects causes the value to be "erased" in the API response.

core:propertyPublicApiCapability

{
    "editable": true,
    "comparable": true
}

This trait configures capabilities in the API (GraphQL). For example, if the property can be accessed directly (without the parent), it is possible to publish or update it using the API.

To disable the property, set the node to false.

core:propertyStewardship

To enable stewardship for your custom entities, you can add the core:hasStewardship trait along with a Referenced object property that references the group entity and has the core:propertyStewardship property trait assigned.

If the property that references the group entity is named 'stewardship', adding this property trait is not required.

For step-by-step instructions, see Stewardship, section Enable stewardship for a csustom entity.

core:cascade

{
    "deleteStrategy": "FIX_HCN"
}

When a user wants to delete an entity that has references, different deleting strategies can be used:

fail - The validation results in an error if the user is trying to delete the entity that has references.
fix_hcn - Sets the reference to the last published History Change Number (HCN).
set_null - Removes the reference by setting it to null.
delete - Cascade deletes the entities.
always_hcn - The customer makes sure that all references have a fixed HCN. Otherwise, the validation fails.

For always_hcn to work without an error, it is required to have the plugin which creates versions of a change at the moment. For example, if the profiling configuration changes, the job still refers to the old version.

always_hcnis not used in the MMD, only in plugins and within Metadata Management Module (MMM).
HCN represents different versions and is assigned to every published change in MMM. An HCN is a numeric encoding of the time when the version was created.

core:uncopyable

If you assign this trait to a property, the configuration of the property does not get copied when you duplicate an entity with this property.

core:reference

{
    "versionStrategy": "FIX_HCN",
    "nodePaths": "/monitoringProjects/configuration/items/dqChecks/target"
}

This trait is used to determine the strategy used by the front end when setting the History Change Number (HCN) to referenced entities. You can either always reference the latest version of entity (by omitting the trait or with versionStrategy = DEFAULT) or lock the fixed HCN (latest at the time of reference creation by specifying versionStrategy = FIX_HCN).

You also need to specify nodePaths to specify which entities should be affected by this strategy.

This trait should be configured not only for the parent entity but also all child entities that contain references. For example, for dqCheck in monitoring projects, it should be set on ruleInstance, dqCheckMapping, and target since these entities also reference other entities.\

Entity traits

Trait name Trait properties Description

core:hasNoWorkflow

If this trait is applied, the changes can be published without the approval process.

workflows:ableToStartRequestDataAccess

Users can request access level changes to this entity’s data if this trait is applied to an entity.

fe:mmdEntity

{
    "iconName": "dashboard",
    "displayNameSingular": "property",
    "displayNamePlural": "properties",
    "viewOnly": "<boolean>"
}

In the properties of this trait, you can specify which forms are used for button names in singular and plural form as well as set the icon name.

The following rules apply:

If there is no displayName: singular = entityName, plural = entityName + 's'.
If only singular specified: singular = as specified, plural = singular + 's'.
If only plural specified: singular = entityName, plural = as specified.
If both specified: specified values.

If you set the viewOnly property to true, you disable editing features on the front end for that entity. The current use case is to disable editing of entities that are managed from ONE Desktop.

audit:auditEnabled

If audit is enabled, the entity is audited if this trait is assigned.

fe:term

{
    "color": "#1458E9"
}

Assign this trait to define the color of a term type in the trait’s properties. Applies only to term subtypes.

core:displayName

{
    "propertyName": "username"
}

This trait allows to choose the primary property to be displayed in limited situations (lists, labels). If not provided, properties displayName or name are used instead.

core:nodePublicApiCapability

{
    "standaloneAccessible": true,
    "publishable": true,
    "standaloneEditable": true,
    "editable": true,
    "hasHistory": true,
    "standaloneComparable": true,
    "comparable": true,
    "pageable": true,
    "hasStandalonePermissions": true,
    "hasPermissions": true,
    "hasValidations": true
}

This trait configures capabilities in the API (GraphQL). For example, if an entity can be accessed directly (without the parent), it is possible to publish or update it using the API.

Internally, it is combined with persistence trait that configures the database persistence, which means that, for example, if an entity is not accessible without a parent (simply stored), it switches on the standaloneAccessible flag:

{
    "standaloneAccessible": true
}

To disable accessing the entity, set the node to false.

core:boundary

Defines the boundaries of a subtree, that is, one united entity, which then looks like one entity for some kinds of operations (for example, history calculation or approval request generation).

Rule entity example

{
  "implementation": {
    "dqDimension": {
      "results": {}
    },
    "componentInstance": {
      "target": {
        "inputs": {},
        "outputs": {}
      },
      "inputMappings": {
        "source": {},
        "target": {}
      },
      "outputMappings": {
        "source": {},
        "target": {}
      }
    },
    "expression": {
      "references": {}
    },
    "fallback": {
      "result": {}
    },
    "conditions": {
      "result": {},
      "expression": {
        "references": {}
      }
    },
    "steps": {
      "outputsMappings": {}
    }
  },
  "inputGroups": {
    "inputs": {
      "termInstances": {
        "target": {}
      }
    }
  },
  "outputs": {},
  "termInstances": {
    "target": {}
  }
}

core:copyable

This trait configures the capability of entities to duplicate the content of properties (the button Duplicate is available).

For example, if the trait is set to copyable for rules, it is possible to duplicate the content of the rule properties (but not the relationships) in a new rule.

relationships:relationshipNode

{
    "sourceProperty": "source", // name of the property referencing first relationship entity
    "targetProperty": "target", // name of the property referencing first relationship entity
    "relationshipTypeProperty": "type" // name of the property describing the type of relationship
}

This trait enables the relationships visualization configuration for the chains of three entities.

For example, in a relationship chain A < B > C, entity B is referencing entities A and C.

If you want to display a direct relationship between A and C, the current trait should be present and configured on entity B, where source is A and target is C.

This works if the entity B is present in the list of Relationship nodes in graph visualization configuration. For more information about how to add the entity to the list of Relationship nodes in graph visualization, see visualizing-relationships-on-the-graph.adoc.

relationships:enabled

This trait enables entity visualization on the relationship graph.

To see the entity on the Relationship graph, the Graph Visualization settings need to be adjusted or created for this entity accordingly. For more information, see configuring-graph-visualization.adoc.

relationships:skipped

{
    "configurations": [
      {
          "sourceNodeEntityType": "catalogItem",
          "sourceProperty": "termInstances",
          "targetNodeEntityType": "term",
          "targetProperty": "target",
          "labelValue": "Assigned term"
      }
    ]
}

This trait hides the entity from the relationships chain in the Relationships graph.

When the A, B, and C entities are displayed on the graph with the relationship chain A → B → C, it is possible to skip showing the B entity while keeping the relationship chain of A → C.

To hide the B property, configurations are used, in which the following applies:

"sourceNodeEntityType" is an "A" node type.
"sourceProperty" is an "A" node property, referencing "B" node.
"targetNodeEntityType" is a "C" node type.
"targetProperty" is a "B" node property, referencing "C" node.
"labelValue" is the label of relationship that will be displayed in the graph.

One node can have multiple skip configurations, depending on the relationship chains it appears in. In this case, the "configuration" array will have multiple elements.

task:ableToCreateTask

This trait allows users to create the task for the Task Manager. The tasks for the entities with this trait can be created directly from the entity Overview screen and from the Task Manager itself.

comments:commentable

{
    "includeSubnodes": true
}

This trait enables comments on an entity. The trait property includeSubnodes allows you to select whether you see all comments associated with that entity and any child entities, or just the selected entity, when viewing an entity with comments enabled.

Assign traits

After a property or an entity is added, click its name to see the details.

Go to Global Settings > Metadata Model.
Find and select the entity that you want to edit.
In Traits, select Add mmd trait and set the Trait name and properties as needed. You can find the necessary information earlier in this article (see Property traits and Entity traits).
Select Save.
Go to System Changes and publish the changes. This includes switching to the maintenance mode, creating a database backup, and resolving any potential conflicts.

For more information and step-by-step instructions, see System Changes, section Run and publish changes.

Edit and remove traits

To edit or remove an existing trait:

In the three dots menu, select Edit or Delete as required.
(Optional) If you are editing a trait, specify the changes in Trait properties and then select Save.

Some traits in the default configuration cannot be deleted.
Go to System Changes and publish the changes. This includes switching to the maintenance mode, creating a database backup, and resolving any potential conflicts.

For more information and step-by-step instructions, see System Changes, section Run and publish changes.

Was this page useful?