Embedded Functionalities
While the technical complexities of the application are hidden from the user, they are specifically designed to promote ease of use and a smooth, efficient workflow.
Partial Fetch
deXgine employs a partial data loading strategy for large tables, retrieving and displaying information incrementally. This approach minimizes loading times and maintains full application functionality.
- The list employs a partial loading strategy, displaying a subset of records upon opening. The remaining records are loaded dynamically as the user interacts with the list.
- When the user applies a filter, the query is re-executed, retrieving only the matching records from the database.
- When the user scrolls, the application loads the remaining records in batches as needed.
List Filtering
The deXgine runtime environment provides automatic generation and management of list filters, derived from the application model. This functionality obviates the need for manual implementation.
A distinct colored line, located immediately below the table header, serves as the filter interface for each query-based list module.
- Users can filter results directly as they type, without opening a separate window or clicking a specific area.
- Filtering is available for all visible columns, regardless of data type (text, numeric, option list, date, boolean, etc.), except for columns derived from complex SQL constructs (e.g., subqueries, aggregate functions).
- Users can use the '%' character as a wildcard in text filters.
- Numeric and date filters offer complex filtering capabilities, including range and date-specific criteria.
Document Management Capabilities
File-type fields have been added to the model, facilitating document association with any entity.
These fields operate analogously to other data fields, but are specifically designed for file handling.
A central server repository stores all documents, providing data consistency across users.
Client-server file transfers are transparently managed by the system.
Suport for Drag & Drop
DeXgine supports drag-and-drop functionality, allowing users to easily transfer data between applications and windows:
- text (field content) from other applications to deXgine application
- text (field content) from deXgine application to other applications
- files from other applications to deXgine application
- files from deXgine application to other applications
- text and data from different deXgine application modules
A drag & drop interaction between the "Products" and "Invoice Lines" lists simplifies invoice line creation. Dragging a product to the "Invoice Lines" list automatically generates a new invoice line associated with that product. An "onchange" trigger then retrieves and populates the product's price.
Help Generation
Throughout the development process, you have the ability to provide descriptions for each database field, module, button, and other UI elements you define or that are provided by deXgine. These descriptions are then used by deXgine to automatically generate the application's help documentation and User Reference Manual.
- Text formatting will be consistent throughout.
- Module links are automatically detected and included in the help documentation.
- When you add a new module, field, or button, the help documentation is automatically updated to reflect those changes.
- Application documentation can be generated as a help file (.chm) or html.
Multilingual Support
Building multi-language applications is straightforward. Just define the labels and static combo options for each language you plan to support.
DeXgine automatically displays language-specific labels upon user login, based on the user's language setting.
DeXgine Developer includes a built-in translation tool.
E-mail Support
deXgine's runtime environment allows email sending through two methods: user-initiated (client-side) and automated (server-side).
- The client-side email engine leverages the operating system's default email client setting for the current user.
- The server-side email engine is an internal SMTP client that supports PLAIN and LOGIN authentication. CRAM-MD5 support is currently being tested.
User/ Role Management
deXgine applications offer built-in user and role management capabilities through a default business object (tables, modules, menus):
- Create user accounts and assign passwords.
- Create roles and assign users.
- Information about users and roles is used to determine and assign application access rights.
Menu-Level Access Control
Menu access rights are managed natively in deXgine applications, eliminating the need for custom code.
Access rights are definable for both users and roles.
Note: You have the option to implement a custom access rights mechanism if the default functionality doesn't align with your requirements.
Record-Level Access Control
Every deXgine application includes a built-in mechanism for defining access rights for individual records in any table. To enable this functionality, simply specify the desired tables.
Access rights are definable for both users and roles:
- View - the user can view the record
- Modify - the user can modify the record
- Delete - the user can delete the record
- Rights - Users have the ability to grant other users access to the currently selected record.
Administrators have the ability to define templates that initialize record-level access rights for each table where this functionality is enabled.
Note: You have the option to implement a custom access rights mechanism if the default functionality doesn't align with your requirements.
Notifications
Notifications keep application users informed about events. They can be configured for any application event and scheduled for delivery at a specific time (e.g., as reminders).
deXgine offers the tools to define and describe application notifications. The actual implementation of notifications is the responsibility of the application analyst and varies by application.
At the scheduled notification time, the designated user will receive an alert both through a popup window within the application and, optionally, via email.
News
This functionality replicates a traditional poster board, providing a central location for users to post notices that are visible to everyone within the application.
Administrators, or users with appropriate permissions, can enter news items into the system. These news items are then displayed to all users in a scrolling ticker located at the bottom of the application window.
Sticky Notes
This feature offers the same quick note-taking ability as sticky notes, but in a more organized and accessible digital forma
A keyboard shortcut opens a note-taking window that remains topmost on the screen until dismissed.
Notes can also be sent to other users.
Shortcuts
User interaction with application menus varies significantly. Some menus may be used frequently, even multiple times a day, while others are accessed only occasionally, perhaps once a month.
Navigating complex application menus can be time-consuming. deXgine addresses this by allowing users to define custom shortcuts. Typing a shortcut in the designated window instantly opens the associated menu, providing quick access to frequently used functions.
Database Backup/ Restore
This functionality provides application administrators with the ability to back up and restore both the database and the documents stored in the application repository.
Backups are database-independent and portable, allowing cross-platform restoration (e.g., from SQL Server to Oracle).
Backups created by this functionality are always stored as disk files.
It's important to note that these backups are designed to work in conjunction with, not as a substitute for, your organization's comprehensive backup policy (which may include tape backups, dedicated backup appliances, or other external storage solutions).
Background Tasks
This module provides developers, and optionally application administrators, with the ability to schedule the execution of background tasks. These tasks can include nightly checks, automatic report generation, and other similar operations.
The task scheduler allows you to specify the time of day for execution and the frequency (hourly, daily, weekly, monthly, or yearly). For more complex scheduling requirements, custom logic can be implemented within the background function itself.
Audit
DeXgine offers an on-demand auditing feature.
To avoid excessive database growth, auditing is not enabled by default for all data changes. While login activity is automatically logged, other data changes are only audited when specifically requested by the application administrator. Administrators can easily activate auditing for specific database tables by right-clicking on a module and selecting the "Monitor" option.
When implemented, the auditing functionality provides a clear record of who made specific changes, when, and where, promoting accountability among users.
Key Features:
- Event Logging: Records events, such as user logins and data modifications.
- Timestamping: Each event is precisely timestamped to provide a chronological order of activities.
- User Identification: Captures the identity of the user who performed the action.
- Data Tracking: Logs specific data that was created, modified, or deleted.
- Search and Filtering: Allows users to easily search and filter audit logs based on specific criteria like date range, user, event type, database table, record id or record name.
- Security: Audit log access can be protected using menu level access rights - standard DeXgine functionality.