Introduction
Glossary Item Box
As far as the components are considered, Creatio can be represented as follows (Fig. 1):
Fig. 1. Components
The development of solutions in Creatio involves different customization levels depending on the type or complexity of a business task. Note that the application core level is an immutable system component. Development in Creatio is done on the configuration and database levels.
Database
This is the level of physical data storage. The database stores not only the client data but also the application settings, as well as the settings of access permissions.
As a rule, development on the Creatio platform does not require working with database objects directly. Creatio tools enable users to work with data using the native interface.
That said, using views and stored procedures on the database level allow users to implement custom business logic and call it from custom configuration elements.
For certain tasks, development on the database level is the most logical solution and the fastest method.
Core
The core is an immutable part of Creatio. It is a set of libraries implementing the base application functionality.
Back-end libraries are implemented in C# with using the .NET Framework platform classes. Developers can create back-end class instances and use the functionality of back-end libraries, but they cannot make any changes in these classes and libraries.
The main back-end components:
- ORM- data model and methods of working with it. In most cases, we recommend using the object model, though the direct access to the database is also implemented in the back-end core components.
- Packages and replacement mechanism.
- Libraries of the server control elements. These control elements include pages server-generated using the ASP.NET technology, for example, pages of the [Configuration] section.
- System web services.
- The functionality of the main designers and Creatio sections.
- Libraries for integration with third-party services.
- Business process engine (ProcessEngine). This is an important Creatio element that can implement algorithms set up as process diagrams.
The primary task of the front-end components of the core is providing the operation of client modules. The front-end classes of the core are implemented in JavaScript using different frameworks. They are designed for creating user interfaces and implementing other business tasks on the side of the browser.
The main front-end components:
- External libraries of client frameworks.
- Sandbox – a special client core component, designed for providing the interaction between different client modules by exchanging the messages.
- Base modules – the files written in JavaScript, where the functionality of the primary Creatio objects is implemented.
Configuration
Configuration – is a set of functionality available for Creatio users of a specific workspace, namely:
- Server logic.
- Auto-generated classes that are the product of system setting operation.
- Client logic – pages, buttons, actions, reports, business processes, and other configuration elements.
The configuration is an easy to modify part of the system. A specific configuration is formed by the following element types:
- Objects – entities designed for data storage that combine a table in the DB and a class on the server-side.
- Business processes – the configured elements that represent a visual algorithm of user actions.
- Client modules.
In Creatio, all the configuration elements are grouped in packages.
A package is a final set of functionality that can be added to the configuration and can be deleted.
The final Creatio functionality is formed by the set of packages in the configuration.
The package mechanism in Creatio is built on the open-closed principle (one of the SOLID OOP practices). According to this approach, all entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means that new logic and features must be implemented by introducing new entities rather than modifying the old ones.
Any Creatio product is a finite set of packages To extend or change application functionality, you need to install the package in which all necessary changes are already implemented.
The Creatio packages can be divided into two types:
- Pre-installed packages. These include packages with basic functionality (e.g., Base, NUI), packages that extend the functionality of the system (for example, 1C integration packages, telephony, etc.), and packages developed by third-party developers. Such packages are either delivered along with the primary application or installed from zip-archives as Marketplace applications.
- Custom packages – created by the system users. These packages can be attached to the SVN repository.
The configuration elements of the pre-installed packages cannot be modified. You can develop additional functionality or modify the existing functionality only via custom packages.
The existing functionality is modified using the replacement mechanism. To change the behavior of a pre-installed element, create a new custom package element that extends it. For the created object, set a property implying that the object will replace the parent object in the object hierarchy. All modifications that have to be applied to the pre-installed object are to be implemented in the replacement object. When calling a preinstalled object, Creatio will then run the logic of the corresponding replacement object.
A single base object can be replaced in multiple custom packages. The resulting replacing object implementation in the compiled configuration is based on the hierarchy of packages that contain the replacing objects.
To use the functionality of a package in another package, specify a dependency on the source package.
The dependent package extends or changes the functionality of the source package. Thus, Creatio builds a hierarchy of dependencies and packages. Low-level packages can extend or modify the logic and features of any package higher in the dependency tree. More information about the package hierarchy and dependencies is available in the “Package dependencies” article.
A complete list of all packages installed in the workspace is available on the [Packages] tab of the [Configuration] section.
- Schemas – configuration items that define new or existing configuration elements.
- External assemblies – third-party libraries required for development and integration with third-party systems They can be used in source code schemas after the installation.
- SQL scripts – arbitrary SQL scripts run upon package installation. You can use SQL scripts to transfer a package to other configurations if it is associated with database changes.
- Data – section records, lookup values, and system settings that have been developed in the package. You may require package data to transfer the package to other development environments if the package is associated with specific records and database values.
More information about working with packages is available in the “Working with packages” article.
Configurable functionality:
Use Creatio development tools to customize the application for solving specific business problems of the user:
- Add new or modify existing system objects, as well as sections, pages, and application details.
- Create or edit business-processes.
- Implement the required business logic for the application components.
- Implement solutions integrating external applications.
You can use the following tools to develop solutions in Creatio:
- Low-code and no-code tools (section wizard, content designer, process designer).
- Front-end development using the built-in IDE or a third-party IDEs using the functionality of core front-end components (changing the business logic of interface components, creating custom components).
- Back-end development using the built-in IDE or a third-party IDEs using the functionality of core back-end components (data processing, implementing integration solutions, user's business process logic).
See Also
