Category:HowTo

The Openbravo how-tos describe Openbravo development topics using a focused development goal.

The first how-to on creating and packaging a module is important for all other how-tos as it describes the steps which must be done before another how-to can be executed.

When you need to setup your development environment it makes sense to start with the how-to setup the Eclipse IDE howto. It explains how to download and configure the development projects so you can run Openbravo locally on your development machine.

And ofcourse we all should do test-driven development, so make sure to look at this howto: How_to_create_testcases.

All how-tos follow a common structure:

1. Start with the definition of the objective of the how-to
2. Describe the steps of the how-to
3. Present the achieved result of the how-to

Visualization

Openbravo is fully skinnable making it possible to change the colours, icons etc. through your own module. The create a new skin how to explains how to adapt the current visualization in a custom module.

Windows, tabs and fields, reports and alerts

Openbravo Windows can be configured and changed without rebuilding the application, or can be fully customized using a modular approach. There are several how-tos which give a great insight in the customizability of Openbravo ranging from small changes to a window to complete new windows:

• Create or Change a window: how to add a new window to the system through the application dictionary or change an existing one
• How_to_add_a_field_to_a_Window_Tab: describes how to add a new field to an existing window
• How_to_add_a_canvas_field_to_a_Form_or_Grid: add a calculated field or button as a field/column in the Form/Grid
• How to create client side callout onchange function
• How_to_create_a_Callout: a callout adds logic to a field which is executed when the field is accessed/changed in the user interface
• How_to_create_a_Navigation_Bar_Component: with a small coding effort in java and javascript you can add new buttons to the main navigation bar
• How_to_add_a_button_to_the_toolbar: buttons can be added to the toolbar shown in form/grid view for specific windows
• How_to_implement_a_new_main_view: helps you to create a completely new custom view using client side javascript
• How to create a Report: define a new report through the Openbravo user interface
• How_to_create_an_Alert: alerts are used to notify users of changes in business data
• How_to_use_property_fields: how to show related information in a grid/form and to show a child table in the top of a window
• How To Define Display Logic For Tabs: how a tab can be shown or hidden based on field values
• How_to_define_Display_Logic_Evaluated_at_Server_Level: how a field can be hidden in view definition based on preferences at view generation time
• How_to_add_a_rich_text_field_and_column: how to add a rich text field and column
• How_to_add_a_masked_text_field: how to create a masked field in a tab
• How_to_embed_a_Widget_into_a_Window_Tab: widgets can also be included within forms
• How_to_retrieve_parents_node_by_level_in_a_tree : how to retrieve parents node by level in a tree
• How_to_automatically_populate_search_keys : how to Automatically Populate Search Keys
• How_to_create_client_event_handler_actions : how to create client side event handlers (pre/post save)
• How_to_create_jrxml_make_barcode_barberque : how to using jrxml with barbeque

Production

• Post_in_work_effort :Post in work effort

Data model - Database

Openbravo's data model can easily be extended to accomodate for new requirements. Changes in the data model are automatically propagated to the rest of the system. Meaning that important Openbravo functionality is out-of-the-box available for your new tables and columns. For example, your new tables are automatically available through the REST webservices, entities are generated and new windows can be defined.

The following how-tos give insight in the development steps involved in changing the data model:

• How_to_create_a_Table: helps you to add a new table to the system
• How_to_add_Columns_to_a_Table: describes adding new columns to an existing table using modularity
• How_to_create_a_Computed_Column: Openbravo allows you to define columns which are computed using a sql expression, these columns do not exist in the datbase schema but are computed when reading a record from the database.

And there are several how-to's focusing on database oriented development:

• How_to_create_a_Trigger: although most of the logic should be implemented in java using the Data Access Layer, it is still possible to develop logic in the database using triggers, this how-to helps you here
• How_to_create_a_Stored_Procedure: stored procedures are one of the mechanisms Openbravo provides to implement business logic. Stored procedures are executed by the database engine and are implemented in the standard PL/pgSQL (for PostgreSQL) or PL/SQL (for Oracle) language.
• How_to_use_an_Extension_Point: the extension point concept allows a module to extend/plug in their own custom behavior inside existing stored procedures
• How_to_add_a_Constraint: gives an example of adding a constraint to an existing column
• How_to_define_an_on_Create_Default: helpfull for when initializing data when creating new records
• How_to_exclude_Database_Physical_Objects_From_Model: if you want to prevent certain database elements to show up in the application dictionary
• How_to_referece_xml_rounding: if you want add new referece to rounding

Client side development

In Openbravo 3.0 it is now possible to develop code which runs on the client (browser) and adapt the client side logic through modules. Before working through a howto it can make sense to take a look at the documentation on client side development. The following howtos describe different client side development topics:

• How_to_add_a_button_to_the_toolbar: describes how to add a new button with server side actions to the toolbar shown in forms and grids
• How_to_create_a_Navigation_Bar_Component: helps you to add a new component to the main navigation bar shown in the top of the application
• How_to_implement_a_new_main_view: develop a completely new totally custom view which can be opened from the menu and quick launch

Server side development

Openbravo offers a complete environment on the server to implement your own business logic. Openbravo automatically takes care of most infrastructure tasks for you, but you can override existing behavior where needed! There are many how-tos on server side development:

• Data Access Layer articles: the following articles explain how to work with Data Access Layer (DAL)
  • How_to_work_with_the_Data_Access_Layer: a quick introduction into the Data Access Layer
  • How_to_implement_a_business_event_handler: implement your own business logic when entities are updated/deleted/inserted, trigger-like support
  • How_to_develop_a_DAL_background_process: develop a process which is run in the background at preset intervals
  • How_to_do_a_complex_query_using_the_DAL-1: describes how a complex SQL query can be done using HQL
  • How_to_do_a_complex_query_using_the_DAL-2: another example, giving insight in how to translate SQL to HQL
  • How_to_call_a_stored_procedure_from_the_DAL: calling the database in the same transaction as your server side logic
• Process Definition: these how to's explain how different kinds of Process Definitions are implemented:
  • How to create a Standard Process Definition: how to create a Standard Process definition with parameter defined in Application Dictionary
  • How_to_create_a_Pick_and_Execute_Process: how to create a Pick and Execute process
  • How_to_create_a_Manual_UI_Process: how to create a Manual UI Process
  • How_to_create_a_Multi_Selector: how to create a Multi Selector to be used as parameter in a Process Definition.
  • How_to_create_a_Report_using_Process_Definition
• Background Processes: how background processes are created.
  • How_to_create_a_Background_Process: describes how the class defined in the previous how-to can be scheduled through the Openbravo user interface
  • How_to_create_a_Java_Process: describes the structure of a java class which can be run as a process in the background
• Trees: these how to's explain how to create new tree types within modules:
  • How_to_Define_a_Table_as_a_Tree: allows to show the Tree Grid View and makes the table available to create a Tree Selector.
  • How_to_Create_a_Tree_Selector: allows to define a reference to a Tree Table.
  • How_to_Restrict_the_Movements_of_Nodes_in_a_Tree: defines the logic to handle the hierarchical structure in a tree.
  • How_to_Create_a_Custom_Tree: allows to create tree having a different data structure to the default ones (AD_Tree_Node or Link to Parent).
• Tables: tables are used as origin of data to populate grids in standard windows and processes. By default they are based on database tables. But in some cases it makes sense to implement a different definition:
  • How_to_create_a_Table: standard one based on a database table
  • How_to_create_a_HQL_Based_Table: tables defined based on a query.
  • How_to_Create_a_Table_Based_on_a_User_Defined_Datasource: completelly implemented in Java, it allows to retrieve data from any source.
  • How_To_Using_Auxiliary_Input: Using Auxiliary Input . So that the default value can be adjusted according to the tabs in windows

• How_to_implement_a_new_Discount_and_Promotion_Type: how to define and implement a new Discount and Promotion Type.
• How to Create Your Own Import Process with IDL: how to implement an IDL process.
• How_to_send_emails_on_events: how to send events to send email and how to listen to those events.
• How_to_implement_Create_New_In_Selectors: explains how to implement a selector that is also able to create new recods.

Web services

Openbravo automatically provides webservices on the complete data model. If you add new tables/columns to Openbravo then they are automatically available through the REST webservices. Openbravo supports multiple technologies: XML and JSON. You can also add new webservices to Openbravo, this is explained in this how-to.

Modularity

Openbravo provides a complete infrastructure to work with modules and package your modules including related data. Several related topics are discussed in the

• How_To_Create_and_Package_a_Module: helps you to package your functionality in a module
• How_to_publish_a_Module: to make your modules available to the Openbravo community
• How_to_create_a_Dataset: describes how to add data to your module
• How_To_Create_a_Configuration_Script: to adapt existing modules, or even the core module
• How_to_create_build_validations_and_module_scripts: create scripts which validate the module environment or scripts that are run when a module is installed

Migration - Classic User Interface

Openbravo 2.50 is widely used and a common scenario is to upgrade from 2.50 to 3.00. At Openbravo we have paid specific attention to support existing modules, logic and concepts. This how to helps you to migrate your existing code from 2.50 to 3.00.

Openbravo 3.00 allows you to run specific windows in classic mode within the new layout or even still run the application completely in classic mode, see this how-to.

The dbsourcemanager is a critical component of Openbravo. It is responsible for updating the database when installing modules and upgrading. As Openbravo continuously improves the dbsourcemanager it can be very helpfull to use the latest version of this component in older versions of Openbravo. This how-to describes how to do this.

Other Topics

Articles in this section cover miscellaneous topics related to Openbravo development:

• How_To_Log. Guides about how and what to log.
• How To Configure Log. Explains how log file is configured and how to change debug level for a class/package.
• How_To_Upgrade_a_Library. Describes the process to upgrade or include a new library.