DeXgine - Development Steps |

DeXgine significantly reduces development time by automating many of the routine tasks associated with application development.

While application structure analysis and description remain the developer's responsibility, DeXgine handles the creation of the user interface and the complex mapping of these fields to the database.

The Embedded Functionalities provide additional value to your application without requiring any development effort on your part.

The following outlines the steps in the development process:

Define the database structure

Clearly defining the database structure is fundamental to application development. DeXgine facilitates this process through the following mechanisms:

Directly defining the tables (entities), their columns, and the relationships that connect them.
Using entity-relationship diagrams to model the database structure;
Importing pre-existing SQL DDL (Data Definition Language) scripts.
Importing existing database structure.

Keep in mind that DeXgine's database model extends standard SQL DDL when importing an existing script. After importing, parse the newly created objects and set up the extended properties accordingly.

In addition to other definitions, you can also specify initialization or configuration data here.

Define the user interface (UI)

The user interface is structured around Modules. Each module contains a set of related user interface controls, such as fields and buttons, designed to:

Display the stored database information in a clear and user-friendly manner;
Enable users to manipulate and manage the data.

In the majority of cases, defining a module involves writing a SQL query against the database. DeXgine then automates the remaining steps:

DeXgine handles the creation and configuration of user interface controls, automatically detecting the appropriate type (edit, combo, checkbox, etc.) and defining their size, labels, and other properties.
Implement the necessary code to process data modifications entered by the user, specifically insert, update, and delete operations.
Implement the synchronization logic required for master-detail modules. A common example is maintaining consistency between an invoice and its corresponding line items.

In most cases, defining a module simply requires writing the corresponding query. However, for specific functionality requirements, you can customize the default behaviour or write custom code using DeXgine's built-in high-level Programming Language.

You can then use the Report Generator to develop the reports.

The next step involves adding your modules to the application menu. At this point, your application is nearly finished.

DeXgine offers multi-language support, allowing you to make your application available in multiple languages. Now is the time to translate the labels, menus, and help text to enable this functionality.

Deploy

This single step performs all the necessary actions to create the installation kit. It builds the required binaries, compiles the help documentation for all specified languages, and generates the setup executables for single-user and multi-user deployments.

Short Example

After trying to offer a concise view over the standard development steps I realized that I'm nowhere close to describing the benefits of using DeXgine.

So, I'll try to give you a sense by using an example: Developing a short ticketing app.

Watch the video at the end...

The "specifications":

The customer sends a support request - Service Call (Ticket)
Someone adds the record into the database and allocates the request to one of the colleagues
I want to be able to find, add, modify, delete a customer and/ or a ticket
The tickets must have a number/ code. Any correspondence with the customer will refer this ticket number. Auto-numbering would be nice.

The development:

I need a way to store the customers (accounts).

            
            create table account (
                acc_id        integer not null,
                acc_name      varchar(128) not null,
                acc_pin        varchar(64),
                acc_phone        varchar(64),
                acc_email        varchar(128),
                acc_description    varchar(512),
            constraint pk_account_01 primary key(acc_id),
            );

And the tickets

            
            create table service_call (
                svc_number        varchar(20) not null,
                svc_date        date not null,
                svc_duedate        date not null,
                svc_importance        integer not null,
                svc_account        integer not null,
                svc_status        integer not null,
                svc_name        varchar(128) not null,
                svc_solution        varchar(128) not null,
                svc_responsible 	varchar(20) not null,
            constraint pk_service_call_01 primary key(svc_number),
            );

Since I took the time to write these scripts for you, I may as well, use them to create the tables in DeXgine. I'll save them into a file and import the script.

Now, as I very nicely specified above, I'll add the extended properties and specify the relationship between the tables.

"After importing, parse the newly created objects and set up the extended properties accordingly."

            
                
                    acc_name Dexgine attribute: mark this field as "name". When a record from this table is referred in a module, the list of accounts will display the account name and not it's record ID.
                     
                    svc_number Dexgine offers a single click option for defining an autonumbering module and adding it to the application menu
                     
                    svc_date Dexgine attribute: Default: [today]. Each new record will populate this field with current date.
                     
                    svc_importance Dexgine attribute: Option List: 0="Default,(Ro)Implicit", 1="Low,(Ro)Mica", 2="Urgent". This field will present an option list selector (combo) with these values.
                     
                    svc_account Referes the account table: [account.acc_id]
                     
                    svc_responsible Referes the user table: [xguser.user_code]

Also, please note the multi-language option list for the svc_importance field. Any number of languages prefixed by the language identifier. In this case, base language (English) with no identifier and Romanian with "Ro": 0="Default,(Ro)Implicit".

Well. I'm kind off... done!

Ok. Here it is:

From the account table definition:

Select the types of modules that DeXgine will create. In my case, 2 modules. A list of accounts and an account detail. Double click on a record from the list will open the detail module for the selected record.
Button "Generate Module" creates the module and opens it for fine-tuning. Here, button "Menu" opens the hierarchical menu structure and asks me where I want the menu entry. I'll specify the root/ main location

From the service_call table definition:

Select the types of modules that DeXgine will create. In my case, 2 modules. A list of tickets and a ticket detail. Double click on a record from the list will open the detail module for the selected record.
Button "Generate Module" creates the module and opens it for fine-tuning. Here, button "Menu" opens the hierarchical menu structure and asks me to select where I want the menu entry. I'll specify the root/ main location

Fine-tuning

Order of the columns in the list modules. Just change the order of the fields in de definition query.
Arrange fields in the detail module. Inside the module interface, a combination key gets me to the edit option. Fields are organized by drag&drop in a matrix.
Additional field attributes at the module level - if necessary. In edit mode, you have full access at the field attribute simply by selecting it.

Deploy

acc_name	Dexgine attribute: mark this field as "name". When a record from this table is referred in a module, the list of accounts will display the account name and not it's record ID.

svc_number	Dexgine offers a single click option for defining an autonumbering module and adding it to the application menu

svc_date	Dexgine attribute: Default: [today]. Each new record will populate this field with current date.

svc_importance	Dexgine attribute: Option List: 0="Default,(Ro)Implicit", 1="Low,(Ro)Mica", 2="Urgent". This field will present an option list selector (combo) with these values.

svc_account	Referes the account table: [account.acc_id]

svc_responsible	Referes the user table: [xguser.user_code]