A relationship is a link between a registry role on Registry Data (e.g. an Entity or Professional) and a user or an organisation profile. This enables Verne to grant permissions (authorise) a logged on user (or organisation) to maintain that Registry Data according to the level of entitlement the corresponding registry role has. Relationship Management is part of the User Management Product.
e.g. A Director on a Company typically has the authority to maintain that company’s details. The relationship between a Director (registry role) and a User (in the security register) allows Verne to grant set of permissions to that user in the context of that Company.
Relationships are derived, via relationship instructions, from the registry roles on an entity, e.g. owner/director/shareholder etc and do not need to be configured in the normal way. Relationships can, however, be configured in the normal way to accommodate more complicated (or non standard) business requirements.
Should a relationship be configured outside of the relationship instructions, the DerivedYn attribute on that relationship should be set to false. This ensures that any relationshiop instructions will not modify them and they should be maintained completely outside of any instructions.
Relationships are stored in the domain tree, so they are carried forward with each version of the entity.
Relationship Structure
The structure of a Relationship Domain is as follows:
| Domain Property | Value | Description |
|---|---|---|
| Name | Relationship | The name of the domain in the Domain Tree |
| ArrayName | relationships | The name of the array that holds all the Relationships |
| StartDate | (Date) | The date that this relationship came into effect |
| EndDate | (Date) | The date that this relationship ended |
| DerivedYn | (YesNo) | If this is a Derived relationship or not |
| PermissionPool | (String) | The name of the Permission Pool that this relationship will use to provide authority |
| RelationshipName | (String) | The name of the Relationship |
| AssociatedRoleDomainId | (String) | The id of the domain (registry role) that this relationship is for – maybe null |
| AssociatedRoleDomainName | (String) | The name of the domain (registry role) that this relationship is for – maybe null |
| UserIdentifier | (String) | The identifier for the User that this relationship is for – maybe null |
| OrganisationIdentifier | (String) | The identifier for the Organisation that this relationship is for – maybe null |
Relationship derivation
Out-of-the-box Verne derives/calculates relationships on every save.
Relationships are derived using the DeriveRelationships command or the deriveRelationships convenience method on the service transaction.
Relationship Instructions
Which relationships are derived for an entity are determined by processing an application’s configured relationship instructions. Relationships are created/maintained for an entity via relationship instructions that "matches" the service transaction in its current state, e.g. a single relationship instruction could relate to a specific service, and/or relate to a specific register role.
See relationship instructions configuration for specific details relating to configuring relationship instructions.
Relationship instructions determine which relationships get created for an entity. A relationship record has a name, a permission pool and may also contain the id of the register role domain that this relationship ‘is for’, e.g. the Director domain.
Additional rule scopes
The first-level relationship instruction relationship scope options for defining rules around when a relationship should apply and the rule element for defining custom rules all relate to whether a relationship relating to the relationship instruction is created/removed/maintained or not.
There are two additional rule scopes relating to relationships that are run after the relationships are derived using the relationship instructions. For efficiency, these rule scopes are only called if there has been a change in the relationships.
