Born To DeBug

TaskFlow managed Bean properties.Referring to a Bean instance from another Bean instance using task flows. ADF 11g

2011-12-17T10:14:00.000-08:00

Hi,
In this example we are going to show how to access bean instances from other bean instances using task flows.
Based on a question in the OTN forum:
https://forums.oracle.com/forums/thread.jspa?threadID=2321268&tstart=0

It might sound a bit strange to some, but task flows can be quite helpful for that matter.

Download Sample Application.

What is the purpose of task flows?

According to documentation:
http://docs.oracle.com/cd/E24382_01/web.1112/e16182/taskflows.htm#BABFBAFA

ADF task flows provide a modular approach for defining control flow in a Fusion web application.

Among other things, Task Flows provide the ability to instantiate beans with the appropriate scope.

According to documentation:

http://docs.oracle.com/cd/E24382_01/web.1112/e16182/web_getstarted.htm#CACCFIII

In an application that uses ADF data binding and ADF task flows, managed beans are registered in different configuration files from those used for a standard JSF application. In a standard JSF application, managed beans are registered in the faces-config.xml configuration file. In a Fusion web application, managed beans can be registered in the faces-config.xml file, the adfc-config.xml file, or a task flow definition file. Which configuration file you use to register a managed bean depends on what will need to access that bean, whether or not it needs to be customized at runtime, what the bean's scope is, and in what order all the beans in the application need to be instantiated.

So, basically, this means that, we can declare managed beans with a specific scope per taskFlow.
If you check the documentation's images regarding task flows and managed beans:

You will notice that each managed Bean has it's own properties.

This gives us the ability to create, as declarative as possible, connections between instances of beans.

This of course needs an understanding of the bean scopes in order to have a proper implementation.
Here is the documentation about scopes
http://docs.oracle.com/cd/E15523_01/web.1111/b31974/taskflows.htm#CHDFAIGC
http://docs.oracle.com/cd/E24382_01/web.1112/e16182/adf_lifecycle.htm

For persistent readers and investigators on bean scopes. Please refer to a very interesting discussion on EMG
http://groups.google.com/group/adf-methodology/browse_thread/thread/c7427b4b0b69766d

Lets move on to our scenario:
For the sake of this example, we are going to create a page template. Inside this page template we are going to place a menuBar with some menus and menuItems.

Then we are going to bind some of the menus to a backing bean. of scope View. Why we want to have it in a View Scope? Well, this is going to be another detailed post about scopes. For now, lets say that we want to keep the binding alive during the life of the page (ViewPort)
We are going to create a new Java Class and we are going to name her ( I prefer to thing of it as a she :) )
TemplateBean. Then we are going to create bindings to some of the menus:

templateBean

template page:

At this point, if we check our adfc-config.xml file we will see that the appropriate entry of the bean is written:

Next, we are going to create a taskflow and a page inside it. That page is going to use the previously mentioned template.

Creating the page based on the previously created template:

We are going to use the HR Schema for this example and the Employees table. We will generate the appropriate BC with the wizard of JDeveloper:

Up to now, we have completed the following:

1) Generated the Business Components.

2) Created a page template with some menus and menu items and binded some menus with a backing bean with scope of type View.

3) Created a task flow and a page in it that is using this template.

In the new page we are going to drag and drop the employees iterator to the page as a form:

There is an additional button with the rollback operation as you will see in the above picture.
This is added during the making of the sample application.

For this example application, we are going to have the following logic:

When the user changes the salary of an employee, menu1 will be disabled if the new value is greater than 100. if the value is lower or equal to 100.

NOTE: For the simplicity of this example we are going to have the menus enabled during query. The above scenario will take place only when changing values. This might not seem a real case scenario but the goal is to demonstrate the features of taks flows and their injection of bean instances to other instances.

Now, lets think about our case a bit... We have a template with some menus.. This template.. well is a template.. and for that reason it can be used in many cases and pages.. So it is not wise to bind it with a specific use case right? We have to keep the template menus loose and adaptive to any page..
We already have bindings to a backing bean of those menus... Why not use them then?

We are going to create a value change listener method for the salary attribute of our page:

With the help of the wizard, we crated a managed bean with the Value Change Listener method for the salary attribute.

If we check the task flow properties now, we will see that there is a new entry there:

According to our scenario, we want to check the value of the salary attribute and disable the menu1 which resides in the template we created previously.

And here comes the magic.. All we have to do is to create a property in the bean of the page with the same type as the template bean, implement our logic and make the appropriate reference in the task flow...

Lets implement our Value Change Listener logic:

The only thing left now, is to reference to the appropriate TemplateBean instance.
This can be easily done in our task flow:

As you can see from the above picture, we create another managed Bean in our task flow. The one for the templateBean.
Then, after selecting the aRequestBean, we created a new property and placed the correct name of the property, class and the instance we want to use.

Everything else will be handled by the framework.

It doesnt get more declarative than this!

And that is it!

Download Sample Application.

Regards.

Validator or ValueChangeListener. ADF 11g lifeCycle

2011-12-13T05:10:00.000-08:00

Hi,

This is an example that will demonstrate the lifeCycle phases involved with validations and ValueChangeEvents.
There is some confusion on which is triggered first and when they are triggered.
This post will try to clear things a bit.
Even though the documentation is sufficient enough, this post will work as a helper by pointing only the important elements in order to understand the process as a general concept.

Download Sample Application.

According to the documentation:

http://docs.oracle.com/cd/E15523_01/web.1111/b31973/af_lifecycle.htm

Validations should fire first and then ValueChangeEvents should be issued:

The two important phases in our case are :

Apply Request Values and Process Validations.

According to Documentation:

Apply Request Values: Each component in the tree extracts new values from the request parameters (using its decode method) and stores the values locally. Most associated events are queued for later processing. If a component has its immediate attribute set to true, then the validation, the conversion, and the events associated with the component are processed during this phase. For more information, see Section 4.2, "Using the Immediate Attribute."

Process Validations: Local values of components are converted from the input type to the underlying data type. If the converter fails, this phase continues to completion (all remaining converters, validators, and required checks are run), but at completion, the lifecycle jumps to the Render Response phase.
If there are no failures, the required attribute on the component is checked. If the value is true, and the associated field contains a value, then any associated validators are run. If the value is true and there is no field value, this phase completes (all remaining validators are executed), but the lifecycle jumps to the Render Response phase. If the value is false, the phase completes, unless no value is entered, in which case no validation is run. For more information about conversion and validation, see Chapter 6, "Validating and Converting Input."

What we understand here is that, for input components, by default, the validations are going to be fired in the Process Validations phase. Furthermore, they have a specific order:

1) converters
2) required checks (check if it is required)
3) validators

NOTE: Of course there are some other cases were the required checks are not fired.. but the above is the general idea.

As you may have noticed, in the Apply Request Values phase, it is mentioned that if the component has it's immediate property to true, then the validations will take place in tha phase.

Which means, that they are not skipped.

What we understand here is that validations will fire no matter if the component is immediate =true or not.

But when does the ValueChangeEvent is triggered?

Again, according to the documentation:

ValueChangeEvent is an intermediate phase between Process Validations and and updae model Values.

This means that ValueChangeListener are invoked right after validations. It does not matter if the component is immediate true or not.

The difference lays in the phase those operations will be executed.

The case of the commandButton:

CommandButtons will trigger the validations and valueChangelisteners of inputComponent while pressed. It is the same case weither the the button is partialSubmit and the inputComponent partialTriggered by the button, or the button is not partialSubmit.

If we set the commandButton to immediate true, then some phases are skipped:

According to documentation:

When actionSource c omponents (such as a commandButton) are set to immediate, events are delivered in the Apply Request Values phase instead of in the Invoke Application phase. The actionListener handler then calls the Render Response phase, and the validation and model update phases are skipped.

This means that if the button is set to immediate only the ApplyRequestValues phase will be invoked, the Process Validations phase will be skipped.

So, if we will have a selectOneChoice component with autoSubmit=false and immediate=false and a commandButton with immediate=true.

According to what we know so far, the commandButton will invoke the ApplyRequestValues phase and then render response phase. Our selectOneChoise, will invoke the validation and ValueChangeListener in the Process Validations phase.. which in our case, will not be invoked.

So we are bypassing everything...

If we want to invoke validators and valueChangeListeners while having the button immediate=true, we will have to have the selectOneChoice to immediate=true as well!

why? simply because, according to documentation, while having the input component immediate=true, all validators and valuChangeListeners will be shifted to ApplyRequestValues. Which is exactly what we want.

Conclusion: Validators are executed before ValueChangeListeners. They are executed even if the input component is immediate=true. The only change is the which phase they will be executed in.
The combination of commandButton can bypass he validations and valuechangelisteners if it set to immediate=true. We can still have validations and valueChangeListeners triggered if we have the inputComponent to immediate=true. Since the validations and ValueChangelisteners will be triggered in a different phase and more specifically, they will be triggered in the ApplyRequestValues phase.

Well, this is it. Of Course we could continue investigating more programmatic ways and workarounds but this would be out of the scope of this post

Download Sample Application.

Regards.

Create Description Attribute of an LOV Attribute. Using Reference Entities. ADF BC 11g

2011-12-08T06:22:00.001-08:00

Hi,
In this example we are going to create a simple LOV and we are going to have an additional attribute as the description of that LOV.

Download Sample Application.

In more detail, we are going to use two entities in one View Object. The first entity will be our updatable entity. The second entity is going to be the reference Entity. The role of the second entity is to provide a description of the id if the first entity.

So, basically we are going to have an LOV which will display meaningles ids and another attribute from another entity that will display the description of that id. The description will be a meaningfull message to the user.
For this example we are going to use the HR Schema and the following tables:

Locations,
Countries.

We want to show a form of Locations and we want to have the Country Id from an LOV.

First we will create the Business Components with the wizard of JDeveloper.

This will produce us all the BC:

We simply left the Location View Object only. We removed all other views in the Application module.
We want to show the Country name for the corresponding Country Id.
Additionally we want to have the CountryId as an LOV.
Lets Create the LOV

First, we locate the attribute we want, CountryId in our case in the LocationsView vo and we press the plus sign in the LOV section. On the new window, we press the plus sign again in order to set the List Data Source. In the new window(again) we shuttle on the right the CountriesView vo and we press ok:

Next, we have to map the attributes we want to associate:

Last but not list, is the apperance of the List of the Values. We select the UI Hints in the same window and we shuttle the attributes we want to have them displayed in the list of values. Additionally, we set the type of the List to Input Text with List of Values.

And that is about it. our lov is created. The next step is to associate our Locations entity with our Countries entities in the Same viewObject, the LocationsView.
We go to LocationsView and more specifically in the Data Model. We shuttle the Countries entity to the right and we will see that the association is applied immediatelly. We select the join to be outer join just in the case of no data.

Now that we have our entity, we are going to shuttle our desired attribute, which is the CountryName. Now that we have added the Countries entity we can shuttle CountryName from that entity. If we havent done that, we would not be able to show this attribute in the LocationsView.

And we press OK.
As you might have noticed above, we shuttled only one attribute, the CountryName and the PK is additionally shuttled. This is needed because the framework needs to update the association for every new value in the main CountryId from the Locations Entity.

From the BC point of view, all the mandatory steps are done.
Off to create our jspx!
For this example we are going to create a simple jspx form to our unbounded task flow. We are simply going to drag and drop our LocationsView iterator from the datacontrol to our jspx as a form:

In the new window we are going to select the attributes that we want to display in our form. As you will see in the wizard, we will have the additiona CountryId1 attribute from the reference entity. we will remove that because we dont want to have duplicate components.
NOTE: we could prevent this in the BC layer and the Display Hint attribute. The scope of this example is simply illustrative and aims to demonstrate the description functionality.

As you see, we have the CountryId1 attribute to be displayed. We simply select it and press the red x button to remove it from the list. Another important think to notice here is that the wizard understood from the BC that the type of the List for the CountryId is List of Values and immediatelly converts it to the corresponding component.
We press OK and after adding some additional buttons with operations we have our form.

But we are not quite there... a few adjustments left.
In order to properly display the CountryName in every change of the CountryId we have to make the CountryId LOV to AutoSubmit=true and place partialTriggers to the CountryName. The partial Trigger will be the id of the CountryId LOV component.

AutoSubmit:

PartialTriggers:

And That is it!
Every time we change value in our CountryId the CountryName will be updated accordingly.

Download Sample Application.

Regards.

Programmatically create new row of View Object in Application Module. ADF bc 11g

2011-11-23T03:36:00.001-08:00

Hi,

this is yet another example of showing hwo to create a new row of view object in an Application Module method.

Download Sample Application.

We will use the Departments table of the HR Schema in this example.
First we are generating the BC through the JDeveloper wizard.

Then, we generate the java class of the Application Module:

Inside the java class we place the following code:

The usage of this method varies.. In this example we are going to use page button in a page.

We have to do one more thing for that, expose our method in the client interface of the Application Module:
We go to the java section of the Application module and we press the pencil icon in the client panel:
In the new window, we select our method and shuttle it to right panel:

For that we create a page in our unbounded task flow:

Then we double click on the page, this will show us a wizard to help us create the page. This happens the first time only, the time that we want to actually generate the page.

In this example, we are going to use a jspx..

Then, from the dataControls, we are draging and droping the DepartmentsView onto the page as a form:

we just accept the default options from the wizard:

and press ok. The result looks something like this:

Now, what we want to create a button that will call our Application Module method.
All we have to do is to drag and drop our method from the dataControl and select ADF Button:

And That is it.
If we run the page now, and press the button a new row will be shown.

Download Sample Application.

Master-Detail-Detail. Using Tree Table and Table. Using Target Data Source featrue. ADF BC 11g

2011-11-18T07:09:00.000-08:00

Hi,
This is an example demonstrating the usage of treeTable and table of ADF all together.

Download Sample Application.

We are going to use the HR Schema and more specifically the following tables:
Departmens,
Employees,
EmployeesViewDetails.

Departments and Employees are going to be the Master detail that will be displayed in the Tree Table
the EmployeesViewDetails will be the detail table shown below the tree Table.

After generating the appropriate Business Components through JDeveloper wizard, we are going to create an additional association and a viewLink.
Because the EmployeesViewDetails is a database view, the associations are not provided by JDeveloper wizard.
Furthermore, we are changing the the Primary Key of the EmployeesViewDetails from RowId to EmployeeId.

Association:

ViewLink based on that association:

Finally we reach to a point where we will create the Application Module hierarchy:
This is the tricky part. at this point, we have to understand two things:
One, we are going to use the Target Data Source feature. This feature according to the following documents
http://www.oracle.com/technetwork/developer-tools/adf/master-detail-moredetail-154767.html

http://www.oracle.com/technetwork/developer-tools/adf/learnmore/sept2011-otn-harvest-508189.pdf

needs to point value that corresponds to a key of the other iterator..
Additionally the JDeveloper documentation for this feature says:

So, what we have to do is to point the right value to the right Key..

Two, Our hierarchy is not going to be the following:

Is going to be the following:

Now, why is that???
Simply because, we want to use the target Data Source feature, and for that reason, we need to map the same key attributes.
Further more, we do not want to show the details on our tree.... We just want to show it on a separate table.

The concept is simple: We have to have the same keys to synchronize properly.
Now, to our case, apparently, we cannot synchronize Employees and EmployeesViewDetails directly, for the simplest reason that we are on a master-detail-detail situation...

In fact, our example is a very special case, because it is a pure coincidence that Employees and EmployeeViewDetails have the same attribute as a primary key.

According to documentation, a draft and general explanation would be the following:

the targeted Data Source iterator, will find a row where it's key value is the same as the key value of the selected row of the iterator that invokes the target Data Source iterator and will set this row to current.

well, reading it again, it is not simple at all!! :D
ok lets try again...

The targeted iterator will simply search for a row in the list and make it current.
The key of that row, will have the same value as the key of the selected row in the tree.

hmm... still not good..

The iterator that uses the target Data Source feature, will force the specified iterator to find a row with the same key value as the previous one.

I give up.... :D
Well, so if we had just added the EmployeesViewDetail without having it as a detail under Employees... we should have seen all employees and every time we selected an employee, the employeesViewDetail table would simply change the current row.
And of course, we do not want that..
So, the best approach is the one showed in the screen.
Why? Well, when we select an employee from the tree, the target Data Source feature will invoke the other employees iterator, which in turn will invoke the employeesViewDetails iterator to refresh because, after all, it is a detail right?..

Next, we are going to Create our page.
First, we will create a task flow and a jspx on it.
Onto jspx, we drag and drop the departments Iterator from the dataControl and we select, treeTable.
Then, we add a rule for the Employees as shown in the Screen below.

For Departments rule, we shuttle DepartmentId and Department Name attributes.
For Employees rule, we shuttle EmployeesId, firstName and lastName.
Next, we surround our treeTable with a panelCollection. We Simply right click on the tree table component and we select panelCollection.

Since treeTable component, does not create other than the node column, we will create them ourselves.

After that, we surround the panelCollection with a panelGroupLayout with type Scroll. This will be the parent Container of both, our treeTable and table.

At this point, we have to apply the target Data Source feature. As we explained earlier, we are going to set this feature for the Employees detail iterator of the Departments master iterator. This Employees iterator will point to "other" Employees iterator.
But first, we have to add this iterator. So in our page definition we add the other Employees as iterator.

Then, we are going to set our Target Data Source value.
We simply select the tree of Departments and then the rule of Employees,
after that, we expand the target data source option and open the help wizard to choose our iterator. The iterator would be the "other" Employees iterator.

Now, every time we select an employee from our tree, the "other" employees iterator will change the current row to the same as the selected in the tree.
All we have to do now is to drag and drop the EmployeesViewDetails from our Data Control

After that, we surround the table with a panelCollection (the usual best practice..) and set partial triggers to table from the tree table.

And that is it!
When you run the page you will see a row in the empsDetailsView ofcourse, since it is querying, but this is not the scope of this post.. When ever you select an employee the table will be refreshed with the employee's details.

Download Sample Application

Regards.

Create new Record after Search Criteria (Using Search Form) returns no Results. ADF BC 11g

2011-11-16T13:12:00.000-08:00

Hi,

In this post, we are going to immediately create a row when we have no search results.
This is usually the case in oracle forms. Forms have a different out of the box approach.
When a Form opens, it open in a mixed mode. This means that no data are fetched. The user is able to insert some data and press enter, if there are no data in the DB with a given primary key, then, Forms are entering insert mode. This means that they create a new row. If the data are there, the record is Queried.

We are going to do the same with the following example.

Download Sample Application.

We will use, as usual, the HR schema of Oracle XE and more specifically we are going to use the Regions table. We choose the Regions table because it is the simplest table regarding dependencies and fits the scope of this example.

First, we generate the Business Components from tables with the help of JDeveloper's wizard.
Next, we are going to use the Search Form feature ADF BC provides.
We create a page called index.
So, we drag and drop the Regions iterator onto our page and

Ok. After dropping the Search Form, we can simply run and test our page. We will see that the default mode of the page is the fetch data mode. In other words, it queries and shows the first row.
If we press the find button, the page will enter into the find mode, where all fields are search criteria.
We can insert some data and press the execute button. Then the execute operation will be invoked and search for records that have those data we entered earlier.

Well, this out of the box functionality is not exactly what we want... So lets try to change it a bit.
First, let's try to open the page in find mode.
To do that, we are going to create an invoke action, as mentioned in this post:

http://dstas.blogspot.com/2010/09/adf-11g-methodaction-and-invokeaction.html

Our invoke action is going to invoke the Find Operation.
Additionally we are going to change the refresh property. Our Refresh property is going to be: prepareModel
For further reading please check the following links:

http://groundside.com/resources/DuncanMills/S298736_bindings.pdf
http://download.oracle.com/docs/html/B25947_01/bcdcpal005.htm#sthref837

Additionally, we are going to set a Refresh Condition. This is to avoid executing the invokeAction in every postBack.

If we now run and test our page, we will see that our page is entering in find mode! We are ready to set criteria and press execute!
Up to now, we are half way through. We have to enter in insert mode.
When? right after knowing that the execute operation returned no results.

So, at this point we can understand when we should invoke an insert operation. When our iterator has no rows.. No rows can be produced by many cases, one of them is when we enter non existing criteria and search.. Another reason might be the fact that there are not any records in the DB... What ever the case, we are fully covered.
Since we are opening the page in find mode.. we have to search..
Additionally, it would be great if we could enter in insert mode even if we issue a rollback and the DB has no rows..

Last but no least, is that we want to create a new row if the search has no results, but, we want to use those search criteria values in the new row.

For that, we are going to alter a bit the Execute operation. We are going to create our own actionListener method.
But First, we have to apply our logic. Our logic says that if we do not have any records fetched by the execute operation, we should immediately create a new Row, with initial values, those values we did the execute on the first place.
One thing at the time:

Getting the values from find mode:
We will override the create(AttributeList attributeList) method of the Regions View Row java class:

Then, we will create a method in our application module, that will check if there are any rows fetched (Since it will be invoked right after the Execute) and if not, it will create a new Row in the Regions view Object. We do not have to worry about the initial values since we have done some coding in the create method as mentioned above.

Then we expose this method to the client interface and add it as a methodAction in the pageDef of the

And that is it.
When we run the page, it will open in find mode. If we set criteria that will bring any data, the page will enter in insert mode with initial values those data.

Download Sample Application.

Regards.

Conditionally Displaying Table Records Based on Another records's attribute value. Conditionally making required attributes of those rows. ADF BC 11g

2011-11-16T04:49:00.001-08:00

Hi,

In this example we are going to create a small application demonstrating the following case:

Using a table, a value of an attribute of a row, will determine if some other rows will be visible or not.
Furthemore, on those rows, specific attributes will be required or not.

Download Sample Application.

Lets get into the details.
We have a table, that we want to filter it's data. Ok, so far so good. We can do that by using the iterator's filter property in the pageDef. Additionally we are going to use a transient attribute that will keep the value we want to filter with.

Then, we want to have some attributes of those hidden rows to be mandatory only when those rows are visible.
The condition that will determine wether those attributes will be required or not will be based on a value of an attribute of another row.

Example.

We Have Row A, Row B, Row C and Row D which they are visible.
We have Row E, Row F which are not visible.

When we will set value to attribute d of Row D, row E and row F will be visible with the same attributes to be required.

In fact we are going to make things a bit more difficult. We want to have validation erros only when pressing commit. This is due to ease of use reasons. Simply put, we do not want mandatory field messages to be thrown every time we change a row.
Last but not least, the attribute that will determine the visibility of other rows, will be a Yes/No radio Button.
So, this means that, when the user selects Yes on a RadioButton of a row, there will be some logic that will make other, specific rows, be visible and make their radioButtons be required.

The logic that will make the rows visible and the radio required is purelly in the scope of business requirements. In this example we are going to use a simple case. The scope of this post is to demonstrate the implementation in order to achieve this functionality.

We are going to create a table in the HR Schema.

The Sql Script is already included in the application.
Download the application and find the script called SampleData.sql

As you can see from the table, there is not something weird.. Columns may have different names depending on requirements.
After we run the script, we create our BC from JDeveloper wizard.

And we have the following BCs:

It is quite obvious that attribute SelectRadio is going to be our radioGroup of yes/no. So we are going to add a List of Values to this attribute. The List of Values is going to be a new view object with static values.
The attributes are going to be the following:
ID,VALUE.

With the following DATA:

We set the Y and N just for simplycity.
After finishing the creation of the static VO we create an LOV in our sample View Object:

Then we just add the Static View object as an accessor.
We map the Selectradio attribute with the selectradio attribute with the choice attribute. and that is it.

Ok, so far we have created the VO with an LOV.

What we want now is to make the radio Group conditionally required. As we see in the db table. it is not required. We could have a entity validation method. But in this example we are going to try something different. We are going to use the required property of the radioButton.

Since, we will have another row determining the required property, we are going to follow this approach:

We will place a transient attribute in our viewObject called ReqRadio. This attribute is going to determine if this the RadioButton is going to be required or not. So we add this attribute:

Now, the only thing left is to place the logic where this transient attribute will get a value.
Since a radioButton will determine if another radioButton of another row will be mandatory, we will have to do an iteration over all those rows that are dependent of that row.
For this example, we keep things simple. we have a column in our table in the DB which is called, typeofdata. As you will see in the rows, we have a record that has a value of MasterFormC and others that have value of formC. This example logic says that all rows that have formC and the radioButton of MasterFormC is with value Y, then, those records will have their radioButton required.

The simplest way to do that is to create a ViewCriteria in our ViewObject that we will use it to filter our rows. The Execution Mode will be set to memory

As you can see from the screen above, we set the typeofdata to be equal to "formC".
Next, we are going to create a method in our Application Module that will do the following:
First, we will check if the typeofdata is MasterFormC and then:
Will get the ViewCriteria of the View Object, apply it, get the RowSetIterator and set value to the transient attribute ReqRadio of each record.
The value to be set will be given as a parameter.

As you can see from the code, we return a message that we will use it later in our page.
Next, we expose this method to the client interface of our AM.

Next, we will create our page and we will drag and drop our table onto the page:

Then, we will surround our table with a panelCollection container and insert Commit and RollBack operations as toolbar Buttons in the toolbar which will reside in the toolbar facet of the panelCollection

As we mentioned earlier, we do not want to have validation errors every time we change a row... For that reason, we are gong to set the immediate property of the table to true.

The last thing to do onthe UI for the RadioButton is the requiredProperty. the required Property will be based on the value of the reqRadio:

Now that we have a pageDef, we will expose our AM method as a methodAction:

Additionally, we want to filter our iterator with all those rows that can be visible due to our business logic.
For that, we are going to create a transient attribute that will be called IsVisible. We are going to change a bit the code in the getter of this attribute (we have to create the ViewRowImpl jav class of our view object first and select the generateAccessors property):

With the above code, we will know if this row is to be visible or not.
Onto our pageDefinition:
in the pageDef, we select the iterator of our View Object and we wil enable the filtering:

Now we will be able to filter our table properly.
Last but not least, is our radioButton. We set it to autoSubmit=true in the page. We then create a valueChangeListener for our RadioButton.
Additionally we will create a popup with a dialog and an outputFormatted text with value of a pageFlowScope variable.

Then, we create bindings for the popup and the table. This will allow us to programmatically show the popup and partialTarget our table.

And That is it.

If you run the application You will see that initially, the data are filtered and depending on the value of the MasterFormC typeofdata, the rows are becoming visible and required. Additionally there is a popup Shown when the rows are becoming visible notifying the user that the following rows must have a value on their radioButtons.

Download Sample Application.

Regards.

prepareModel, renderModel and the lifeCycle. ADF 11g

2011-11-12T06:46:00.001-08:00

Hi,

This is a small post explaining a bit the difference of prepareModel and renderModel options in the refresh property of an InvokeAction.

Those two refresh properties are very self explanatory..

The only difference is the following:

prepareModel: Is executed right after initContext is executed.

renderModel: Is executed right after metadataCommit is executed.

In other words, prepareModel is executed right before any validations or posts or updates take place. Basically, is executed after initContext and before everything else. So, this property is useful for actions and methods that do not require any validation process or updates. It will be executed before all that.

RenderModel, on the other hand, is executed after all those steps are done and passed. So we can use this refresh option when our business logic, or our logic, claims that all steps of the life Cycle should be done.

I understand that this is not the full description nor it is the official documentation. Besides, there is the official documentation for that. But, those lines can be used in everyday developing and I believe that can help in understanding which property we should choose depending on the case.

(Figure 20-1 Lifecycle of a Web Page Request Using JSF and Oracle ADF from
online documentation regarding ADF LifeCycle)

(Figure 20-2 Lifecycle of a Page Request in a Fusion Web Application from online documentation regarding ADF LifeCycle)

Regards.

References:

10.5.5.3 Correctly Configuring Refresh Property of InvokeAction Executables

20 Understanding the Fusion Page Lifecycle

http://groundside.com/resources/DuncanMills/S298736_bindings.pdf

Master Detail CRUD operations with Regions ADF 11g

2011-11-10T10:10:00.000-08:00

Hi,

This is an example that demonstrates how to create a Master Detail relationship between tables by using Regions. The main purpose of regions is the notion of reusability. With regions and bounded task flows we can reuse our pages into many other pages keeping the same functionality and having a more cleaner approach.

Download the Sample Application.

For this example we are going to use only one Model project and keep things simple.
We are going to create our Business Components through JDeveloper and it's wizards.
We are using Master Detail for Departments and Employees.

So, we are going to create two Bounded Task Flows that use fragments.
One for the Departments
One for the employees.

In each bounded task flow we drag and drop a view and place the appropriate names of departments and employees.

Then in the unbounded flow we create a jspx that will have two Regions defined.
One for the Department BTF
One for the Employees BTF

For Departments we are going to drag and drop the Departments iterator as a form with navigation buttons and submit button. Additionally, we add the createInsert and Delete Operation buttons next to submit

We do the same with employees. The only difference here is that we drop an editable table and not a form. Additionally we drag it from the hierarchy and not the alone one in our Data Control. This means that we drag the detailed employees.

Next, we are going to create an index page in our unbounded task flow that will contain our Bounded Task Flows as regions.

In order to that, after we created the index page, we simply drag and drop each Bounded Task Flow as a Region

We do the same for the Employees Bounded Task Flow.
Up to now, we have our hierarchy done and well placed. Since we share the same application module instance, we are good to go!!
All that is left now is to place commit and rollback buttons in our Departments fragment and we are done!
For the rollback button we have to make a specific adjustment:
The emps region needs to be refreshed and indicate that the rollback is performed. For this reason we are going to set the refresh property as follows:

So, what we do here is, to set a refresh condition on our detail region. What we say here is, refresh emps fragment when the dept fragments is refreshed.

NOTE: this is a simple application demonstrating the ease of use of Regions. It is not intended to cover all aspects of regions.

Download the Sample Application.

Regards.

Validate Entity or Validate Entity Attribute when using af:table or af:treetable ? ADF BC 11g

2011-11-08T12:45:00.000-08:00

Hi,

With this post we are going to investigate which validation is better to use for a specific circumstance. The Entity Validation or the Entity Attribute Validation for the specific case of af:table UI component. Here is our case:

We have rows that have two input fields that they depend on each other.
For instance, in this example we are going to use the HR schema of Oracle XE, we are going to have a logic that says that we cannot have an employee with firstName or PhoneNbr. But we can have an employee without firstName and phone Nbr. In other words, we have to set values to both fields or to none of them.

Download Sample Application.

NOTE: This is an example test case and this example might not actually fit any business logic. It is purely illustrative and the scope of this post is to investigate a best practice on the validation approach of two depended fields.

So, what we have now is a business rule. This rule says that we can have an employee with no firstName and no phoneNbr, but, if we must set values, we have to set to both of them.

OK, for this rule we are going to develop both cases for our investigation.

One with Entity Attribute Validations. Method A

One with Entity Validation. Method B

For the simplicity of this example, we will create two separate entities of the employees table and two separate views.

Method A:

Since it is not just a mandatory property and has some logic, for this example we are going to use a method type of validation.

We accept the default name of the method, as proposed from JDeveloper wizard.

In the failure handling section we set a message that corresponds to our business logic:

We do exactly the same ( with a slight difference in the failure handling message) for the PhoneNbr attribute.

For the phoneNbr we have to check the the checkBox in order to generate the method. This is because there is already one method.

Next, we have to right some code in the methods:
NOTE: in case your java class has no accessors, go to the java section of your entity, press the pencil and select the Create Accessors checkBox

The methods for each attribute:

Method B:
For method B, we will do the same process but only once, with one method. Because we are going to create one EntityValidation method. We are using EntityB. The process is the same, but the starting point is different:

Now, we have only one method so we will simply put both conditions of the other entity class into this method:

All we have to do now, is to create two separate pages, each one will have a view Object (already created by the JDeveloper wizard ). All we have to do after the pages, is to... test...

We create the pages and we drag and drop a view to a page:

we set the FirstName and the PhoneNbr as autoSubmit true.

If you run the application and press the first button, we will be navigated to to method A page where we have the entity attribute validations. There, if go and delete the value of the FirstName in the first row, press tab, we will get an error message:

The above is correct. It is exactly what we wanted. Lets go and delete the PhoneNbr of the same row,
Normally, we should not get any error message right? At least, this is the visual logical thought..
However, we still get the error...

This is very logical and expected behavior. Since validations are failed, no values are set in the attributes, thus our method in the second attribute handles the FirstName with it's "old" value which is not old because it has never changed.

Now, if we check the same in the second page, we will not receive the same behavior. We will have the accepted one. The difference here is that the Entity Validation is triggered when the whole entity is submitted. This happened when we change a row by clicking to another record in the table or by pressing a button.

So this investigation and example clearly indicates that when it comes to depended attributes and their validations, the correct declarative way is to use an Entity Validation and not an Entity Attribute Validation

Reference:
http://download.oracle.com/docs/cd/E24382_01/web.1112/e16182/bcvalidation.htm#ADFFD407

Download Sample Application.

Regards.

af:switcher and af:goLink Example ADF 11g

2011-11-08T02:49:00.000-08:00

Hi,

Here is an example demonstrating how to conditionally have a goLink on your jspx.
The case is simple, based on some value, the goLink should not be a goLink and be an output text.
In other words, how to implement a conditional goLink.
af:switcher comes into the game. With af:switcher we can have facets. Each facet has a name. The switcher will determine which facet will be rendered or not. So, all we have to do is to write the appropriate condition. Check the Following screen:

As you can see in the above screen, the facetName property of the switcher can accept EL and infact what we did here, to conditionally render a facet of the switcher. The translation of the facetName is the following:

#{aVariableHere eq 'aVale' ? 'GOLINK' : 'OUTPUTTEXT'}

means:

"if the aVariableHere equals to aValue then (?) render the facet with name GOLINK else (:) render the facet with name OUTPUTTEXT.

In this example, the values are strictly illustrative, they should change depending on bussiness logic.

Regards.

Drag And Drop Records Between Tables. ADF BC 11g

2011-11-04T12:44:00.000-07:00

Hi
This is a small example of the following case:

Drag and Drop records from one table to another.

More Specifically, we are going to create a small application that will give us the ability to drag and drop employees to the desired department. The result to this will be to update the information of that employee. We are going to present each department and it's employees separately and we will be able to drag and drop employees from one department to another...
For this simple case, we are going to use 2 departments with their corresponding employees.

Download the Sample Application (JDeveloper 11.1.2.1.0).

We generate the appropriate business components for our little example. The business components are:
Entities: Departments, Employees.
View Objects: Departments Employees.

Furthermore, all the appropriate entity associations and viewlinks are generated by the JDeveloper wizard.
Once we have that, we have to concider what else of development is left to be done on the Model layer.
Our use case describes the "move" of one or more employees from one department to another department. This means that each employee, of those draged and droped, will update there DepartmentId value.
So, what we have to do now, is to provide answers to the following logical and technical questions:

1) How are we going to know which employees are being moved?
2) To which Department are those employees are being moved?
3) Should we prevent any movement to the same department?
4) Should we immediatelly commit any movement to the database? Or should we have it a separate operation for the user?
5) How are we going to handle two different instances of VO in the Same Application Module? Are there any benefits to have two different Application Modules ?
6) How much code should we use in the view layer? Are we going to use AM methods? Are we going to develop in the Backing Beans?
7) Will the user be able to edit employees and drag and drop without just commiting?

Lets try to answer them one by one...
1) We are going to know all the information of every row straight from the controller. Sample code will be provider later in this post. So, there is no problem for this. The framework allows use to handle this information.

2) We have this imformation as well. Even though we will be droping employees to another employees table. Basically we will be able to know the Department Id of the other iterator directly from the Application Module. More about the Applicaton Module later on.

3) Normally, we should prevent it, because it is less consuming to simply check both Departments's ids and raise a message, rather than updating viewRows and entities with the same values. Besides, the implementation will acutally be the same for both tables. Which means that the user will be able to actually drag and drop employees inside the same table. This will certainly be an overuse of the functionality and it will be better to prevent it.

4) No, we should not immediatelly commit, simply because, the user might do a mistake and will want to undo her changes. It is a lot easier to simply have a rollback button, which, in terms of ADF development, is just a drag and drop. On the other case, we will have to redo an update and commit again. These are extra roundtrips to the database which is not a good thing to occupy the database if you can avoid it. Now, there is always the case where the user will want to undo the changes of only specific employees and not all of them. Well, in this case, the user will have to find those employees and re drag them back to original Department. Even if this is the case, all those changes will take place in the cache and not in the database. All those changes will be posted and commited to the DB when the user will press the commit button. One button. One press. One commit. keep the DBAs even happier.

5)With ADF we can simply insert the Same View Object twice. This will create two total different instances and handle them as such in the presentation layer. However, with one Application Module, the out of the box rollback functionality will rollback everything in both tables. But, this is the default functionality and we should treat it as is. On the other hand, if we use two Application Modules, we will be opening two database connections. You can reference documentation regarding Application Module pooling parameters here:

http://www.oracle.com/technetwork/developer-tools/jdev/index-097578.html

Overall, from architectural point of view and my personal opinion, it is better to use one Application Module and keep the DB and Weblogic resources as low as possible. But again, this is my opinion..

6) We will use both cases. We are going to use methods developed in the views and in the Backing Bean. The reason is simple. every action should be done in the appropriate layer.

7) This is possible yes. Since we will be using one Application Module, all changes will be carried to the other Department. At the bottom line, it is just a change.

------------------------------------------------------------------------------------------------
IMPORTANT NOTE: In HR Schema, there is a trigger called UPDATE_JOB_HISTORY
(using SQL Developer ).

This trigger is executed every time an update is done for employee regarding jobid and/or departmentid. As you will see this trigger has many check constraints that will not allow us to update an employee. For instance the pk is a combination of employee Id and the start Date to the new department...

Since in this example we want to demonstrate a back and forth drag and drop along with commit operation, we will disable this trigger. Just right click on the trigger in the SQL Developer and select disable. Again, this is an example of the drag and drop implementation. In real production environments those issues will be addressed accordingly. In case you dont disable this trigger while running this example, you will not be able to drag and drop the same employee to another department in the same day... the choice is yours!!
-------------------------------------------------------------------------------------------------

We shall Develop!!

So far, we have just created the BC and Shuttle twice the same viewObjects. Departments and Employees. This will give us the freedom to use two total different instances of the same View Object in the same page and keep the cached values visible in both of them. So, every time we update a

The part of the selected rows and their information is already described by Frank Nimphius in the
ADF Code Corner . We are going to use that sample code because it is exactly what we need.

We want to know the selected rows that are going to be updated.

The difference in this example is that we will be updating table rows in the backend.
We will not commit and the user will have a smooth "administration" of departments and employees.
In other words the user will point and change.

Developing the jspx
Since we have already created our BC, it is time to develop the jspx.
For that reason, we will create a bounded task flow and a view inside it.

Then, we double click on the view to create the jspx. For this example we are going to use the three column Oracle template.
The layout of the page is rather simple. We will just drag and drop Departments and Employees, Left and Right, to our jspx with the help of JDeveloper Wizard

JDeveloper will create all the needed components along with partial triggers as you see in the screen below:

Additionally, we change some labels and add Commit and Rollback buttons from the DataControl in the start facet of the template:

When we run our task flow the page will be like this:

Up to now we have achieved to have two panel boxes with separate functionality in terms of navigation. Commit and Rollback button apply to both panelBoxes since our views belong to the Same Application Module.

Applying Drag and Drop functionality.

In order to add Drag and Drop functionality, we have to do the following:
Each table will be able to either drag one or more rows to the other table. So, each table will have a drag source and each table will be a drag target. We simply insert inside each table the tags dragsource and droptarget.

DragSource:
We want to move one or more rows from a table. For that reason we have to specify the action to be MOVE:

We do exactly the same for both tables. Now, we have enable both tables to be able to drag rows and move them. We will specify now where those rows can be dropped.

DropTarget:
The implementation is similar to dragsource. We write the droptarget tag inside each table and we specify the same action move. Additionally, in the droptarget we have to specify the following:
dataFlavor: This is an inner tag of droptarget in which have to specify the type of data that are going to be handled and the type of action. In our case we want to move a RowKeySet with discriminatn rowmove.
dropListener: Without a dropListener we do not achieve much since we want to update our employees with the "accepting" departmentId. The dropListener is a property in the droptarget tag:

We set the dropTarget tab to both tables. The difference here is that we have to specify different dropListeners for each droptarget tag. This is because we want to handle the different dropEvents. We could fix our code to be better in terms reusability, but this is not the scope of this example.

On each drop listener we have to do the following:
We have to gather all rows that are dropped, find the new DepartmentId and update them. Finally we have to show the updated rows under the new department.

JAVA coding:

The coding part is relatively little for this implementation. All we have to code is:
Get the Landing Department (the new Department Id to which the dropped employee will belong),
Get the Selected Rows,
Update each row with the new DepartmentId,
Show the changes to the user. This means executeQuery for the Employees and update the components.

Getting the Landing Department Id:

Getting the Selected Rows:

Update Each row with the New DepId:

Refresh UI:

All this code is basically one method: a DropListener method:

The operationBindings is nothing more than 2 ApplicationModule methods exposed to the client:

last but not least, is the panel box bindings which are used to refresh the UI components:

And That is it!

Download the Sample Application.

References:

ADF Code Corner
60. Table Drag and Drop Sample by Fank Nimphius:

http://www.oracle.com/technetwork/developer-tools/adf/learnmore/60-table-drag-n-drop-sample-176981.pdf

af:dragsource:
http://download.oracle.com/docs/cd/E15523_01/apirefs.1111/e12419/tagdoc/af_dragSource.html

af:droptarget:
http://download.oracle.com/docs/cd/E17904_01/apirefs.1111/e12419/tagdoc/af_dropTarget.html

Adding Drag and Drop Functionality
http://download.oracle.com/docs/cd/E12839_01/web.1111/b31973/af_dnd.htm

Regards.

weblogic.descriptor.BeanAlreadyExistsException: Bean already exists: "weblogic.j2ee.descriptor.wl.LibraryRefBeanImpl@c76e5f19(/LibraryRefs[[CompoundKey: adf.oracle.domain]])

2011-11-01T05:11:00.000-07:00

Hi,

If you ever see this exception on your JDeveloper while trying to deploy an application:

weblogic.descriptor.BeanAlreadyExistsException: Bean already exists: "weblogic.j2ee.descriptor.wl.LibraryRefBeanImpl@c76e5f19(/LibraryRefs[[CompoundKey: adf.oracle.domain]])

Most probably it is not your fault... what I found out was that my weblogic-application.xml file was somehow, "bigger"... a lot of duplicated values:

Well, if you remove all duplicated values, your application will work fine. At least it did for me.

Why this would happen? Honestly, I am not sure.. sometimes things get messy... Maybe the back and forth between JDeveloper versions... I cannot really say.. But anyway, the solution is simple and fairly easy.
To locate the weblogic-application.xml file, just find the Application Resources section of the Application Navigator.

Double click on the weblogic-application.xml file and correct the mistakes.

Here is a healthy default weblogic-application.xml file:

Regards.

PopUp and Esc/Cancel operations. ADF 11g

2011-10-24T07:04:00.000-07:00

Hi,

When we create a popup with a dialog inside it. The dialogListener cannot actually capture the Esc or the cancel button. For this case, we are using the popupCancelListener of the popup.

This small application has only one button and a popup with a dialog inside. All the default actions with declarative programming.

Download sample application.

Regards.

Master Detail Data presentation and CRUD Operations. Detail records in an Editable Popup. ADF 11g

2011-10-20T04:49:00.000-07:00

Hi,

This yet another example of Master Detail data representation.
The difference here is that, the Detail rowsets will be presented in a popup.
We are going to use HR schema of Oracle XE for this example.

Download Sample Application.

We are going to use Departments as the Master and Employees as the Details.
Departments will be presented in an table.
The Departments table will have all CRUD operations. Insert, Update, Delete. Additionally there will be a Rollback button.
Every Record in the Departments table will have an additional column where an edit button will reside.
The edit button, when pressed, will show a popup which will present another table, the table of the Employees that work to this Department.

Using the Generate Business Components From Tables wizard of JDeveloper, we produce all the necessary entities, associations, view objects and viewlinks. It is a very straightforward process.

After having the BC created along with the Application Module, we proceed in creating the View controller components.
We will create a bounded task flow and within it, we will create our index jspx.

Inside the Jspx we will drag and drop the Departments iterator and we will choose to select a single row from the Row Selection.

and select the single selection

After creating the table, we will surround it with a panelCollection component. This container will hold the toolbar of the CRUD buttons for this table. Additionally, both in the panelCollectin and table, we set the AFStretchWidth in the styleClass. It is recomended by Oracle in order to have properl full width layout.

The we drop a toolbar in the panelCollections toolbar facet and then we drop the Department's operation from the DataControl.

We will add, createInsert, delete, commit and rollback. Commit and Rollback operations are for the whole datacontrol and not only for the Departments table.

Next, we have to create a popup. This popup will show the employees of the corresponding Department.
Inside the popup we will add a Dialog. Inside this Dialog we will drag and Drop the Employees iterator and have exactly the same process as we did with Departments.

Eventually, we will have a similar table with Departments.

Popup component by default caches the first data that will be shown. In our case, we do not want that since we want a refreshed view of the employees. This means that we want to execute Query for employees for every Department.
So we have to set lazyUncached the contentDelivery property.

NOTE: Since we are using toolbars and toolbar buttons we have to set the appropriate partial triggers. Toolbar buttons by default have the partialSubmit property to true. This means that we have to set the appropriate partialTriggers to the tables.
Each table will be partially triggered by it's toolbar buttons. So in Every table, in the partialTriggers sections we will add the correspoing toolbar button ids.

After setting the appropriate partialTriggers, the only thing left is, the edit button.

We right click on the table and select insert Column.
Then, we right click on the column and insert ADF faces button.
After that, we right click on the button and insert ADF showPopupBehavior.
In the showPopupBehavior we enter the popupId and the type of action:

And that is it.
When pressing Employees button, ADF will invoke additionally the selectionListener and make the departments current row. So every time we press the edit button, the current Department becomes current and the corresponding employees are fetched.

Download Sample Application.

Regards.

Entity Attribute Validation Rule (Business Rule) based on Master View Object Attribute Example ADF 11g

2011-10-19T16:05:00.000-07:00

Hi,
Here is an example case of entity attribute validation rule.

Download Sample Application.

This example is using HR Schema of Oracle XE.
The following case uses Employees and Departments Entities and View Objects.
All Business components are created through JDeveloper 11g wizard.
The validation will check if the ManagerId attribute of the Employees Entity has the same value as the ManagerId of the Department.
We consider that there should not be the same Manager of a Department and an Employee.
Just to clarify that this is an example and maybe the logic does not seem very logical....
The point is to present the solution.
So, what do we have so far?
Two Entities (Employees and Departments) with their association (Master is the Departments entity)
Two View Objects( Employees and Departments) with their corresponding entities and the appropriate view Link.

Now, as we said earlier, we want to prevent the user from setting managerId value, for an Employee, which is the same as the managerId value for the corresponding Department.

In order to implement this case the declarative way, we are going to create an Entity Attribute Validation Rule or in other words, Entity Attribute Business Rule.

We locate the Employees entity and the ManagerId attribute and press the green plus sign:

A new wizard window will appear that will guide us to create the validation we want.
For this scenario, we want to compare the Employees Entity managerId with the Departments View Object managerId. For that reason, we will select the value View Object Attribute value of the Compare With choice list. Further more we set the Operator to Not Equals.

Location of te ManagerId

Setting the Not Equals

The final thing to do is to set an appropriate message that will notify the user that this value cannot be accepted.

This Rule Definition will be triggered when the Employees managerId attribute is the same as the Departments View Object managerId attribute.

In order to test the example, we do not need to create any jspx.. Since this is a BC validation, all we have to do is run the Application Module:

In the following example: Department has ManagerId of nbr: 200

We double click on the Employees view and change the managerId to 200 and press tab. The result will be the following: (the message is just for fun.. .not an actuall logic message.. or is it? :) )

And that is it..
Dont you just feel a little bit more Declarative now?

Download Sample Application.

Regards.

Master Detail on separate Pages and Separate Task Flows ADF 11g

2011-10-17T01:34:00.000-07:00

Hi,

This is another small example of how to present Master-Detail information. This example will show to present master detail data over different pages where each page exists in a different task Flow.
Furthermore, you can find a discussion in the forum, where this post was inspired from.

Download The Sample Application.

The implementation is almost the same as a previous post:

http://dstas.blogspot.com/2011/10/master-detail-on-separate-pages-jspx.html

The difference here is that, Master Detail pages exist in different task Flows.
This approach has the following differences:

Create another task flow for the details page.

In the master task flow, make a call to another task flow (the details task flow that is..) instead of a page.

In the details task flow, make a call to a task flow return instead of the master page. The task flow return will return to the calling task flow.

And here is the "tricky" part of the implementation. In order to keep the task flows synchronised with each other in terms of Data Control, we have to share the same Data Control.

This can be easily done by selecting a check box in the detail task flow that will do just that. It will "get" the Data Control of the calling task Flow.

So, every time the master task flow will call the detail task flow, it will delegate the Data Controls. This means that there will be a consistency between Master and Detail task flows in terms of data.

Download The Sample Application.

Regards.

Master Detail on Separate Pages jspx ADF 11g

2011-10-14T04:05:00.000-07:00

Hi,

This is an example of using a typical master detail relationship but in different pages.
The master will be in one page and the details will be in another page.
The use case is simple.
Select a master row from a table and then navigate to the details table of this master which are in another page.
For this case we will use the Department and the Employees tables of the HR Schema.
The Departmens will be the master page and the Employees will be the details page.

Download The Sample Application.

For starters. We have to create the appropriate ViewLinks between DepartmentView and employeesView.

The "trick" here is to use the appropriate iterators in the same DataControl.

This means that, in our case, we will have a task flow with two view inside that will share the same data control.

So, in the first page, we will drag and drop departments iterator as a table. Add a button for the navigation.

For the second page, we will drag and drop employees iterator, the one that resides inside the Departments tree.

And that it is.. The framework will take care of the rest. The Binding layer will keep the relationship open between the two iterators since they are sharing the same dataControl.

Download the sample Application

Regards.

ADF Survey

2011-10-12T06:15:00.000-07:00

Today, Grant Roland published a post regarding a goal to improve ADF. There is a survey for ADF that will help Oracle improve, even more, the ADF future.

Let us all express our opinion and provide feedback for the best possible improvement of ADF.

http://blogs.oracle.com/grantronald/entry/your_chance_to_change_the

https://www.oraclesurveys.com/se.ashx?s=705E3EFC4861B8FE

Regards,
Dimitris.

Create Row in a Table after leaving an input Field (ValueChangeListener usage) ADF 11g

2011-10-11T16:13:00.000-07:00

Hi,
This is a sample application demonstrating the following case:
We have an af:table with rows from a View Object. What we want is to create a new row right after leaving an input Field.
What we are going to do is to make use of the valueChangeListener.
First we are going to do is to create a simple page.
For this example, the HR schema is used and more specifically the Regions Table.

Download the Sample Application.

After creating the appropriate Business components (entities and view objects), we will create a jspx with its pageDefinition. In the jspx we drag and drop the Regions View Object as a table.
In the page Definition, we add the operation binding of CreateInsert.

After that, we select the input field we want to use for the creation of the new row and we create a valueChangeListener. If no Backing Bean is present the wizard will help us create one on the fly and very easily. Additionally, we have to set this field to autoSubmit=true;

Furthermore, we have to create a binding of the Regions table because we need it in order to refresh the table right after the creation of the row. The refresh is needed because we want to show to the user (actually refresh the UI) that the row is already created and correctly shown.

The last this left is to write some code in order to actually create the new row right after leaving the input field (via pressing tab lets say)

The code to write in the ValueChangeListener is fairly small and rather easy. All we have to do is call the CreateInsert operationBinding and then refresh our table.

And that is it.
When you run the application you will see that after changing a value and pressing tab a new row will appear on the table. Note that this row is not posted in the DB and does not exist there. This sample application has no other operations like commit or rollback included.

Download the sample Application.

Regards.

ADFUtils.java And JSFUtils.java

2011-10-11T14:16:00.000-07:00

Hi this is some kind of personal finder.. I uploaded an Application containing the ADFUtils.java and JSFUtils.java classes create by three ADF Ninjas:
@author Duncan Mills
@author Steve Muench
@author Ric Smith

I know, at this point I have to say that this is not my code. I did not wrote it. I simply put it up in my blog because I seem to loose track from time to time and I need it somewhere that I can easily find and download. Of course, the code is in the Demo as mentioned here

https://forums.oracle.com/forums/thread.jspa?threadID=1105943

But again, I find it more practical to additionally have it on my own list without claiming any credit for this code.

http://adfsampleslist.googlecode.com/files/ADFJSFUtilsApplication.zip

Regards,
Dimitris.

Rollback After Validation Error Entity Level. ADF 11g

2011-10-09T13:29:00.000-07:00

Hi,
There has been a discussion in the OTN forum regarding how to rollback when an Entity validation error appears..
Well, at first, I thought we could use the refresh(int refMode) method inside a validation method which will reside in EntityImpl java class. This thing is that this approach does not seem to work properly... at least for me.. Or maybe, according to documentation, I cannot place the correct combination of refresh MOdes.. If anyone has a successful example, please

http://download.oracle.com/docs/cd/E12839_01/apirefs.1111/e10653/oracle/jbo/Row.html#refresh%28int%29

The case is rather simple.
We have a validation rule for an attribute. If this validation fails, we have to rollback.
Well, of course the validation rule will be applied in the BC and more specifically in the entity. Since we want to have an additional logic after the validation, we will create a validation method through the wizard.
So, after our validation method, we will rollback, calling the DBTransaction rollback;

this.getDBTransaction().rollback();

This example will always rollback. It is just an example.

After setting up successfully the validation method to the DepartmentName attribute in the EntityImpl java class, all we have to do is to drag and drop the Departments Iterator in our jspx as a af:table. Last thing is to have the DepartmentName autosubmit=true.
And that's it, it will refresh the value from the db.

Download the Sample application:
http://adfsampleslist.googlecode.com/files/ValidationRefreshExample.zip

Regards,
Dimitris.

Insufficient Disk space! Install Oracle Weblogic 10.3.5 on a Mac OS X 10.5

2011-07-23T14:50:00.000-07:00

Hi,
After downloading the generic install of Oracle Weblogic Server 10.3.5 (wls1035_generic.jar), I kept trying to install it on my mac OS X 10.5.8. I always got the "Insufficient disk space!" message even though I had sufficient disk space message..

After quite some time on searching I discovered that I had to place the following command in order to install it properly:

java -Dos.name=unix -jar wls1035_generic.jar

Well, that worked for me. Just another post for faster results while searching the internet.

Regards.

Displaying a One To Many Master Detail Relationship In a Row.

2011-07-14T12:24:00.000-07:00

Hi,

Here is the scenario based on the HR Schema of Oracle XE.

UPDATE: Application is updated for 11.1.2.1.0.

How could we represent a Department with all the employees in an horizontal way. In a row that means.

This is a typical master detail representation and can be easily done with tables. With ADF can be done quite fast. But, what if we want to have rows of Departments and the Employees of each Department in a single row?

Why bother doing it?? Well, why not?

Download the Sample Application.

Download Sample for 11.1.2.1.0

Here is a sample implementation to an answer.
Basically what we want is to have a table and, in each row, we want to have cells of the Department and a couple of cells for each employee of the corresponding Department.
This solution (I am sure there will be others) takes advantage of the tree binding of the page definition.

Ingredients:

Entities: Departments, Employees
Entity Associations: Departments and Employees
Views: Departments, Employees
View Links: Departments and Employees from the above mentioned Entity Association.

a jspx with a page definition

and some manual coding in the jspx.

For the Business Components creation, we use the wizard and we produce the bc we want. Actually, there are only two tables, Departments and Employees.

Then, we create a jspx and a page Definition.
In the page Definition, we add a tree component:

after pressing ok, we select the root data source. In our case is the DepartmentsView.

After pressing ok, we shuttle the DepartmentName attribute on the right:

Then, again, add another rule, the one of the employees and shuttle the FirstName and the LastName (the same as we did with Departments):

Now, basically, we are done with our bindings. That's it. All we have to do is "paint" our page.

We are going to manually construct our table. We are going to use the simple html table, for this example, and the af:iterator component.
What we are going to do is to iterate the Depts and for each dept we are going to iterate the employees.

At that time we are going to create our table.

So, for every we will place 2 for the information for every department
Inside the same we will start a new iterator.
The employees iterator.
In order to fetch the correct employees all we have to do is to get the children of
the var of the master iterator
Since we want to be represented as a "table"

Eventually our table will look something like the following:

As you can see from the picture above the number of the employees is not standard. This is quite logical since every Department might have different number of employees. For the sake of the example, we limited the number of rows of the employees iterator to 2. So what we see is maximum 2 employees of every Department. Of course one can easily change this number to a more dynamic one.
Below are the screens of the code of the jspx:

For the Labels:

For the actual Data:

As you can see, it is fairly easy to present horizontally a one to many relationship..

Download the sample application.

Download Sample for 11.1.2.1.0

Regards.

JDeveloper 11.1.1.5 severe bug

2011-05-18T00:37:00.000-07:00

Michael Koniotakis posted in his blog a very severe problem regarding JDeveloper 11.1.1.5.
The problem is related to the Rollback button and the immediate property.
It is also mentioned in the forums : http://forums.oracle.com/forums/thread.jspa?messageID=9587923#9587923

In the forum, it is mentioned by Didier Laurent ( http://blogs.oracle.com/Didier/ ) that an Alert is raised in "My Oracle Support" .

I am sure a patch will come out soon to fix the major issue.

ViewObjectImpl findByKey(Key key, int i) example

2011-04-28T13:45:00.000-07:00

Hi,
This is a small sample application demonstrating the findByKey(Key key,int i) method.
According to the API:

http://download.oracle.com/docs/cd/B14099_19/web.1012/b14022/oracle/jbo/server/ViewObjectImpl.html#findByKey_oracle_jbo_Key__int_

This can be useful when we want to navigate to a page for instance displaying a given row and not actually filtering the dataset retrieved from the query.

Download the Sample Application

The test case is fairly simple. Lets use the HR schema.

We create an Application and produced the Business Components of the Employees and EmployessDetailsView tables. Just using the JDeveloper Wizard.

The result is to have, among others, the following views:

EmployeesView

EmpDetailsViewView

The findByKey method as we saw in the API accepts a parameter of type Key.

The case for this example is to use the key for one VO object and call the findByKey method to find a row in the other VO and make it current.

So we have to alter the EmpDetailsView entity Object a bit. We need to set the primary to point to EmployeeId and remove the RowId, smartly, produced by JDeveloper wizard.

and the View Object should be like the following:

Note here that we are not creating any ViewLinks. This will simply filter our data and we wont be able to see all other data.

Furthermore, we will create two separate pages for each VO and we will navigate from one page to another.

We will create a form in each page with navigation buttons. Additionally we will move from one page to another and see the appropriate information.

For example, while in page of Employees, we will navigate to record with EmployeeId=107 and then press the button to go to EmpDetails. The same operation will be done from EmpDetails to Employees.

The goal is to have consistent data according the employeeId.

As you understood by now, we will use the findByKey method...

Simply, we will create two separate methods in the Application Module Implementation class that will do the work.

What we do here is to get the Key from the One's VO current Row and find by key to another.

Now, we need to call these methods.

We will expose them in the client interface of the Application Module

Next we will create a task Flow of three (3) pages.

Index: from which we will navigate to Employees or EmpDetails pages

Emps: from which we will navigate either to EmpDetails or Index pages

EmpDetails: from which we will navigate to either Emps or Index pages.

The trick here is to interfere the calls from Emps to EmpDetails and vice versa in order to call the findByKey methods.

Since we have them exposed, we will simply drag and drop them to our taskFlow and have to be called before going to the page we want.

And that is about it..

Every time we navigate from one page to another, the corresponding findByKey will be called and we will see the data set according the EmployeeId.

Download the Sample Application

cheers.

Restore Deleted files in JDeveloper (No SVN)

2010-12-21T04:34:00.000-08:00

Hi,

I accidentally deleted some files of a project of mine. I could not revert anything because I did not have any version control on them.. I searched everywere, in recycle bin in file System of my windows.. nothing..
However, I managed to discover them under the following path:

C:\Documents and Settings\DStasino\Application Data\JDeveloper\system11.1.1.3.37.56.60\.history

There are many folders with numbers, every folder holds a history of a file with a date modifed.

The files inside the folder are in raw format. I you open it with some editor you will see the file you might be looking for. So, what I did is to rename and change the file extension and place it back to my project!

That was a great relief...

If anyone knows any more declarative way, please share.

Regards.

Entity Inheritance And Passivation-Activation Possible Problem in ADF 11g

2010-11-17T05:09:00.000-08:00

Hi,

It seems to be a very strange behavior when it comes to Entity Inheritance and Passivation-Activation.

Download the Sample Application

Lets Say that we want to create an application that wants to do the following:

1) Use Entity Inheritance

2) Have one View Object and interact with it, leaving the inheritance do the magic

3) Create an insert Operation to the subtype. The method will reside in the AM and exposed to the client interface.

4) Create a sample jspx and drop a Form of the View Object.

5) Drop the insert operation onto the jspx sample page.

6) Have our application tested with and without the AM pooling.

Implementation:

Lets take those steps one by one:

1)
As Far as the Entity Inheritance, we will follow the ADF documentation that describes us how to do it:

http://download.oracle.com/docs/cd/E15523_01/web.1111/b31974/bcadveo.htm#sm0327

First we create the Employees entity.
In the Employees Entity, we set the attribute JobId as the discriminator Attribute. We do not set any Default Value in this attribute since we want to handle all case that are not included in the subtype.

Next, we create another Entity that extends the Employees entity. The name is EmployeesAC_ACCOUNT

In the EmployeesAC_ACCOUNT we have set a Default Value in the Discriminator Attribute: "AC_ACCOUNT"

2)
To create a View Object with prolymorphic entities, we follow the ADF documentation that describes how to do it:

http://download.oracle.com/docs/cd/E15523_01/web.1111/b31974/bcadvvo.htm#sm0515

This means that we create a viewObject based on the entity, and then add the subtypes

3) In Order to create a row in the subtype, we follow the documentation of the step 2) and specifically the chapter:

39.6.4.3 Creating New Rows With the Desired Entity Subtype

So we created a method in the Application Module that does the following:

4) Next, we create a simple page with a Form of the Employees View Object.
A Drag n Drop in the ADF world..

5) We expose the AM method in the client interface and we drop it as button in the Form

In Result we have the following layout:

If we run the application and press the create button we will see the following:

As you can see, the discriminator value has the value passed from the create method.

If we set values to all fields and then press submit, the form is submited correctly.

This functionality works very well.

5) But according to decoumentation:

http://download.oracle.com/docs/cd/E12839_01/web.1111/b31974/bcstatemgmt.htm#CHDGAIFA

We have to test our application with the Inheritance we did, without the Application Module pooling.
Note: for a detailed explaination of how to remove it you can check a blog post:
http://jdeveloperfaq.blogspot.com/2010/02/faq-14-how-to-test-application-module.html

After we uncheck the pooling in the Application Module. we run the page again.

We press the create button and we insert data. But when we press submit, where the passivation and the activation takes place we have error messages on the page that the required attributes have no values!!

so, from this state:

we press submit we end up to this state:

Am I missing something here?

Download the Sample Application

Regards.

Search Page To Edit Page And Back to Search Page With Refreshed Data

2010-09-16T13:30:00.000-07:00

Hi,

Here is a way of doing the following scenario:

Download the Sample Application

We have a search page with a Criteria and a result Table. The criteria have Query Automatically to false. This is to prevent from fetching any data on the page.

We have another page that edits the selected row from the table. This is called the Edit page.

There is a navigation from Search Page to Edit page.

Finally we want when to navigate back from the Edit page to Search page, to have the new data refreshed on the search table.

First we create a View object with View Criteria. This example uses the Countries Table from HR schema.

In the View Criteria we add the CountryId in the Criteria.
Then we create a bindVariable to hold the value.

We make sure that the attribue and the Bind Variable are of the same type.

By default the wizard sets the View Criteria to NOT query Automatically, which is what we want for this example. Query Automatically false means that no data will be displayed on the page until a search is issued:

Then we set the bind Variable to be hidden while the View Criteria will be rendered on the jspx.

Finally, we have a view Object with a view Criteria:

Next, we create a page for the search page:

On the wizard, check the row Selection checkBox:

The result of it the following screen:

We surround the table with a panel Collection layout and drop a Button from the pallete:

The Edit button will be included in the toolbar facet of the panel collection:

For now, we dont have any navigation set.

First we have to create the edit page. Is the same process as the search page. Instead of droping the criteria, this time we will drop the iterator as a form:

We drag and drop the commit operation on the footer of the form in order to save any data changed:

For the simplicity of the example remove the disabled condition of the commit button.

Also, we create a button below the commit button that will navigate us back to the search page:

Then we drop a navigation flow from Search page to Edit page.

Now, we go back on the Main(search) page and locate the edit button(it is in the toolbar facet of the panelCollection) and set the action that points to edit page:

If we run the main page we will have a search page with no data.

If we press search button, all data will be fetched.
Then we press the edit button and we navigate to to the edit page we will see that the record we choosed is displayed in the edit form

At this point we do not have any functionality on the Back button:

What we want is to navigate back and reflect the data..

All we have to do is to create another navigation flow back from edit page to search page:

Then, we have to assign the correct action to the back button:
Back in the edit page we locate the back button and set the back action to it:

And thats it!

Download the Sample Application

ADF 11g methodAction and invokeAction in the pageDef

2010-09-05T14:59:00.000-07:00

Hi,

Here is a small example focusing on how to create a methodAction and an invokeAction in a pageDef. Those properties in a pageDef can be very helpful especially when we want to do things more declaratively or have automated actions for your page.

Download The Sample Application.

What we are going to do here is a slight difference of a previous post.
In the previous post we entered a page in insert mode.

http://dstas.blogspot.com/2010/09/open-jspx-page-in-insert-mode-in-adf.html

Now, we are not going to use the feature of methodCall.
We are going to have the logic in our pageDef.
We are going to use the methodAction and the invokeAction.

First, we create the model, for this example we are going to use the HR schema in the ORACLE XE.

We create BC(entities and views) for employees table.

We generate the Application module as well.

We create the method in the application Module as in the previous post here

We create the java class for our Applciation Module (AM).

We create the java classes for Employees View the same as we did for the AM.

In the java class of the AM we create the method that creates and inserts a new row in the Employees View.

We will now expose the method in the client interface of the AM

with result:

After exposing the Method from AM, we will create a methodAction pointing to method exposed.

NOTE: we have to create a jspx page with a pageDef. To create a pageDef simply drag a drop on the jspx or right click on the jspx and select create page Definition.

1) Open the pageDef of the jspx. and in the Bindings Column add a new binding of type methodAction

On the second screen:

With the result:

Now, this methodAction can be called as any other operation in the bindings.

In our case, we want to call this method every time we enter the jspx.

In the previous post, we did it with a separate methodCall.
In this case we will create an InvokeAction tha calls this methodAction

In our pageDef again, we will create an invokeAction.

After ok is pressed:

The result to this is:

We are not just done yet.

We need to set when this invokeAction will be invoked.
We go on the property Inspector of this executable and change the refresh condition
to prepareModel:

At this point we have created an invokeAction that binds a methodAction and it will be invoked everytime the prepareModel is invoked.

For more details on the refresh property, please refer to the documentation:

http://download.oracle.com/docs/html/B25947_01/bcdcpal005.htm#sthref837

The last thing to do is to drop the Employees form into the page.

On the wizard window check the navigation buttons check Box.
As a final, also drag an drop the Commit operation onto the jspx.

Thats about it.

When we run the page:

Download the sample Application.

Open jspx Page in Insert Mode in ADF 11g How To

2010-09-05T05:04:00.000-07:00

Hi,

This is an example of how to enter a form in insert mode.
By default, the ADF queries for data when the user enters a page.

To bypass this, we have to enter the page without quering for any data.

To do this, we have to executeEmptyRowSet() on our View Object before entering the page.

Download the Sample Application.

The before entering the page is easier than you might think

The goal here is to have the page intact with it's default functionality.

The fact that we want to enter the page in insert mode might change at some point. So it is better to have this functionality in a different place.

Besides, the insert mode, affects the model and eventually the page through the bindings.

So, by changing the status of the VO we eventually changing the status of the jspx through the magic bindings.

What we need is this:

As you can see, in our task flow we have a method call as the default activity.

This methodCall calls a method in the Application Module.

The method in the AM is very simple:

    /**
     * creates a new record in the Employees View Object.
     * Also executesEmptyRowSet in order not to fetch Data.
     */
    public void enterEmpsInInsertMode(){
     EmployeesViewImpl emps=(EmployeesViewImpl)this.getEmployeesView1();

     emps.executeEmptyRowSet(); // executeEmpty RowSet not to fetch Data.

     Row newRow=emps.createRow();

     emps.insertRow(newRow);

     emps.setCurrentRow(newRow);

    }

This method gets the EmployeesView and does the following:

1) executes empty row set. This will not bring any data to the iterator.
2) creates , inserts and sets it as current in the View Object, which eventually through the bindings will be the current row in the iterator on the page.

This method is exposed in the client Interface of the AM.

The result is this:

If we drag and Drop from our Data Control this method in our taskFlow, it will create a methodCall with its own pageDef and added the method from the AM.

Make sure that the method call is set to be the default activity of your task flow.
Thats it!
It might not be out of the box implementation, but it is a very clear approach.

Here is a screenShot of the result page:

Download the Sample Application.

Update: After FetishCode comment, I have to say that the scope of the example is for the user to be able to rollback and be able to see all the records of the View Object. To achieve this, we must change the property cacheResults of the Iterator in the pageDef of our page to false.

I double checked the application and changed to the correct one. Mistakes happen..
Regards.

Press Edit Button to make Table Row Editable.

2010-08-29T12:48:00.000-07:00

It seems very logical to have a button in a table row that will change the state of the row from read only to editable.
ADF supports this in a diferent way, The table has a property called EditingMode.

If you set the value clickToEdit, then, each time you click a record, it will become editable.

Here is way of doing the same thing but with a button.
So instead of clicking on the row to edit, we ll have to click on the button and make the row editable.

Download the sample application.

This is what we want to have as functionality:

First we will create a transient attribute in our Entity Object
This attribute will be called editable and will have type of Boolean
We will add this attribute in the VO.

In the VO Row Impl java class, we will override the isAttributeUpdatable method.

Now, if the editable transient attribute has value true, we will return the super method, else we will return false.

Well, this means that every time we fetch data from the View Object, cached or not, this check will be done and according the value, the attribute will be updatable or not.

How to set value to this attribute:
We want this to happen when we press the button.
So, first we create another column,

add a button with partialSubmit=true,
Inside the button we add a setPropertyListener (Recomended instead of setActionListener)

Type: action
From: #{true}
To: #{binding.editable.inputValue} <--- we have to add the binding on our pageDef
e.g

This will represent the editable value on the current record.

Last, place partialTrigger on the table from the Button

The other partialTrigger you see on the screenshot is from create insert button.
So, if you run your application you will see that when you press edit button on a row it will become editable.

Infact, you can make more than one row editable, simply by clicking the corresponding button...

But what happens when we commit??
We need to set the value back to false..
So,
Back in the EntityObject impl java class, override The doDML method, and before super, set the attribute to false.

This will post the false attribute and after the commit it will have value false.
So all the rows will be read Only.

As far as the createInsert operation:
We could do the same on the createInsert button, as the edit button.
Just for the difference, we can do it somwhere else in the model.

In VORowImpl java class, Override the create method and set value true to the editable attribute.

Thats about it...

So now, we have a table we readOnly behavior and an edit button that enables that row.
After commit, the row(s) become readOnly again.

Download the Sample Application.

regards.

Column button in a read only table. Edit in a Popup and return values.

2010-08-29T11:06:00.000-07:00

Hi,
Here a simple example of how to add a button in a read only af:table and show a popup with an editable form of the current row.

Download Sample Application.

The first page can be done rather easy.
Simply drag and drop the iterator from the Data Control into the page and choose read only table.
Then, in the table add a column.
Inside the column add a commandButton.

This commandButton will show the popup.

Create a popup that will include a Dialog inside. The Dialog type will be ok/cancel.
Inside the dialog drag and drop the same iterator as previously but this time choose form.
The submit button is not necessary in our case.

Here is the generated code from JDeveloper

We are not just done yet.
In the button we have to add a showPopupBehavior and point the id of popup.
When the button will be pressed the popup will be shown with the current record ready to be edited.
Here is the code of the button:

At this point, if you test it, you will find that no matter which edit button you ll press, you ll still see the first record in the popup.

This is simply because the popup by default caches it's results.
To change that, just change the contentDelivery to lazyUncached:

With this way, the data are always refresh upon the show of the popup.

In order to refresh the data of the table in the back ground, we need to add a partialtrigger to the table.
The partialtrigger will be the id of the dialog which is inside the popup.
So when the user presses the ok button the table will be refreshed and show the new data.

At this point we are good to go..

after ok pressed.

Download Sample Application.

All the Information about XML artifacts of ADF

2010-07-29T00:43:00.000-07:00

ADF is based on XML files for entities, views, ApplicationModules etc.
All these files can be used in order to produce a very useful information for Developers and Designers of ADF applications.
Serafeim Karapatis (http://serafeimk.blogspot.com/) has introduced this concept and the creation of a tool that will be easy to use and will produce very usefull information about ADF applications has started.

For more information, check Serafeim Karapatis's post http://serafeimk.blogspot.com/2010/07/xml-artifacts-adf.html

Stay tuned for upcoming releases.

Regards.

Oracle-XE on Ubuntu 10.4 Swap File Problem.

2010-05-25T12:15:00.000-07:00

Hi,

Here is the official link from Oracle on how to install oracle-xe on Ubuntu.
I just tried it on my Virtual Box machine with Ubuntu 10.4 .

http://www.oracle.com/technology/tech/linux/install/xe-on-kubuntu.html

But since I am not familiar with Linux.. And I am sort of forced to use it if i still want to work on my Mac and on oracle-xe..
I made a mistake on swap file size... I left it default.. Everythin ok until i tried to install oracle-xe. It was complaining that the swap file was too small for the installation..

Here is the link on how to increase the swap file on ubuntu:

https://help.ubuntu.com/community/SwapFaq

It is the official site of ubuntu..
I would like to share it with everyone cause it troubled me for sometime.

Regards.

Master View Search Form .Display Only Results in Detail View Objects

2010-05-25T02:48:00.000-07:00

Hi,
There is a very easy way to keep your Search Form in find mode all the time.
Consider this:
Lets say that we have a Master View Object (e.g. Employees) and a Detail View Object( e.g Departments).
We want to Use the Master as a Search Form and the Detail as a result table.

The structure of our page is the following:
1) Master as a search form(always entering in find mode.)
2) Detail as a readOnly detail table.

We want our page to show something like this:

and we want to show like this:

a) First of All we frag and drop the Master view object as a search form into our page.

b) Second we remove the find button but we keep the operation in the pageDef.

c) In the pageDef, we create an invokeAction in the executables. This invokeAction will invoke the Find operation. The refresh condition will be "prepareModel" We want this because it will be invoked when initializing the iterators.

d) In the page, we set the "Execute" button to partialSubmit=true

e) In the read Only detail table, we set the following partialTriggers:
the execute button, and the searchForm. We do this because we do want the Detail show data at the first place. And, we want it to be refreshed after the button is shown.

Donwside:
If we will execute with empty criteria or with criteria that will fetche more than one row in the Master.. the detail will show rows only for the first fetched Master row.

download sample application.

Regards.

Convert java.lang.String to oracle.jbo.domain.Date

2010-04-09T02:49:00.000-07:00

This is a way of converting a given date as a string to oracle.jbo.domain.Date.

/**
*Converts a String to oracle.jbo.domain.Date
* @param aDate
* @return oracle.jbo.domain.Date or null.
*/
public oracle.jbo.domain.Date castToJBODate(String aDate){
          DateFormat formatter;
          java.util.Date date;

          if(aDate!=null){

            try {

              formatter = new SimpleDateFormat("dd/MM/yyyy");
              date = formatter.parse(aDate);
              java.sql.Date sqlDate = new java.sql.Date(date.getTime());
              oracle.jbo.domain.Date jboDate = new oracle.jbo.domain.Date(sqlDate);

                return jboDate;
               } catch (ParseException e) {

                        e.printStackTrace();
                }

         }

         return null;
}

ViewObject.createRow(); Or ViewObject.createAndInitRow(AttributeList); ?

2010-04-08T04:18:00.000-07:00

There are many posts over the internet regarding how to open a page in Insert Mode.
Invoke Insert operation that is.
There are also many ways of doing this.
In this post I would like to show you a small, but very big, difference between VO.createRow() and VO.createAndInitRow(AttributeList attrList) methods.

Download Sample Application.

The difference can be found in this specific and yet very common case:
In the form to be created we have an LOV which besides the codeId returns also another value to another Attribute of the ViewObject: see the following Image:

Yes, it is a common case in every day programming...

In the sample application I have implemented 3 Different methods with the same result (not quite the same result as you will see...).

1)

The Whole purpose is those methods to be called before entering the page. se the flow below:

On the main.jspx I have placed 3 buttons for each action. The result to this is the following:

For the first two (2) methods the result is the same and as expected: the second attribute of the LOV is returned correctly.

For the third (3d) method, the result is not as expected: The New Row is created but the second attribute is not returned at all!

Actually I did a bit more of investigation.

I created another 3 button with the same actions for a different page. This page does not have the LOV case as the previous one.
It has an attribute from a referenced Entity.
So when the LOV has a value the referenced attribute will have value.
After testing, I saw that all actions have exactly the same correct behaviour: Referenced Attribute is calculated correctly.

Download Sample Application.

According to the API:
-createRow() : Creates a new Row object, but does not insert it into the Row Set.
Returns: a new Row object..
Source: http://download.oracle.com/docs/cd/E12839_01/apirefs.1111/e10653/oracle/jbo/RowIterator.html#createRow()

-createAndInitRow(AttributeList nvp): Creates and initializes a new Row object, but does not insert it into the Row Set. This method differs from createRow() mainly in that this method allows the user to pass in a list of name-value pairs with which row attributes are initialized.
nvp is a named value pair. When building an nvp from scratch, use NameValuePairs to build a new nvp. Here is an example:
NameValuePairs nvp = new NameValuePairs();
nvp.setAttribute("EmpTyp", "C");

Row row = voEmp.createAndInitRow(nvp);

This method is particularly useful when creating a subclass View Row or Entity Row. You can include polymorphic discriminator attribute values in nvp and correct subclass row object will be created.
When this method is called, underlying entities are created. After the new entities are created, a new view row is created. After that ViewRowImpl.create(oracle.jbo.AttributeList) is called with this nvp. ViewRowImpl.create(AttributeList) walks thru the list of entities and calls EntityImpl.create(AttributeList) with the same nvp for each entity in the view row.
Parameters: nvp - a list of name-value pairs.
Returns: a new Row object.
Source: http://download.oracle.com/docs/cd/E12839_01/apirefs.1111/e10653/oracle/jbo/RowIterator.html#createAndInitRow(oracle.jbo.AttributeList)

Conclusion: createAndInitRow method does not have expected behaviour when it comes to LOV or Choice List attributes that return more than one attributes.

Set Queryable Property on Attribute Programmatically

2010-03-31T04:23:00.000-07:00

Have you ever thought of programmatically changing the Queryable property of an Attribute in your View Object??

Download the sample application

Lets say that we have the following case:

We have a View Object (VO) with one view Criteria (VC). All attributes have by default set the 'Queryable' property to true. We are fine so far.

Then, the rain comes... We thought that attribute 'A' should become queryable only if an external parameter 'paramA' has value to 'true'.

Well, it is fairly easy to change the property..
In the sample application i have placed the following code in the VO Impl java class.

/**
* Changes the value of the Queryable property of an Attribute of this ViewObject.
* @param attrName String the name of the attribute.
* @param isQueryable Boolean the value to be set.
*/
public void changeQueryableProperty(String attrName, Boolean isQueryable){

ViewAttributeDefImpl[] vAttrDefImpls=this.getViewAttributeDefImpls();
int attrIndex=this.getAttributeIndexOf(attrName);
vAttrDefImpls[attrIndex].setQueriable(isQueryable);

//UPDATE:
// For those of you that have noticed
//that getViewAttributeDefImpls() is
//for internal use only.
//use the following code:

// AttributeDef[] attrs = this.getAttributeDefs();
// int attrIndex=this.getAttributeIndexOf(attrName);
// ViewAttributeDefImpl vida=(ViewAttributeDefImpl)attrs[attrIndex];
// vida.setQueriable(isQueryable);

}

In the example as you will see, i have placed two pages

NOTE: this is just an example of doing things in order to illustrate the less code to be written... The Declarative way.... You spin my head round round... :D

1) Main
2) Second

When we are navigating from Main to Second page we pass a pageFlowScope parameter and we are actually declaring whith attribute will be queryable or not.

I have exposed the method above in the client interface and created a methodAction in the page Defintion

Then I placed an InvokeAction in the Executables section of Seconds' pageDef, which will invoke changeQueryableProperty. As a refresh condition i placed 'prepareModel' option in order to be invoked during the initialisation of the iterators.

Download the sample application

Enjoy Life the way you Wantd!
Declarativelly!
cheers.

lock is owned by another session Embedded WebLogic

2009-06-19T03:20:00.000-07:00

UPDATE for new Release of JDeveloper:

the file now exists in:

C:\Documents and Settings\user\Application Data\JDeveloper\system11.1.1.1.33.54.07\DefaultDomain

remove the edit.lok from there.

---------------------------------------------------------------------------------

In JDeveloper 11.1.1.0.1, there is often some problem with Lock session:

weblogic.management.ManagementException: [Deployer:149164]The domain edit lock is owned by another session in exclusive mode - hence this deployment operation cannot proceed.

Simple solutions like restarting JDev, redeploying, clean , recompile and redeploy.. The problem persists.

Someone could easily suggest to remove system folder and restart JDev... But this will take time to reset your enviroment..

The session Lock is kept under Weblogic and in the following folder

C:\Oracle\Middleware\jdeveloper\system\system11.1.1.0.31.51.88\DefaultDomain

and is the file edit.lok.

rename it or remove it and start your application again. Weblogic will recreate the .lok file.

Starting OpenOffice 2.4 as a Service in Ubuntu

2009-03-29T04:24:00.000-07:00

This yet another post of how to start OpenOffice as headless Service:
After you have installed your OpenOffice.

navigate to the executables directory. this is under:

usr/lib/openoffice/program

and type the following command:

soffice -headless -accept="socket,host=127.0.0.1,port=8100;urp;StarOffice.ServiceManager;" -nofirststartwizard

For More information regarding this topic refer to the following links

http://wiki.services.openoffice.org/wiki/Uno/FAQ

http://udk.openoffice.org/common/man/spec/uno-url.html

Adding different ActionListeners Programmatically

2009-03-17T13:45:00.000-07:00

Here are some sample codes that anyone can use for adding different types of ActionListeners
to a RichCommandButton or RichCommandMenuItem or RichCommandToolbarButton Programmatically.

There might be cases that you need to add actions to some buttons programmatically; This means that you will need to search through the API to find out the appropriate java class of what you need. This Class saves you from this trouble and most of all saves you time!

I came across to this requirement and i think it might be very useful to others.

Also check Edwin Biemond's post for some handy code you might need.

Basically is a Utils Class called RichCommandComponentUtils.java and adds programmatically the following methods:

ActionListener
Action
ResetActionListener
FileDownLoadActionListener
ReturnListener

Each method has it's own MethodExpression method in order to be suitable for the component.
This can be very handy and useful in cases of Dynamically Generating Buttons as Andrej's post.
Of course it can be used where ever you think it is suitable

In a few words the process is this:

In order to have an ActionListener to , lets say a commandButton, porgrammatically we need to do the following steps:

Binding of the Button to a bean e.g. myActionListenerButton.
The ActionListener method which must have the following structure
public void anActionListener(ActionEvent anActionEvent) { ... }
And the Usage of the RichCommandComponent class as follows:
RichCommandComponentUtils.addActionListener( this.getMyActionListenerButton(),"#{main_Backing.anActionListener}");

And this is it.

Your button now has another ActionListener.
Here is a sample application that adds different types of listeners to some buttons.

In this sample application Listeners are added to the Buttons on Main and Second pages.
This happens on RenderResponce phase of each page.

NOTE: In the sample application I clear all actionListeners before adding some. This happens because actionListener are added which means that with this sample every time the page is rendered the Buttons will have plus one actionListener.

Feel free to update, fix, improve this Utils class. It is very usefull to me and other improved versions will come. Let me Know of what you think

regards!

Dependent LOV's in Query Criteria and View Accessor Workaround

2009-02-07T07:05:00.000-08:00

Cascade LOVs is a very common request in many applications (refer to Andrejus Baranovskis's post for how to implement here )

Also the usage of Query Criteria component(af:Query) in pages is a very good practice when Complex search is needed.

There is always the ability to add more fields and set operators as desired in order to make your search fit to your needs.

There is a problem when trying to add second time the same LOV attribute that has bind variable(either in SQL or via ViewCriteria) in Query Criteria component(through Advanced feature). When trying to add the same LOV for second time the application crashes...

The Test Case:

In order to follow the test case we run this sample application

NOTE: to following test case is simple and does not reflect real conditions for real Design of cascade LOVs, it is an example.

Lets say that we want to make a search by EmployeeId =any value and have the following case about ManagerId.

ManagerId must be greater than 1 AND must NOT be equal to 2.

ManagerId produces LOV from ManagersView(a second Employees View Object) with View Criteria defined and a bind Variable.

This bind variable accepts value from EmployeeId in EmployeesView Object through View Accessor.This is a typical filtering process.

In order to follow our test case we run this sample application

Press Advanced in Query Criteria,
Press Add Fields,
Click on Manager Id field.
Press Again Add Fields,
Click on Manager Id field again.

The Problem:

After pressing second time the ManagerId the following error appears:

Table is gone! You might get a 500 error page as well.

Stack Trace:

Stack Trace indicates that the second time the field is added, the Attribute EmployeeId cannot be evaluated. The problem is reproduced only for LOV fields that use bind variables. Any other fields can be added without a problem...

No matter if it is a feature or a bug, the problem persists and to bring your application back to working state a restart on the server is required!!.

The Work Around:

The solution to this problem is simple. A single line of code actually! Here is where Groovy comes to play. After reading Steve Muench's Tips and Tricks, i applied a very simple script. As you saw while running the application; the first time the LOV is added, the EmployeeId is evaluated correctly. The second time though, is not. For some reason, userData cannot find the attribute (and yet the question remains: is it a feature or a bug???).

Simply add the following Groovy script in the View Accessors of the View Object.

And Everything will work fine.

It is a simple check if the Attribute exists in UserData; if not, set value to null..