Some RegulatoryOne Registration & Dossier Management features require you to create components for specific component types as part of the configuration process. Component types are the configuration elements of a Vault that extend its functional behavior. Components are instances of component types that contain specific configuration details. Some components store additional data in subcomponents. Components have a parent-child relationship with their subcomponents, meaning that a subcomponent always belongs to a parent component.
You can view, create, and edit some components in your Registration & Dossier Management Vault; however, some components can only be accessed in MDL. See About Vault Components for more details about how to access, create, and alter components in MDL.
Note: The component types described in this article are available only in RegulatoryOne Registration & Dossier Management Vaults.
Component Types
The following component types are available in Registration & Dossier Management Vaults:
| Label | Name | Details | Accessibility |
|---|---|---|---|
| Object Mapping | Objectmapping |
Maps a source object to a target object. | Accessible in Vault and MDL. |
| Field Mapping | Fieldmapping |
This subcomponent of Object Mapping maps a source field to a target field on the objects defined in the associated Object Mapping. | Accessible in Vault and MDL. |
| Relational Token | Relationaltoken |
Identifies how Vault creates or populates object records when supported actions run. | Accessible in Vault and MDL. |
| Relational Token Setting | Relationatokensetting |
Defines the root Relational Token for supported actions. | Only accessible in MDL. |
| Registration Attribute | Registrationattribute |
Defines Registration Item field attributes for Local Impact Assessments and Global Change Impact Assessments. | Only accessible in MDL. |
Defining Object Mappings & Field Mappings
Object Mapping components define a source object and a target object. Field Mappings are subcomponents of Object Mappings that map fields between the source and target objects defined in the associated Object Mapping. You must first create an Object Mapping, then add Field Mapping subcomponents to that Object Mapping. You can link Object Mappings to Relational Tokens so that Vault automatically populates mapped fields based on token resolution.
You can access, create, and alter Object Mappings and Field Mappings in your Registration & Dossier Management Vault and in MDL. See Defining Object Mappings & Field Mappings for more details about how to create Object Mappings with Field Mappings in your Vault.
Defining Relational Tokens
Relational Token components leverage hierarchical relationships between objects so that users can automatically generate and populate records based on token resolution when supported actions run. If you link a Relational Token to Object Mappings, Vault will populate mapped fields on certain records based on token resolution. When you create recursive Relational Tokens, Vault applies the token to all generated records created as the token resolves through the hierarchy for the specified object until Vault can create no more additional records. You can also specify if Vault applies any VQL Criteria on the Relational Token as new records are created or after recursive record creation.
You can access, create, and alter Relational Tokens in your Registration & Dossier Management Vault and in MDL. See Defining Relational Tokens for more details about how to create Relational Tokens in your Vault.
Note: After creating the necessary Relational Tokens, you must link each supported action to a root token. If you do not do this, the action will fail when run by users. We suggest using the recommended Relational Tokens as root tokens.
Recommended Relational Token Components
We recommend using the following Relational Token components (a parent and a child) to use as root tokens linked to supported actions, which you can also use for other purposes as needed. You may need to create these components if they are not already in your Vault:
| Attribute | Parent Token | Child Token |
|---|---|---|
| Name | registration_objective__c |
registration_item__c |
| Label | registration_objective | registration_item |
| Object | Registration | Registration Item |
| Field Label | Field.name__v |
Field.name__v |
| VQL Criteria | null | null |
| Parent Token | null | registration_objective__c |
| Parent Token Reference Field Type | None | Self |
| Parent Token Object | Registration | Registration Item |
| Parent Token Child Field | null | null |
| Parent Token Reference Field | Field.id |
Field.registration__v |
| Recursion Type | null | null |
Defining Relational Token Settings
The Relational Token Setting component type defines settings for object actions that support Relational Tokens. You must link each supported action to the appropriate root token to specify which root token each action references when resolving Relational Tokens. This allows you to define Relational Tokens that indirectly reference objects.
You must use MDL to access, create, and alter Relational Token Settings.
Relational Token Setting Component Attributes
Relational Token Setting components include the following attributes:
| Attribute | Name | Field Type | Description |
|---|---|---|---|
| Name | Name |
String (Maximum length 128) | API Name. |
| Label | label |
String (Maximum length 60) | UI-friendly string. |
| Active | active |
Boolean | Indicates if the component is active. |
| Root Token | root_token |
Relationaltoken |
The root Relational Token for the specified Action. |
| Associated Object Type RIR | associated_object_type_rir |
Objecttype |
The object type Vault assigns to Requirement records generated by the specified Action. This attribute only applies to the GENERATE_REQUIREMENT and GENERATE_REQUIREMENT_FOR_RO actions and must be populated with unique values on the Relational Token Setting components for those actions. Once saved, this value cannot be altered. |
| Action | action |
Enum | The supported action to which this setting applies:
|
Linking Actions to Root Tokens
You must create Relational Token Settings and set the appropriate Action (action) and Root Token (root_token) attributes for the following supported actions:
- Generate Registration Data (
GENERATE_REGISTRATION_DATA): The Generate Registration Data action on the Registration Item object. The Root Token (such asregistration_item__c) must reference the Registration Item object. - Generate Requirements for Registration Item (
GENERATE_REQUIREMENT): The Generate Requirements and Update Requirements actions on the Registration Item object. The Root Token (such asregistration_item__c) must reference the Registration Item object. - Generate Requirements for Registration Objective (
GENERATE_REQUIREMENT_FOR_RO): The Generate Requirements and Update Requirements actions on the Registration object. The Root Token (such asregistration_objective__c) must reference the Registration object. - Split Registration Item (
SPLIT_REGISTRATION): The Split Registration Item action on the Registration Item object. The Root Token (such asregistration_item__c) must reference the Registration Item object.
Any objects referenced in Relational Tokens must be directly or indirectly related to the object defined by the root Relational Token for the supported action in order for the Relational Token to resolve when that action runs. For example, when the Generate Requirements action runs on a Registration Item record and a related Requirement Library uses the packaging__c Relational Token in the Name field, the packaging__c Relational Token must be a direct or indirect child of the registration_item__c Relational Token.
Note: If you do not link a supported action to a root token, that action will fail when run by users. We suggest using the recommended Relational Token Settings to link supported actions to root tokens.
Recommended Relational Token Setting Components
If you are using the recommended Relational Tokens (registration_objective__c and registration_item__c), we recommend also using the following Relational Token Setting components to link supported actions to root tokens, which you can also use for other purposes as needed. You may need to create these components if they are not already in your Vault:
| Attribute | Generate Registration Data | Generate Requirements for Registration Item | Generate Requirements for Registration Objective | Split Registration Item |
|---|---|---|---|---|
| Name | generate_registration_data__c |
generate_requirement__c |
generate_requirement_for_ro__c |
split_registration__c |
| Label | generate_registration_data |
generate_requirement |
generate_requirement_for_ro |
split_registration |
| Root Token | registration_item__c |
registration_item__c |
registration_objective__c |
registration_item__c |
| Associated Object Type RIR | null | The name of an active Requirement object type. | The name of an active Requirement object type. | null |
| Action | GENERATE_REGISTRATION_DATA |
GENERATE_REQUIREMENT |
GENERATE_REQUIREMENT_FOR_RO |
SPLIT_REGISTRATION |
Important: Relational Token Setting components for the GENERATE_REQUIREMENT and GENERATE_REQUIREMENT_FOR_RO actions must reference different Requirement object types for the Associated Object Type RIR (associated_object_type_rir) attributes. After you save an Associated Object Type RIR value, you cannot alter it.
Defining Registration Attributes
The Registration Attribute component type defines Registration Item field attributes and maps them to object fields. You must define relevant Registration Attributes in order for the following actions to run successfully:
- Local Impact Assessment: Identifies Registration and Registration Objective matches based on the Regulated Category Attribute Impacts you link to each component.
- Generate Registration Data: Populates specified fields on a source Registration Item record based on the Object Mapping linked to the Relational Token you specify for a component.
- Run Global Impact Assessment: Identifies Registration Items potentially impacted by a global operational change based on the pre-defined Global Operational Change fields you specify for each component.
You can create only one (1) Registration Attribute component for each Registration Item field.
Registration Attribute Component Attributes
Registration Attribute components include the following attributes:
| Attribute | Name | Field Type | Description |
|---|---|---|---|
| Name | Name |
String (Maximum length 128) | API Name. |
| Label | label |
String (Maximum length 60) | UI-friendly string. |
| Active | active |
Boolean | Indicates if the component is active. |
| Object | object |
object |
References the Registration Item object. This value must always be Object.request__v. |
| Field | field |
object.field |
The name of the Registration Item field used as an attribute, such as Field.made_in__c. This attribute only supports certain field types. If you enter a lookup field, you must leave the Relational Token (relational_token) attribute blank. |
| Global Operational Change Object | global_operational_change_object |
object |
References the Global Operational Change object. This value must always be Object.global_operational_change__v. This attribute is only referenced when users run the Run Global Impact Assessment action.
If you are not configuring Global Change Impact Assessments, leave this attribute blank. |
| Global Operational Change Field | global_operational_change_field |
object.field |
The name of an active custom Global Operational Change object field, such as Field.made_in__c. This attribute only supports certain field types and must be the same type as the Registration Item field you enter as the Field (field) attribute of the component. This attribute is only referenced when users run the Run Global Impact Assessment action.
If you are not configuring Global Change Impact Assessments, leave this attribute blank. |
| Relational Token | relational_token |
object.field |
The name of an active Relational Token. This attribute is optional. If you populate this attribute, ensure that the Request Object Mapping field on the Relational Token is populated with a valid Object Mapping. The Object Mapping determines how Vault populates the specified field on a Registration Item based on token resolution. Vault applies the Relational Token depending on which supported action a user runs:
|
Supported Field Types
Vault supports only certain types of object fields for Registration Attributes component attributes.
Vault supports the following types of object fields for the Field (field) attribute:
- Date
- Number
- Object (excluding references to the Document and User objects)
- Picklist (single value)
- Text (including long text and rich text)
- Lookup (so long as the type is a supported type listed above)
Global Operational Change Field Attribute
Vault supports the following types of object fields for the Global Operational Change Field (global_operational_change_field) attribute:
- Number
- Object (excluding references to parent objects and the User object)
- Picklist (single value)
- Text (including long text and rich text)
If you include a Global Operational Change Field attribute in a component, it must be the same type as the Field attribute you added to the component.