LogoLogo
User DocsAPI Docsatfinity.swiss
  • 🚀Atfinity: No-Code Process Automation
  • Guides
    • Getting Started
      • Introduction
      • 1. Create Ontologies and Roles
      • 2. Create Information
      • 3. Create and Configure a Document
      • 4. Create a Rule
      • 5. Create a Process
      • 6. Put Live
      • Summary and Next Steps
    • Advanced Topics
      • Extending a Workflow
      • Customizing Names of Cases and Instances
      • Automatically Calculating Information Values
      • Using Built in Integrations
    • Troubleshooting
      • Why is a question not asked?
      • Why is a question asked?
      • The value of my calculated field has a strange format
      • Why is my Proof never asked for?
      • Why is my Rule not executed?
      • Why are some options missing in a dropdown?
      • Case Errors
    • Glossary
      • Case
      • Process
      • Workflow
      • Ontology
      • Instance
      • Role
      • Information
      • Document
      • Document Section
      • Document Template
      • Rules
      • Scheduled Rules
      • Information Types
      • Tab
      • Category
      • Taxonomy
      • Proof
      • RuLa Functions
      • Constants
  • Rule Language (RuLA)
    • ℹ️What is RuLa?
    • Declarations
      • is
      • is with where
      • is all
      • is all with min max
      • Role Choices
    • Expressions
    • Operators
      • Boolean Operators
        • =
        • !=
        • >
        • >=
        • <
        • <=
        • and
        • and then
        • not
        • or
        • or else
        • matches (~=)
      • Date Operators
        • NOW
        • IS_DATE
        • TODAY
        • FORMAT_DATE
        • DAYS
        • WEEKDAYS
        • ADD_DAYS
        • ADD_WEEKDAYS
        • ADD_MONTH
        • ADD_YEARS
        • SUBTRACT_YEARS
        • AFTER
        • DATE_EQUAL
        • DATETIME_EQUAL
        • AFTER_EQUAL
        • BEFORE
        • BEFORE_EQUAL
        • DAYS_AGO
        • MONTHS_AGO
        • YEARS_AGO
      • Known Operators
        • unknown
        • known
        • SNEAKY
        • AVG_OF_ANY
        • LIST_OF_ANY
        • MAX_OF_ANY
        • MIN_OF_ANY
        • SUM_OF_ANY
        • CONCAT_OF_ANY
        • UNION_OF_ANY
        • JOIN_OF_ANY
      • List Operators
        • [ , ] (create)
        • [] (access)
        • in
        • not in
        • contains
        • contains any
        • contains only
        • COUNT
        • SORT
        • CUSTOM_MAX
        • REVERSE
        • FIRST_ELEMENT
        • ALL
        • SOME
        • UNION (or |)
        • SET_DIFFERENCE
        • INTERSECTION
        • MAP
        • FILTER
        • FILTER_FALSE
        • FILTER_UNKNOWN
        • SET
      • Dictionary Operators
        • {} (create)
        • [] (access)
        • in
        • keys()
        • FLATTEN
      • Mathematical Operators
        • + - / *
        • %
        • **
        • //
        • AVG
        • CEIL
        • FLOOR
        • MAX
        • MIN
        • ROUND
        • SUM
        • SUM_PRODUCT
        • SQRT
      • String Operators
        • LEN
        • LOWER
        • UPPER
        • TRIM
        • TRIM_LEFT
        • LEFT
        • RIGHT
        • SLICE
        • REPLACE
        • REPLACE_CHARS
        • format
        • calculated_name
        • CONCAT
        • markdown_table
        • make_filename
        • JOIN
        • uuid
      • Special Operators
        • :=
        • ensure
        • get_attr
        • get_translated_attr
        • has_attr
        • get_properties
        • instances
        • instances_exist
        • is
        • ontology
        • Translate (.$)
        • translate_string
        • roles
        • self
        • name_and_log (debug)
    • Conditional Expressions
      • case
      • if-then-else
      • switch
    • Comments
    • Information about the case
    • Accessing the outcome instance
    • Information about documents
    • Recipes
  • Document XML (ADX)
    • ℹ️What is ADX?
    • ADX Elements
      • Body
      • Text
      • Image
      • Columns
      • Field
      • Checkbox
      • Table
      • Rect
      • Line
      • Space
      • KeepTogether
      • Template
      • Style
      • Page Number
      • QR Code
      • HR Code
    • Jinja Templating
      • Instances
      • Case Meta Information
      • Custom Translations
      • Functions
      • Jinja filters
    • Font support
  • API
    • ℹ️What is the Atfinity API?
    • Generate API Keys
    • API Documentation
    • Calling your APIs within Cases
    • External Data Sources (e.g. CRM)
  • Deploying
    • Deploying on-site
      • Kubernetes
      • Docker Compose
    • Management commands
    • Security Logging
    • LDAP User Backend
    • Single Sign On
  • Integrations
    • Avaloq
    • Worldcheck
  • Releases
    • Release Notes
      • Version 11.x
      • Version 10.x
      • Version 9.x and earlier
    • Release Schedule
Powered by GitBook
On this page
  • Step 1: Create new Ontologies
  • Step 2: Create a new Role
  • Step 3: Configure the role

Was this helpful?

  1. Guides
  2. Getting Started

1. Create Ontologies and Roles

PreviousIntroductionNext2. Create Information

Last updated 2 years ago

Was this helpful?

When starting with configuring a new process, it makes sense to first create ontologies and then roles.

Step 1: Create new Ontologies

are templates for all the actors in a process. In our scenario, we have two actors:

  • A Contract, which will be the result of our account opening process.

  • A Person, namely the client who wants to open an account. This person will also be the account holder, which will be important when creating roles.

We therefore need two ontologies: Contract and Person.

It is important to differentiate between an ontology and an of an ontology. An ontology is a template. An instance of an ontology is what we get, when we have filled out and completed the template.

Let's take 'Person' as an example. The ontology 'Person' acts as the blueprint of a person. It tells us that a person has a first and last name as well as a date of birth. However, that's only the template. Once we have filled out and completed this template e.g. with 'Tim Jones, 14.06.1978' we have created an instance of 'Person', namely a person called Tim Jones who was born in 1978.

When creating a new ontology, we have to define two essential things: a key and a name.

The key is an internal reference. This key stays the same, no matter what language we use Atfinity in. That way it functions like a clear identification of that ontology which Atfinity can use in its code. Therefore, it needs to be unique. This key should only exist once in Atfinty. But at the same time, it should be meaningful. For our scenario, 'Contract' works perfectly and helps us to recognise the contract ontology by its key.

As a name, we write 'Contract'. This describes best, what we are dealing with. The name is what is shown to the user of Atfinity. Unlike the key, the name does not need to be unique. It also can be translated to different languages if necessary.

You will have noticed that in this case the name looks just like the key. But this is only the case if we use Atfinity in English. Keep in mind that the name 'Contract can be translated, so it would be 'Vertrag' in German or 'Contratto' in Italian. Although the names are different, they all have the same key, 'Contract'.

Now that we have created the contract ontology repeat this step to create a second ontology for the person. Use 'Person' as key and name.

Step 2: Create a new Role

Similarly to creating an ontology, creating a role starts with giving the role a key and a name. In our case we write 'AccountHolder' for the key and 'Account Holder' for the name.

Step 3: Configure the role

In the previous step we have only created the role 'Account Holder'. Now we need to define the ontology that can have this role. As explained before, that's the ontology 'Contract' in our scenario.

We now also need to specify who is allowed to take the role. In our case, the account holder needs to be a person. 'Account Holder' therefore applies to instances of the ontology 'Person'.

Although we have already created the necessary roles, practise your understanding by creating another role, e.g. the role of a beneficial owner.

An outcome ontology we create can have that need to be taken by instances of other ontologies. In our scenario, a contract needs to state the person who is the account holder of the newly opened account. The role Account holder therefore belongs to the outcome ontology 'Contract' and can be taken by instances of the ontology 'Person'.

And just like that we are already done with this step. Go to the next article where we will for our two ontologies.

Ontologies
instance
roles
Create Information