Skip to content

Entity

An entity is either an organization or a person. This includes the grouping of such items. As this model is a core model, there is no need to create a new model. All that is required is that you inherit from the base entity model. From a higher level perspective, the model is intended to be used to build the entire chain of the intended entity you desire. For each additional "child-model", it must only contain the differences from the parent model. For example, to create a contact "entity", you would first create the Person model which will inherit for the Entity Model, then you create the contact model which will inherit from the Person model.

History

Audit History is included as part of the base model with there being no additional work required for audit history to work out of the box.

Notes

Model Notes is included as part of the base model with there being no additional work required for notes to work out of the box.

Model

When creating your model, do not re-define any field that is already specified within the model you are inheriting from. This is however, with the exception of the code docs specifying otherwise.

Example model

This example demonstrates how the contact model is created. As a Contact is a person, there must also be a Person "Entity" created.

Create the person "Entity" only containing the fields for a "person"

app/access/models/person.py
from django.db import models

from access.models.entity import Entity



class Person(
    Entity
):


    class Meta:

        ordering = [
            'l_name',
            'm_name',
            'f_name',
            'dob',
        ]

        verbose_name = 'Person'

        verbose_name_plural = 'People'

    f_name = models.CharField(
        blank = False,
        help_text = 'The persons first name',
        max_length = 64,
        unique = False,
        verbose_name = 'First Name'
    )

    m_name = models.CharField(
        blank = True,
        default = None,
        help_text = 'The persons middle name(s)',
        max_length = 100,
        null = True,
        unique = False,
        verbose_name = 'Middle Name(s)'
    )

    l_name = models.CharField(
        blank = False,
        help_text = 'The persons Last name',
        max_length = 64,
        unique = False,
        verbose_name = 'Last Name'
    )

    dob = models.DateField(
        blank = True,
        default = None,
        help_text = 'The Persons Date of Birth (DOB)',
        null = True,
        unique = False,
        verbose_name = 'DOB',
    )

    def __str__(self) -> str:

        return self.f_name + ' ' + self.l_name + f' (DOB: {self.dob})'

    documentation = ''

    page_layout: dict = []

    table_fields: list = [
        'organization',
        'f_name',
        'l_name',
        'dob',
        'created',
    ]

Now Create the contact "Entity" only containing the fields for a "contact"

app/access/models/contact.py
from django.db import models

from access.models.person import Person



class Contact(
    Person
):


    class Meta:

        ordering = [
            'email',
        ]

        verbose_name = 'Contact'

        verbose_name_plural = 'Contacts'


    directory = models.BooleanField(
        blank = True,
        default = True,
        help_text = 'Show contact details in directory',
        null = False,
        verbose_name = 'Show in Directory',
    )

    email = models.EmailField(
        blank = False,
        help_text = 'E-mail address for this person',
        unique = True,
        verbose_name = 'E-Mail',
    )


    def __str__(self) -> str:

        return self.f_name + ' ' + self.l_name

    documentation = ''

    page_layout: list = [
        {
            "name": "Details",
            "slug": "details",
            "sections": [
                {
                    "layout": "double",
                    "left": [
                        'organization',
                        'created',
                        'modified',
                    ],
                    "right": [
                        'model_notes',
                    ]
                },
                {
                    "name": "Personal Details",
                    "layout": "double",
                    "left": [
                        'display_name',
                        'dob',
                    ],
                    "right": [
                        'f_name',
                        'm_name',
                        'l_name',
                    ]
                },
                {
                    "name": "",
                    "layout": "double",
                    "left": [
                        'email',
                    ],
                    "right": [
                        '',
                    ]
                }
            ]
        },
        {
            "name": "Knowledge Base",
            "slug": "kb_articles",
            "sections": [
                {
                    "layout": "table",
                    "field": "knowledge_base",
                }
            ]
        },
        {
            "name": "Notes",
            "slug": "notes",
            "sections": []
        },
    ]

    table_fields: list = [
        {
            "field": "display_name",
            "type": "link",
            "key": "_self"
        },
        'f_name',
        'l_name',
        'email',
        'organization',
        'created',
    ]

Tip

Take note of the inheritance and the fact that children don't override parent objects.

Testing

As with any other object within Centurion, the addition of a feature requires it be tested. The following Test Suites are available:

  • Unit Test Cases

    • access.tests.unit.contact.<*>.<Inherited class name>InheritedCases (if inheriting from Contact) Test cases for sub-models

    • access.tests.unit.entity.<*>.<Inherited class name>InheritedCases (if inheriting from Entity) Test cases for sub-models

    • access.tests.unit.people.<*>.<Inherited class name>InheritedCases (if inheriting from Person) Test cases for sub-models

  • Functional Test Cases

    • access.tests.functional.contact.<*>.<Inherited class name>InheritedCases (if inheriting from Contact) Test cases for sub-models

    • access.tests.functional.entity.<*>.<Inherited class name>InheritedCases (if inheriting from Entity) Test cases for sub-models

    • access.tests.functional.people.<*>.<Inherited class name>InheritedCases (if inheriting from People) Test cases for sub-models

The above listed test cases cover all tests for objects that are inherited from the base class. To complete the tests, you will need to add test cases for the differences your model introduces.

About:

This page forms part of our Project Centurion ERP.

Page Metadata
Version: ToDo: place files short git commit here
Date Created: 2025-04-03
Date Edited: 2025-04-04

Contribution:

Would You like to contribute to our Centurion ERP project? You can assist in the following ways:

 

ToDo: Add the page list of contributors