Rubixs framework provides application development SDK, which enables application developers to design, build and deploy highly scalable modern data driven apps using eclipse plugin development environment. The framework SDK promotes application developers to build modern web, desktop and mobile apps using JAVA language constructs. Prototypes and apps can be assembled and delivered faster to meet the project requirements, as core of rubixs provides convenient data management API bundled with rapid application development tools.
Compare to various web frameworks, rubixs has many advantages over traditional web development methodologies, such as having wide array of JAVA ECO system technologies and eclipse workbench concepts at its disposal. For example, developers have industry proven refactoring support, testing/mocking libraries, debugging and profilers under the umbrella of JVM tools and technology, hence experience the full potential of JAVA development.
SDK come is two flavors:
IDE comes with rubixs plugins and their dependencies bundled inside, where as plugins can be manually installed on existing eclipse RCP/RAP type target platforms to integrate rubixs features out of the box.
CRUD operations supported data driven editors can be easily assembled by composing single or several rubixs entities where developer can define their data join relations and constructs. The developer is not required to focus on tedious and time consuming user interface development for data editors, views by writing complex SWT code blocks. Developer is presented with UI designer, where he can drag ‘N drop data models, their corresponding UI elements and features to construct one2one, one2many type, highly scale-able data editors and views. This will greatly enhance business application development in many folds as the focus in primarily on model.
Rubixs solutions are platform and RDBMS neutral and the framework encourage development of single-source business applications. Most of the modern web application development frameworks, requires you to learn additional scripting, non Java configurations, constructs and 3rd party tools, etc. This process basically requires expert knowledge on particular tools and technology, apart from Java to keep all participants communicating smoothly. The integration between framework artifacts and the dependent layers still needs lot of coding effort to implement data binding, validations, business rules, etc. During most implementations, when the base model attributes are changed, the view and controller is not immediately notified of underlying broadcasted model changes. This is where the rubixs comes into action. Rubix models are in sync with dependent artifacts during all phases of software development life cycle. The model changes will automatically trigger content validators to analyze the change deltas and mark/highlight invalid artifact content blocks using the problem markers with quick-fix resolutions where applicable.
Rubixs Development Workflow
Rubixs entity import wizard allows the developers, connecting to an existing datasource connection and provide model configurations, runtime attributes and model events to generate rubixs entity models. Generated entity models can be manually altered using Java constructs to introduce additional attributes, features and functions. Entity object supports transitory column implementations for non persistence type data operations. Rubixs framework provides powerful annotations constructs to implement column level data change listeners and transaction state event triggers.
Entity Import Wizard
Entity import wizard generates entity model by importing selected table schema from the underlying database. Developer is required to provide entity visual control bindings and relation configurations, etc.
Step 1 > Select Import Entity Wizard.
Step 2 > select table to generate entity.
Step 3 > Select package to generate entity java class file.
Step 4 > Provide visual control bindings for table columns.
Step 5 > Define relation configurations for each lookup column.
Step 6 > Define key-value map configurations for each key-value map type column.
Step 7 > Define list of values for each List of Value type column.
Step 8 > Select default display column.
Step 9 > Select columns to generate ON_CHANGE event place holder constructs using @EntityColumnDataChange annotation.
Step 10 > Select columns to generate record event place holder constructs using @EntityRecordEvent annotation.
Step 11 > Define authorization and access control configurations.
Step 12 > Generated entity preview.
1. Generated Class : IdCustomer
Rubixs automatically generates the entity class when finished importing from table schema as below. The generated entity includes column attributes for each table column.
2. Generated Attributes : Entity Columns
Additionally it will generate column captions, which you can modify.
3. Generated Constructor : IdCustomer
Entity constructor, you can define cascade delete operation constructs and various initialization blocks, which will be executed when entity is loading first time.
4. Generated Method : initializeColumns
This method is responsible for creating and registering entity columns to the underlying entity model. For each column type rubixs provides column generators. Generated column configurations can be altered to register sorting order, etc. Alternatively developer can manually add columns using column-factories. The entity generator automatically extracts column constraint rules from the underlying database table for each column. Each column is given index, which will be used to order the sequence of listing entity columns in editor designers. Initialize Columns method will support following types of data columns:
TINY_TEXT, SHORT_TEXT, LONG_TEXT
DATE, DATETIME, TIME
5. Entity Column Types
Rubix support multiple column types for various data representation requirements.
TINY_TEXT, SHORT_TEXT, LONG_TEXT
DATE, DATETIME, TIME
MAP, CHART, GADGET
6. Generated Method : initializeLookupColumns
This method initialize and add lookup type columns to the underlying entity. Lookup columns can register for static and dynamic content filters. Static filter, when registered will be applied during data lookup calls from all sources, hence lookup always returns filtered results to the caller. Dynamic filters can be introduced for session purposes, which will only be applicable to the defined rule scope/context.
7. Generated Method : initializeTransitoryColumns
This method initialize and add transitory type columns to the underlying entity. Transitory type columns do no persist the data during CRUD operations, hence their content is generated on the fly. These columns can be used for various place holder type implementations such as calculated columns.
8. Generated Method : initializeCharts
This method initialize and register chart type transitory columns to the underlying entity. Charts do no persist the data during CRUD operations, hence their content is generated on the fly. Chart type column requires data bindings to display chart items using @EntityColumnDataChange rubixs annotation. This can be achieved by introducing annotation to capture column DATA_CHANGE event and registering command to decorate the chart items. For example, when customer_id column data is changed during record navigation, we can decorate the chart item values for selected customer by using custom queries and computations. You can find example implementation under annotations section later.
9. Generated Method : initializeMaps
This method initialize and register map type transitory columns to the underlying entity. Maps do no persist the data during CRUD operations, hence their content is generated on the fly. Map type column requires data bindings to display map contents using @EntityColumnDataChange annotation. This can be achieved by introducing annotation to capture column DATA_CHANGE event and registering command to decorate map contents. For example, when customer_id column data is changed during record navigation, we can decorate the map content for selected customer by using custom queries and computations. You can find example implementation under annotations section later.
10. Generated Method : initializeActions
This method initialize and register entity actions for given entity. Entity action requires action bindings to invoke user defined action commands using @EntityActionInvoke annotation. You can find example implementation under annotations section later.
11. Generated Method : initializeGadgets
This method initialize and register gadgets to the underlying entity. Gadgets do no persist the data during CRUD operations, hence their content is generated on the fly. Gadget type column requires data bindings to display gadget contents using @EntityColumnDataChange annotation. This can be achieved by introducing annotation to capture column DATA_CHANGE event and registering command to decorate gadget contents. For example, when customer_id column data is changed during record navigation, we can decorate the gadget content for selected customer by using custom queries and computations. You can find example implementation under annotations section later.
12. Generated Method : initializeDefaultSearchFilters
This method initialize default search filters.
13. Generated Method : initializeDefaultSearchResults
This method initialize default search results.
14. Generated Method : initializeDefaultRelations
This method initialize default relations. Default relations are not loaded during constructor call to avoid recursive cycles, hence this method is invoked on demand during lookup and transaction operations.
15. Generated Method : doSaveRecord
This method is invoked when record transaction is about to commit.
16. Annotation : @EntityColumnDataChange
This annotation is used to bind action command to column change event, where developer assign the column name as the subscriber for the event.
17. Annotation : @EntityRecordEvent
This annotation is used to bind action command to a record event, where developer assign the event type of record.
18. Annotation : @EntityActionInvoke
This annotation is used to bind action command to an entity action, where developer assign the column name as the subscriber for the event.
Rubix provides UI designer to design data editors visually using drag and drop. The designer includes layouts, data-sets, data observers, detail observers, relations, actions, charts, maps, etc. Layouts can be further customized to produce enhanced user interface designs. The designer automatically populates widgets from the underlying data models.
During the design time, developer can preview the editor with live data, by providing a valid connection profile. This preview includes both look and feel of the design and how it behaves functionally. For Ex. developer can immediately check validations in the preview mode. The model changes are captured and immediately available during the preview mode.
Rubix provides professional toolkit to design highly scalable data views that can be easily integrated with rich client platform (RCP) and remote application platform (RAP). The framework highly promotes single source applications, where same code runs on both desktop and web seamlessly, without adding extra effort. The developer is not required to implement record transaction management, navigation, notification handling, event management, search content, multiple view presentations, etc features as they’re already implemented inside the rubix-core and every data view inherits these features automatically. Editors provide rich user interface experience with configurable lookups, add/edit on the fly contents, calculated columns, relations, charts, maps, etc. Tool bar provides many useful record transactions with a simple click. We will discuss following advance features with implementation details in future tutorials.
- Implement RULE-BASE filters on content (dynamic and static)
- Implement AUTOMATIC CASCADE DELETE operations on data-sets
- Implement ON_CHANGE events for data columns and provide custom actions
- Implement trigger actions (ON_START, ON_VALIDATE, ON_COMMIT, ON_FAIL) on record events
Unlike many frameworks, the rubix centralize events and methods around the models. The model describes runtime features like search/relation configurations and data /record change events. When new data editors are created by composing existing models, the editor automatically inherit runtime features from the underlying model automatically. This will provide pure model based views that strictly follow with MVC principles.
Role Based Access Control – Grant/Revoke Table/Column Access Privileges
You can follow the links given below to understand in depth powerful enterprise features of rubixs framework.