Data Structure Definition

Overview

The Data Structure Definition screen allows you to view the list of Entities uploaded to Fynapse and delete individual Entites without the need to re-upload the Configuration Data JSON file.

For more details on the Data Structure, refer to Data Structure.

General Information

Data Structure Definition Constraints

The definitions uploaded in a JSON file have to meet the following prerequisites:

Entity

• name:
  • Has to be unique.
  • Has to be composed using the following rules: start with letter, which can be followed by alphanumeric characters and an underscore.
  • Has the maximum length of 128 characters.
• temporalityType - what kind of data are contained in this Entity:
  • Reference - determines that the entity has a reference data type
  • Transaction - determines that the entity has a transactional data type; these are accounting data that cannot be changed
• description - you can add an optional description
• type - determines what type of an Entity this is:
  • ProtectedEntity - this is an entity which is created by the system when you define configurations that are necessary for the functioning of the system.
  • DefinedEntity - this is an entity defined by the user, you can create as many or as little defined entities as required by your data architecture.
• primaryKeyAttributeNames - this is the definition of Attributes which will constitute the Primary Key and allow to identify the record in the system
  The Primary Key has to:
  • Be unique
  • Consist of only mandatory Attributes
  • Consist of a minimum of 1 Attribute
  • Consist of a maximum of 5 Attributes (this requirement is valid for Defined Entities only)
  • Consist only of primitive attributes

Attribute

• name - unique name:
  • Has to be unique.
  • Has to be composed using the following rules: start with letter, which can be followed by alphanumeric characters and an underscore.
  • Has the maximum length of 128 characters.
• label:
  • Has to be unique
  • Has the maximum length of 128 characters
  • No constraints on syntax
• mandatory - determines if an attribute is mandatory:
  • true
  • false
• type - determines whether this is a Primitive or a Complex Attribute:
  • Primitive attributes:
    • UUID
    Please note that the UUID inputs are not generated automatically. You need to generate them either via a third party generator or in your upstream system and include them in the ingest file with the rest of the input data.

    • BOOLEAN
    • TIMESTAMP - the format used in Fynapse is: yyyy-mm-dd HH:mm:ss. This format is hardcoded and cannot be changed.
    • DATE - the date format Fynapse is: yyyy-mm-dd. This format is hardcoded and cannot be changed.
    • TEXT
    • INT
    • DECIMAL - the decimal attribute operates with the following parameters: scale 18 digits and precision 3 digits. This format is hardcoded and cannot be changed.
    • HIGH-PRECISION DECIMAL
  • Complex attributes:
    • Inline Entity - this is an entity attribute type, i.e. a child entity nested within another entity.
    • List - this is an attribute type which can store an ordered collection of data, primitive or complex, e.g. Inline Entities. The data contained within the List will be ordered in accordance with the order they were supplied to Fynapse. An example of this is a ‘person’ Entity with list of ‘children’, ordered from youngest to oldest.
      A special example of this are Protected entities Journal and Journal Line, with Journal Entity containing a list of Journal Line Entities. Their order is determined by Fynapse.

Effective From

The Effective From date is a technical field that is mapped do a dateField defined in a Reference Entity.

If you don’t define a dateField in your Reference Entity or the dateField attribute is left empty in your ingestion file, a default Effective From date will be assigned by the system. This means that the Primary Key will be the only identifier of reference data and the newest version of the data, as identified off of the Primary Key, will be used for enrichment.

If you decide to populate the dateField, then when there are multiple versions of reference data the data with Effective From date effective at the time of the Posting Date of an ingested transaction event will be used for enrichment for this transaction.

1
{
2
  "name": "EntityWithDateField",
3
  "description": "Reference Entity with Effective From",
4
  "type": "DefinedEntity",
5
  "temporalityType": "Reference",
6
  "dateField": "effectiveDate",
7
  "primaryKeyAttributeNames": [
8
    "CompanyId"
9
  ],
10
  "attributes": [
11
    {
12
      "type": {
13
        "typeName": "PrimitiveType",
14
        "primitive": "TEXT"
15
      },
16
      "name": "CompanyId",
17
      "label": "Company ID",
18
      "mandatory": true
19
    },
20
    {
21
      "type": {
22
        "typeName": "PrimitiveType",
23
        "primitive": "DATE"
24
      },
25
      "name": "effectiveDate",
26
      "label": "Effective Date",
27
      "mandatory": true
28
    },
29
  ]
30
}

Validations

Validations - you can define your own validations for Business Events
For more details, refer to Validations.

Examples of Attribute Definitions:

Primitive Attributes

1
{
2
"name": "company",
3
"label": "Company",
4
"mandatory": true,
5
"type": {
6
"typeName": "PrimitiveType",
7
"primitive": "TEXT"
8
    } 
9
}

1
{
2
"name": "glAccount",
3
"label": "GL Account",
4
"mandatory": false,
5
"type": {
6
"typeName": "PrimitiveType",
7
"primitive": "INT"
8
    }
9
}

1
{
2
"name": "timeOfAdmission",
3
"label": "A timestamp of the record's admission to the organization",
4
"mandatory": true,
5
"type": {
6
"typeName": "PrimitiveType", 
7
"primitive": "TIMESTAMP"
8
    }
9
}

Complex Attributes

1
{
2
"name": "personal",
3
"label": "Personal data (names, etc.)",
4
"mandatory": true,
5
"type": {
6
    "typeName": "InlineEntityType",
7
    "definition": {
8
        "name": "PersonalData",
9
        "description": "A personal data record",
10
        "type": "DefinedEntity",
11
        "primaryKeyAttributeNames": [
12
        "id"
13
        ],
14
        "attributes": [
15
        {
16
        "name": "id",
17
        "label": "Record ID",
18
        "mandatory": true,
19
        "type": {
20
        "typeName": "PrimitiveType",
21
        "primitive": "UUID"
22
        }
23
        },
24
        {
25
        "name": "familyName",
26
        "label": "Family name",
27
        "mandatory": true,
28
        "type": {
29
        "typeName": "PrimitiveType",
30
        "primitive": "TEXT"
31
        }     
32
        },
33
        {
34
        "name": "firstName",
35
        "label": "First name",
36
        "mandatory": true,
37
        "type": {
38
        "typeName": "PrimitiveType",
39
        "primitive": "TEXT"
40
        }        
41
        },
42
        {
43
        "name": "middleNames",
44
        "label": "Middle names",
45
        "mandatory": false,
46
        "type": {
47
        "typeName": "ListType",
48
        "itemType": {
49
            "typeName": "PrimitiveType",
50
            "primitive": "TEXT"
51
            }
52
        }   
53
        }
54
    ]
55
    }
56
}         
57
}

1
{
2
"name": "children",    
3
"label": "List of children",
4
"mandatory": false,    
5
"type": {
6
    "typeName": "ListType",
7
    "itemType": {
8
    "typeName": "InlineEntityType",
9
    "definition": {
10
        "name": "Child",
11
        "description": "Record about a child",
12
        "type": "DefinedEntity",
13
        "primaryKeyAttributeNames": [
14
            "childId"
15
        ],
16
        "attributes": [
17
        {
18
        "name": "childId",
19
        "label": "Child ID",
20
        "mandatory": true,
21
        "type": {
22
            "typeName": "PrimitiveType",
23
            "primitive": "UUID"
24
            }
25
        },
26
        {
27
        "name": "gender",
28
        "label": "Gender",
29
        "mandatory": true,
30
        "type": {
31
            "typeName": "PrimitiveType",
32
            "primitive": "TEXT"
33
            }
34
        },
35
        {
36
        "name": "personal",
37
        "label": "Personal data (names, etc.)",
38
        "mandatory": true,
39
        "type": {
40
            "typeName": "InlineEntityType",
41
            "definition": {
42
                "name": "PersonalChildData",
43
                "description": "A personal data record of a child",
44
                "type": "DefinedEntity",
45
                "primaryKeyAttributeNames": [
46
                    "id"
47
                ],
48
                "attributes": [
49
                {
50
                "name": "id",
51
                "label": "ID",
52
                "mandatory": true,
53
                "type": {
54
                    "typeName": "PrimitiveType",
55
                    "primitive": "UUID"
56
                    }
57
                },
58
                {
59
                "name": "familyName",
60
                "label": "Family name",
61
                "mandatory": true,
62
                "type": {
63
                    "typeName": "PrimitiveType",
64
                    "primitive": "TEXT"
65
                    }
66
                },
67
                {
68
                "name": "firstName",
69
                "label": "First name",
70
                "mandatory": true,
71
                "type": {
72
                    "typeName": "PrimitiveType",
73
                    "primitive": "TEXT"
74
                    }
75
                },
76
                {
77
                "name": "middleNames",
78
                "label": "Middle names",
79
                "mandatory": false,
80
                "type": {
81
                    "typeName": "ListType",
82
                    "itemType": {
83
                        "typeName": "PrimitiveType",
84
                        "primitive": "TEXT"
85
                        }
86
                    }
87
                }
88
                ]
89
            }
90
            }
91
        }
92
        ]
93
    }
94
    }
95
}
96
}

Data Structure Definition Screen

The Data Structure Definition screen comprises the following sections:

• The work pane:
  • The Refresh button - click it to check:
    • If any new Entities appeared
    • If any of the Entities were deleted
    • If statuses of the Entities changed
  • The Delete button - click it to delete a selected Entity from the database using the Schema Repository
    Note that deleting an Entity cannot be reverted.

  • The Delete all button - click it to delete all the Entities from the database using the Schema Repository
    Note that deleting an Entity cannot be reverted.

• The grid - where you can see information about the Entities. One row in a grid represents one row in a database. The grid comprises the following columns:
  • Entity name - a unique name of the uploaded Entity
  • Entity status - a status of a particular Entity

Entities’ Statuses

• CREATE_REQUESTED - a request for creating an Entity in a database was sent
• CREATING - a temporary status displayed in the grid when creating is in progress
• CREATED - the Entity has been created
• CREATE_ERROR - an error occurred during creating the Entity
• DELETE_REQUESTED - a request for deleting the Entity from a database was sent
• DELETING - a temporary status displayed when deleting is in progress
• DELETED - the Entity is about to be deleted from the database. You will not be able to see this status because the row with the Entity you scheduled for deletion is also deleted from the grid.
• DELETE_ERROR - an error occurred during deleting the Entity
• UNKNOWN - the status of the Entity is not known. Contact the system administrator to find out more.
• EMPTY - no provisioning was requested
• EDIT_REQUESTED - provisioning request for EDIT was sent

Tutorials