Automatic UI
Developing the User Interface code can be an exhaustive and repetitive task. Moreover, many user interface requirements are common across multiple application domains.
For example, analysis of data using graphs and interactive dashboards is a very popular requirement.
Likewise, viewing tabular data in a Datagrid is a very common requirement too.
FlexiCore Automatic UI library is designed to make the process of adding common data widgets very simple and very powerful process. Once added to a project, users and not developers can add new views of their data to a system.
These components are built to take advantage of the coupling between a FlexiCore based server and the user interface.
The Editor component of the supported widgets accesses a FlexiCore based server to get all available data sources (that is, APIs returning data) and their properties such as possible filtering, data types, etc.
This is possible because FlexiCore transparently turns every REST endpoint created in a plugin or in the main application into a flexible data-source exposing its available filtering.
For example, once the Datagrid editor component is added to a front end project, users can add any Datagrid they need using any function (API) the server exposes. It is a simple task like using Excel or Powerpoint.
The backend code needs no change to provide this flexibility when a new API is added to the server.
Created instances of specific definitions of supported widgets are saved on the system database and are subject to the FlexiCore permission system.
Without FlexiCore Dynamic User Interface support, new back-end functionality would have required coding a new Datagrid for the new functionality provided.
In a similar fashion, users can define server side actions which are actually API calls, these actions are saved on the database and can be invoked by schedule, rule or a button.
Of course, FlexiCore strict access control rules apply.
What is Automatic UI?
Automatic UI is a set of UI components and server-side services that enable users of the system to define new views of server side data without the help of developers.
Developers only need to use the editor and viewer components’ set of any of the supported widgets.
Why use Automatic UI?
Automatic UI technology tremendously cuts development costs and time while allowing more control on available data views by authorized users.
In addition, most server-side improvements are automatically used by the user interface with any change.
FlexiCore Automatic UI provides out of the box data-aware user interface widgets (grid, dashboard, hierarchical view, fan menu) that can be associated with server-side data or actions.
Angular UI Plugins.
FlexiCore introduces support for UI side plugins which brings modularity to front-end development in Angular, or in any framework that supports dynamic JavaScript loading.
The server provides the required APIs for maintaining existing and new UI side plugins.
Dynamic Dashboards.
FlexiCore dynamic dashboard dynamically accesses all available API points providing data. Users creating the dashboard are presented with available fields returned from each data endpoints, for the creation of graphs, plots, cards, and data grids inside dashboards.
Cards can contain images, including dynamic images, text-based fields updated from server data.
Dashboard creators can expose user interface widgets available to dashboard viewers at run time for filtering the data sources used in the dashboard.
Dashboard creation workflow requires no code and includes reach set of drawing, image insertion, text control, etc.
Dynamic grids.
FlexiCore dynamic Datagrid can access any available API endpoint providing data. Users creating a grid are presented with available fields returned from each data endpoints.
Available fields can be used in predefined columns while controlling edit time filtering and run time filtering.
Grid presets’ creators can expose user interface widgets available to grid viewers at run time for filtering the data used in the Datagrid.
Like all of the FlexiCore UI components, created Datagrids are saved in the server database and are subject to the FlexiCore data access permissions system.
Dynamic Hierarchies.
FlexiCore dynamic hierarchies can access any available API endpoint providing data. Each level in the hierarchy can be either static or connected to a data source from any API endpoint without any line of code.
When data is fetched, it can be presented inside the tree, on a Datagrid preset, or on a map.
Hierarchies are responsive and have a completely different look and feel on mobile devices.
