An interesting line up of international experts on Forms had joined their collective forces and minds to present the most complete overview of the Future of Forms available anywhere in the world today. From relatively new and specialized solutions such as OraPlayer and Yo!Forms to more proven (OraFormsFaces) and mature, architecturally driven future scenarios from PITSS and Oracle Consulting complemented with Forms modernization and integration stories as well as the official strategy from Oracle product management.

This article provides access to most presentations that were on offer during this day. Some other resources are listed as well.

Every speaker did a general presentation of about 30 minutes as an introduction to his or her special approach. Most speakers did a second presentation of 45 minutes in break out sessions to cover in more detail what was discussed briefly and as a teaser in the general session. Most speakers also did a hands-on, technical deep dive or Q&A session in the evening for an even more focused audience.

General session

Forms to Future – history, evolution, architecture and future – Lucas Jellema

Oracle Forms Product Strategy and Statement of Direction – Grant Ronald

Modernizing Forms using Pluggable Java Components and the Forms Look and Feel project – François Degrelle

To infinity and beyond: Extend the life of your Oracle Forms application by running your existing Forms from next generation technologies/platforms without migration – Mia Urman (and the video for the demo Mia showed: download 2Mb video)

Forms 11g, ADF and APEX: Co-existence in Enterprise Applications – Madi Serban

Rendering Forms to alternative platforms using YoForms – Oliver Tickell and Don Smith

Partial and or Gradual migration by embedding existing Forms in new UI technology – Wilfred van der Deijl

JHeadstart: Real world experiences for migrating Forms to ADF – Steven Davelaar

Parallel Break-Out sessions

Modernizing Forms using Pluggable Java Components and the Forms Look and Feel project – François Degrelle (this session consisted of demo, Q&A and technical discussions; no slides are available)

JHeadstart: Real world more detailed experiences for migrating Forms to ADF – Steven Davelaar (this session was a more detailed rendition of the general session by Steven Davelaar; there is no specific slide set for this session)

Demonstrating YoForms – on your laptop/ smartphone – Oliver Tickell and Don Smith (same slide-deck as for the general session)

Embedding existing Forms in new ADF applications using OraFormsFaces for perfect co-existence – Wilfred van der Deijl

Forms 11g, ADF and APEX: Co-existence in Enterprise Applications – Madi Serban

Run Oracle Forms business process from any UI (or service): Integrate, Go Mobile, SOA or BPM in minutes without migration – Mia Urman

Note: this session also showcased a number of demonstrations, available on YouTube:
1) Recording a simple Oracle Forms scenario using the unique OraPlayer Toolbar ;
2) Using the OraPlayer generator wizard to Wrap the scenario file recorded in step 1 with a Java API, then import it into Jdeveloper to create an ADF DataControl;
3) Create a default page in ADF to attach to the Forms business logic – http://youtu.be/A8eYcHWcx7s ;
4) Running an ADF system that runs 2 seperate Oracle Forms scenario’s from ADF buttons and ADF text boxes binded to OraPlayer output parameters (Oracle forms wrapped by OraPlayer)

Additional Resources

Some additional resources around the Future of Forms are listed here:

Tweets on the Future of Forms event

Gartner Report on Oracle Forms modernization options

Oracle Forms Product Statement of Direction

Mia Urman’s blogpost on the 15th of May event

Olivier Tickell’s article on the Future of Forms event

Grant Ronald’s blog article announcing the event

Lucas Jellema – The Future of Forms – Article in ODTUG Technical Journal, Q1 2012

Grant Ronald – Ten Years Younger -The Oracle Forms Makeover – Article in ODTUG Technical Journal, Q3 2011

The Future of Forms is …. Forms (and friends) – Presentation on Slideshare from UKOUG 2011 by Grant Ronald and Lucas Jellema

Websites and blogs for speakers, solutions and vendors

Forms Look and Feel Project

Oracle Forms Community – Pluggable Java Components & Java Beans; Library

Francois Degrelle’s Blog

PITSS.CON (Madi Serban)

YO!Forms (Oliver Tickell and Don Smith)

Snippets – blog by Oliver Tickell

JHeadstart 11g Product Center on OTN

Oracle JHeadstart Blog (Steven Davelaar et al.)

Mia Urman’s Blog

OraPlayer

AMIS Technology Blog (Lucas Jellema et al.)

OraFormsFaces (Wilfred van der Deijl)

Formspider

The 11g SOA Suite brings us the Service Fabric that has messages flowing from one SCA Service Component to the next – Mediators and BPEL processes are called from inbound adapter services or external consumers and may call out to references to external providers or outbound adapter service. In this idyllic world, much of the work actually going on is the mapping of messages from one (service’s) domain to the next. Of course we try to converse as much as possible in terms of canonical message structures, but sooner or later we come to the boundary of our domain and need to transform again to some domain or service specific message structure.

Domain Value Mapping

In addition to the mapping of the message structure, we usually have to put up with some level of value mapping as well: different domains frequently use -slightly or hugely -different labels for the same concept. One domain may use M, F and N for gender whereas another has MALE, FEMALE and UNKNOWN or even MAN, WOMAN and UNDECIDED. Messages that have to convey the gender will have to abide by the vocabulary in the target domain. That means that frequently message have to undergo domain value mapping in addition to plain structure-based transformation. The Mappings in the SOA Suite can make use of Domain Value Maps – dictionaries of domain specific values that are mapped across domains – and associated XPath functions that can do lookups in the DVM to replace a value from one domain – M – with the corresponding value from another domain – MALE.

Identity Mapping

A special type of value mapping concerns identity mapping. It is not uncommon for entities to exist in various domains. Patients, Suppliers, Doctors, Equipment and the likes more often than not are recorded in multiple systems – for example in the Financial and HR system, the Planning and Medical Information Systems. A specific entity has an identifier in each of these systems. However, this identifier – frequently a meaningless numerical value – is different in each system. For example: Dr. Boris Jankovic is known as 90210 in the Financial domain, has id-value 666 in the Planning application and is HMSA007 in the Medical Information system. When a message concerning this doctor is sent between services, we need to map the good doctor’s identity to maintain a reference to the same person in the context of each domain.

The Cross Reference functionality that the SOA Suite provides can be used to map identities across domains. This facility uses a database table – default name is XREF_DATA – that contains records per entity with the identity values in all domains. The definition of a cross reference is stored in a file, for example Doctor.xref. The file contains the name of the cross reference as well as all the End Systems (identity domains) that are mapped. This file is exposed from the MDS, to be used across components and composite applications. In addition to all real identity domains, it is a good idea to add a ‘canonical’ domain that contains the common or generic identifier that is used to identify the entity in all canonical, domain independent, messages that flow through the service fabric.

This article discusses and demonstrates the use of this cross reference functionality

The Cross Reference Table then logically looks like this:

	FINANCIAL	CANONICAL	PLANNING	MEDICAL
Boris Jankovic, Shrink	90210	92182172178326721	666	HMSA007
John Minder, Pediatrician	71243	82172178817273631	-	MYMY123

Note that not all entities need to exist – already or at all – in all End Systems.

Interacting with the Cross Reference at run time

The mapping itself is invoked through XPath functions in Mappings between XSD documents representing distinct (identity) domains. There is of course an XPath function to find the identity of an entity in a certain domain given the identity in another domain:

xref:lookupXRef(“Doctor.xref”,”FINANCIAL”,”90210″,”CANONICAL”,true())

This function call will access the Doctor cross reference to try to find the canonical identity for a Doctor identified by 90210 in the Financial domain. If no identity is found for this entity, an exception will be thrown, due to the last parameter being set to true. Note how similar this function is to the dvm:lookupValue() function.

However, the values in the Cross Reference are not static, as new entities are created, updated and even removed all the time. We have a set of XPath functions at our disposal to add, modify and remove entries from the Cross Reference (table). This allows us for example to ensure that when the ‘CreateDoctorInPlanningSystem’ service is invoked from the Financial domain, the Doctor is added to the Cross Reference with her identity in the Financial domain along with the new identity in the Planning System. The XPath function populateXRefRow is used like this to create a new record in the Cross Reference that contains the FINANCIAL identity as well as the CANONICAL identity. The latter identity is generated as GUID value. This value is also returned by the function and assigned in this XSL snippet to the identifier element in the target document:

<inp1:identifier>

<xsl:value-of select=’xref:populateXRefRow(“Doctor.xref”,”FINANCIAL”,/top:FinDoctorsCollection/top:FinDoctors/top:id,”CANONICAL”,orcl:generate-guid(),”ADD”)’/>

</inp1:identifier>

When we want to add the identity in another End System for an entity that already exists in the Cross Reference, we can use this XPath expression:

xref:populateXRefRow(“Doctor.xref”,”CANONICAL”,$initial.request/inp1:Doctor/inp1:identifier,”PLANNING”,/db:OutputParameters/db:ADD_STAFF_MEMBER,”LINK”)

Here we add the value in element ADD_STAFF_MEMBER as the Identity in the PLANNING domain to the Cross Reference record that has the value in inp1:identifier as its CANONICAL identity.

Example of using the Cross Reference facility

Let’s take a closer look at an example. The hospital has a FINANCIAL application; this is where doctors – records for doctors working in the hospital – are first created and get assigned their first identity. When a new doctor is created, this new doctor needs to be registered in the PLANNING application. This Planning domain has its own stubborn way of assigning identities to its records, so the doctor will get a second identity when registered in the Planning application.

We need to make sure that future message exchange between FINANCIAL and PLANNING regarding a specific doctor are correctly interpreted. Therefore, we need to build the Cross Reference to map doctor identities from and to these two systems. We will create a Composite Application that finds new doctor records in the FINANCIAL system and propagates them to PLANNING, meanwhile recording the identities from both FINANCIAL and PLANNING in the Cross Reference, as well as a canonical identity, assigned by the Composite Application.

The steps we go through:

Start JDeveloper; Create a new Application; Create a new SOA Project with Composite Application

Create a Mediator called PropagateAndXRefFDoctor. Its WSDL will be specified later.

Create a new Cross Reference, called Doctor:

Specify the first two End Systems – FINANCIAL and PLANNING. The press OK.

In the property page that now appear, add the third End System: CANONICAL.

Create an XSD with the Canonical Doctor message format:

Now we can create the WSDL for Mediator PropagateAndXRefFDoctor based on this XSD. The Mediator’s OfferNewDoctorForProcessing operation is one way (to reply) and takes a Canonical Doctor message as input.

Create a Database Adapter Service that polls for new records in the FIN_DOCTORS table (using the XREFFED_YN column as the logical delete flag). Note: the DoctorTables.sql script contains the DDL and DML statements for creating the table and its data.

Now wire the Database Adapter Service ReadNewDoctorRecords to a new Mediator ProcessNewDoctorsFromFinancialDomain.This Mediator has a simple task: map the messages from the Database Adapter Service to the Canonical Doctor format.

Create the required mapping DoctorFromFinancialDB_To_CanonicalDoctor.xsl.

The key element in this mapping is the function in the mapping from top:id in the source tree to inp1:identifier in the target tree: the code under the icon is:

<inp1:identifier>

<xsl:value-of select=’xref:populateXRefRow(“Doctor.xref”,”FINANCIAL”,/top:FinDoctorsCollection/top:FinDoctors/top:id,”CANONICAL”,orcl:generate-guid(),”ADD”)’/>

</inp1:identifier>

Here we use the populateXRefRow function to add a row to the Cross Reference Doctor. This new row has an Identity value for the FINANCIAL End System – derived from the top:id element which has the value from the FIN_DOCTORS table’s ID column for this doctor – and the CANONICAL identity, derived using the generate-guid() XPath function. When a message has been mapped using this XSL Map, an entry is created in the Cross Reference that maps a doctor between FINANCIAL and CANONICAL (two database records are created for this).

Wire this Mediator top to the second Mediator PropagateAndXRefFDoctor that deals in canonical messages only:

Now create a new Database Adapter Service CreateDoctorInPlanningDomain, outbound, that calls the Database PLSQL function add_staff_member, that will add the doctor to the table PLN_STAFF. The function will assign an identity to the doctor record in the PLANNING domain. It will return this identity to the invoker of the function.

create or replace function add_staff_member

( p_given_name in varchar2

, p_family_name in varchar2

, p_staff_role in varchar2

) return varchar2

is

l_id pln_staff.id%type;

begin

l_id := substr(extract(day from sysdate )|| to_char(sysdate,’SS’)||p_family_name,1,15);

insert into pln_staff

(id, given_name, family_name, staff_role)

values

( l_id

, p_given_name, p_family_name, p_staff_role

);

return l_id;

end;

Create the mapping from the Canonical Doctor message to the Input Message. This mapping is straightforward, no Cross Reference issues at this point.

However, the return message from the CreateDoctorInPlanningDomain service is something else altogether: that message contains the identity assigned to the doctor in the PLANNING domain. And that identity should somehow be added to the Cross Reference, associating it with the Canonical and the Financial identities for this same doctor.

We need to invoke the XPath function populateXRef() again, this time in the mode “LINK” – since we want to link a new identity value reference to an already existing entity record in the cross reference. The record we want to add this link to is found using the Canonical Identity – that we have in the Canonical Doctor message that was the input for the PropagateAndXRefFDoctor Mediator.

We first need the context for this XPath function to be executed. That means there has to be a Mapping for the response from the CreateDoctorInPlanningDomain service to another target service. The Mediator itself is one-way, it does not return a reply. So what we can do is send the response to another target service, meaningful or not, to have the identity in the PLANNING domain added to the Cross Reference.

Let’s create a File Adapter Service – WriteNewXReffedDoctorToLogFile – that writes every new doctor with his or her various identities to a log file. We go through the usual steps: create a sample file, run the File Adater Configuration Wizard and have it bring up the Native Format Builder wizard. Pretty soon we have the outbound File Adapter Service available.

We can now configure the Synchronous Reply part of the Routing Rule in the PropagateAndXRefDoctor Mediator. The target service for the reply is the outbound File Adapter Service.

In order to have access to the original request message sent to the mediator in the mapping of the reply from CreateDoctorInPlanningDomain to the WriteNewXReffedDoctorToLogFile service, we need to check the checkbox Include Request in Reply Payload when creating the mapping.

The Canonical Doctor Request message is available in the $initial.request XSL variable and is visible in the Source Tree in the visual mapper.

We will need to special XPath functions this time: one that adds the PLANNING identity to the Cross Reference, in much the same way as we saw before – using the Canonical Identifier from the original message:

The XPath function we need here is:

<imp1:PlanningIdentifier>

<xsl:value-of select=’xref:populateXRefRow(“Doctor.xref”,”CANONICAL”,$initial.request/inp1:Doctor/inp1:identifier,”PLANNING”,/db:OutputParameters/db:ADD_STAFF_MEMBER,”LINK”)’/>

</imp1:PlanningIdentifier>

We use the CANONICAL identifier to find the proper record in the Cross Reference Doctor.xref and add a link to this same record for the PLANNING identifier found in the ADD_STAFF_MEMBER element.

Next we also need to provide the value of the FINANCIAL identity to the Log File. However, that identity is not available in the Canonical Doctor message – as it should not of course. That means we have to use the Cross Reference to look up this financial identity – a perfect demonstration of the main purpose of that Cross Reference.

Instead of the populateXRefRow() function, this time we use lookupXRef(). Using the CANONICAL identifier in the Doctor(.xref) Cross Reference, we retrieve the identifier for the FINANCIAL End System:

In plain XSL code that looks like this:

<imp1:FinancialIdentifier>

<xsl:value-of select=’xref:lookupXRef(“Doctor.xref”,”CANONICAL”,$initial.request/inp1:Doctor/inp1:identifier,”FINANCIAL”,false())’/>

</imp1:FinancialIdentifier>

Summary

This completes our composite application. New doctor records in the FIN_DOCTORS table are found by the inbound database adapter service. This services pushes messages with doctor data to the first Mediator that maps them to the proper canonical format and creates a record in the Cross Reference with the Financial and Canonical identities for the new doctor record.

The second Mediator receives a canonical message and sends it – properly transformed – to the outbound database adapter service that uses the PL/SQL function add_staff_member to create the doctor in its PLN_STAFF table. The function and the service return the identifier assigned to the doctor in the PLANNING domain.

Finally, the second Mediator routes the response from the CreateDoctorInPlanningDomain – combined with the original request message – to the WriteNewXReffedDoctorToLogFile service. In the mapping to this outbound log-file writing service, the Planning identity of the doctor is added to the cross reference. The financial identity is retrieved from the cross reference to be added to the log file.

Deploying and Running the Composite Application

We deploy the composite application.

It picks up the records in the FIN_TABLE. When processing is complete, this is what the FIN_TABLE tells us:

And here is the now new contents in PLN_STAFF:

When we look in the XREF_DATA table that holds the data for the Cross References, we find these records:

Finally we check the log file that is written and there we find entries for each new doctor along with the three identities for each doctor.

It’s important to know that the UMS adapter does not work like a JMS topic or like EDN. So you can’t have two UMS adapters which are polling on the same mailbox.

In this blogpost I will show you how to setup and configure UMS, Listen plus send a mail and handle attachments.

We start with configuring our SOA Suite domain.

1st step is to copy two UMS libraries to your SOA Suite domain folder. Copy sdpmessagingclient.jar and sdpmessagingcommon.jar to the lib folder of the SOA Suite WebLogic Domain. You can find these jars at MiddlewareHome\Oracle_SOA1\communications\modules\oracle.sdp.client_11.1.1

2nd Install the UMS resource adapter.  Open the WebLogic Console and deploy the UMSAdapter.rar, you can find this adapter at MiddlewareHome\Oracle_SOA1\soa\connectors . Make sure you targeted this Resource Adapter to the SOA managed WebLogic server. And restart the SOA Suite Server.

3rd Check if the usermessagingdriver-email and usermessagingserver applications are active and targeted to the to the SOA managed WebLogic server. You can check this in the deployments of the weblogic console.

4th Configure the UMS Email driver.  For this we need to go the Enterprise Manager application. When everything is Ok you should see the User Messaging Service. Here we can select usermessagingdriver-email and in the menu we can go the Email Driver Properties.

Here we can set some defaults, like the default mail address, Cost and Speed ( cpu priority )

The UMS settings for outgoing mail.

The incoming settings are more complex because I will read two mail accounts, this is because I need one mail account for every polling UMS adapter.

To make this work I can use a “,” between the values so for IncomingMailIDs I use this as value soa@local.nl,soa2@local.nl , do the same for IncomingUserIDs = soa,soa2  and for the IncomingUserPasswords, I use CleartextPassword and also use a “,” between the passwords.

Restart the SOA Suite server.

At last we must enable the UMS adapter in JDeveloper.  Go to the JDev11.1.1.6\jdeveloper\integration\seed\soa\configuration folder and open the soa-config.xml. Find the adapterType with this ${UMS_ADAPTER_COMPONENT_NAME_L}  as name and remove the preview = true attribute. Now You will see the new UMS adapter in your SOA Component Palette.

In the next part we can finally try this out.

Let’s start with an easy one. Sending a mail from a composite. For this we need to drag the UMS adapter to the External Reference of the Composite.

Don’t change Connection JNDI name.

Choose for Outbound Send Notification. You can choose to receive the Mail Message Id as response, else it will be One Way.

Provide the Mail Header settings.

For Message Schema you got 3 options ( this talks about the mail body ) , off course Opaque, Message is a big String or based on a XML Schema.

Next we can take a look at incoming part of the UMS adapter. Drag the UMS adapter to exposed Services side of the composite.

Don’t change the default Connection JNDI Name

Choose Listener as Operation Mode, Polling does not work in this Preview Adapter and the UMS email driver already polls every few seconds.

Provide the mail adress this must match with your incoming UMS configuration.

Also provide the message type.

We can also define a message filter which can accept or ignore the incoming mails. The pattern string should be a java regexp. To test this pattern you can use this url  http://www.regexplanet.com/advanced/java/index.html

Too bad this feature does not work yet in this technical preview.

And also you can do a custom Java Callout ( I didn’t test it and don’t know the possibilities of this feature).

To test this I need to add the employee xml in the body of the mail ( not as attachment)  and send it to soa@local.nl. As response I will get a mail.

The request I will receive in SOA Suite.

And the response

Last part of this blogpost is about, how to handle mail attachments.

For this I will use the second mail address soa2@local.nl and also change the message type to String. A BPEL service component will write these attachments to a server location.

This is the request I received in the BPEL component. You can see that we only get a reference to the attachments.

So in BPEL we need to use a ForEach to handle every attachment and write this to a file.

To load the attachment and assign it to the file adapter input variable I need to use ora:getAttachmentContent

<assign name=”AssignInput”>
<copy>
<from>ora:getAttachmentContent(‘ReceiveMail_InputVariable’,'body’
,’/ns3:message/ns3:attachment/ns3:Attachment[$ForEachCounter]‘)
</from>
<to>$InvokeWriteFile_InputVariable.opaque</to>
</copy>
</assign>

and this leads to two files.

Here you can download the UMS workspace https://github.com/biemond/soa11g_examples/tree/master/UmsSOA

Today, finally also paying attention to the last slide on almost all presentations, I had a look at: http://www.oracle.com/goto/oll . This is the entry page of the Oracle E-Learning group. This link will re-direct you to the central, by Oracle APEX serviced, pages that contain an overview of all the Oracle topics out there, provided via the E-Learning team and believe me, those are great, also one of the reasons I subscribed on their YouTube Channel anyway. I really wished I had done it sooner though. It not also provides with a great overview, it also has a link to the mobile device link (up in the left corner) that can be used with your mobile phone or iPad/Android alternative to read and see those resources. Probably the most coolest thing, and really thanks for that, is the “Bookmark” bit. If you click it, you will be asked to authenticate yourself via your Oracle OTN account, which gives you a central place to tag the bookmarks you find useful, search in all available topics. If, like AMIS, you participate (and are allowed access to) in a lot of Oracle beta testing of different products, there will also a beta button that guides you to the latest demo’s on those features and products.

In all, a great service from Oracle to those who want to accelerate their knowledge or lookup a demo after having read about it in the Oracle manuals.

HTH with the links provided in this post

Natuurlijk, er zijn allerlei nieuwe tools en technologieen om compleet nieuwe applicaties te ontwikkelen, maar dat is helemaal niet zo aanlokkelijk. De bestaande investering in de Forms-applicatie dreigt verloren te gaan en de kennis en vaardigheden die ontwikkelaars moeten opbouwen voor een ander platform zijn zeer aanzienlijk. Er zijn vast subtielere manieren om de huidige Forms applicaties te moderniseren en met moderne technologie te combineren.

Op dinsdag 15 mei organiseert AMIS een evenement onder de titel: “The Future of Forms” – bedoeld voor ervaren Forms ontwikkelaars en applicatie architecten van Forms applicaties. De vragen die hierboven worden gesteld komen op deze dag aan bod en diverse manieren en tools om met Forms te moderniseren worden gepresenteerd, gedemonstreerd en bediscussieerd. Als je serieus bezig bent met de toekomst van de Forms applicaties in jouw organisatie – en je eigen toekomst natuurlijk – dan zou je dit bijzondere evenement niet mogen missen.

Erkende sprekers uit Nederland, Duitsland, Frankrijk, UK en Israel verzorgen een uitgebreid programma aan presentaties en demonstraties, vanaf ‘s ochtends 9 uur tot pakweg 17.30. Zie voor de details van het programma: Dagprogramma 15 mei Future of Forms. De toegang tot dit evenement is gratis. Aanmelden kan via de website: registreren voor The Future of Forms.

Het programma voor 15 mei staat hier weergegeven. NB: er is ook een avondprogramma met hands-on sessies. Hierin kan je kiezen uit zes verschillende workshops waarin je in detail kennis kan maken met een van verschillende moderniseringsrichtingen. Zie voor details over dit avondprogramma: The Future of Forms – Workshops & Deep Dive.

De korte beschrijvingen van de presentaties zijn als volgt:

Forms to Future – history, evolution, architecture and future – Lucas Jellema
Oracle Forms starting from its earliest incarnations have been around for more than a quarter of century. The vast majority of today’s Forms – and Forms developers – have their roots in mid-90s Client/Server technology- even though WebForms introduced widely adopted three-tier deployment. The world obviously has changed. End user groups are more diverse with different and more advanced needs, working on flexible locations and odd moments. Technology advances have been made on different platforms and devices, new architecture patterns have been embraced and agile development striving for business agility is all the rage. Applications developed using Forms technology have not seen a lot of change. And it is about time that they do. This session looks back at the long history of Forms and the key ingredients to its success. It then quickly focuses on where business and end-user requirements are today and what approaches are available for meeting current and future demands with the current Forms applications as starting point.

The main approaches available for ‘a Future from [and quite possibly with] Forms’ to be discussed are:
 Evolve/improve/”pimp’ existing Forms, continue to run as Forms with a modern look and feel
 Integrate Forms a in SOA environment – hook up to push-mechanisms, queuing interaction and workflow managers
 Embed in Web 2.0 (UI integration with ADF, .NET or other ‘modern’ web technologies)
 Wrap as service (publish business logic from Forms and reuse with new User Interfaces or WebServices on top of them)
 Render to new platforms (render Forms as they are to new platforms such as Java free browsers and mobile devices)
 Migrate to new technology stack and architecture (semi)-automatically migrate/convert Forms to a new technology
 Migrate to new technology stack and architecture : rebuild functionality from scratch in a new technology stack – leveraging functionality and experience from the Forms application – but no more
Each of this approaches is subsequently discussed in much more detail by the speakers that contribute to this event.

Modernizing Forms using Pluggable Java Components and the Forms Look and Feel project – François Degrelle
In this presentation, we will see that Oracle Forms is an open product into which we can plug third party widgets to increase the capabilities. These plug-ins are called “Java Beans” and can push the standard product boundaries. As an example, you will see a presentation and a demonstration of the “Forms Look and Feel Project” plug-in, that is a set of tools that permits decorating a Forms module by reading the graphical properties from an external CSS file, and also providing over one hundred new features. You will learn how the PJC-architecture and the substantial library of community contributed components easily allow for adding attractive, modern features to your Forms – including Google Maps and PDF Reader.

To infinity and beyond: Extend the life of your Oracle Forms application by running your existing Forms from next generation technologies/platforms without migration – Mia Urman

Does your Oracle Forms system have core business logic that you wish you could share as business processes or webservices? Want to integrate Forms with your next generation systems without costly and risky migration projects? Then we have a solution for you! In this brief session we will present OraPlayer, a tool that allows companies to wrap the business logic trapped within their Oracle Forms systems and upgrade fast-track to a modernized, SOA or mobile enabled environment.

Forms 11g, ADF and APEX: Co-existence in Enterprise Applications – Madi Serban & Andreas Gaede
For some time now, Oracle Forms has addressed all the needs for database development. And it still does. The next challenge is taking advantage of the newest features in Forms 11g and integrating enterprise Forms applications with other modern technologies, like ADF and APEX. We will present and exemplify live our first-hand experience of migrating large, enterprise Oracle Forms applications to Forms 11g, ADF and APEX. The exemplified case studies are taken from our latest migration projects. The demonstration will not only take into consideration the web layout redesign, but will also offer solutions for dealing with true challenges like: how to assess the amount of work, how to re-use components and preserve the investment in Oracle Forms, how to ensure a smooth coexistence of Forms 11g, ADF and APEX. Come and join us in discussing the lessons we have learnt from our latest migration projects, the dos and don’ts and much more.

Rendering Forms to alternative platforms using YoForms – Oliver Tickell & Don Smith
One aspect of the communications revolution of recent years is the ubiquity of handheld devices – iPads, Blackberries, Androids and numerous generic Smartphones. Increasingly Forms users want to deploy their applications to such devices – and to do so in a universal way so as not to be tied to any particular technology. We determined that this would best be achieved by rendering to the browser using only HTML and JavaScript. A further requirement was pixel-accurate rendition – necessary because so many forms are laid out with pixel accuracy. We also wanted to reproduce precisely the original functionality so that Forms users would experience no change in application behaviour. We were intially uncertain if this would even be possible. But we can now tell you that not only is it possible, but we have done it. Our solution, YoForms, is written entirely in JEE6 enterprise Java and runs on any standards compliant application server. It communicates with the browser via a lightweight AJAX layer designed to minimise traffic volume, and uses a small subset of HTML features to eliminate browser / device-specific display variations.

In our first presentation we will set out the overall architecture of YoForms and will demonstrate its operation on a low-performance laptop computer running Windows XP, Oracle 10g XE database, Apache Tomcat application server, and Internet Explorer, Google Chrome and Mozilla Firefox.

Partial and or Gradual migration by embedding existing Forms in new UI technology – Wilfred van der Deijl
Thousands of companies have a large investment in Oracle Forms, often running their core applications. Many are considering moving to Oracle JDeveloper and Oracle Application Development Framework (ADF) to enter the new era of enterprise application development. Oracle does not offer a migration solution other than re-developing your application in ADF. This brief session introduces OraFormsFaces, a toolkit that allows you to integrate existing Forms applications in your new ADF, or other, web application. This allows for a hybrid application consisting of both Oracle Forms and new web technology. Over time you can remove individual Forms and replace them with new web technology.

JHeadstart: Real world experiences for migrating Forms to ADF – Steven Davelaar

In this presentation Steven will share his experiences with various customers he helped moving from Oracle Forms to ADF. He will explain how the JHeadstart toolkit helped these customers. In addition he will discuss common pitfalls, lessons learned, and some guidelines that can be extracted from these modernization projects.

Parallel Sessions

Run Oracle Forms business process from any UI (or service): Integrate, Go Mobile, SOA or BPM in minutes without migration – Mia Urman
Having trouble integrating your Oracle Forms applications with other Java/ADF/.Net / APEX/ portal systems in your organization? Want to enter the Mobile, Cloud or SOA world with your EXISTING Forms applications? Want to create webservices or ADF data controls from Forms business processes? Well we can help! In this brief session I will show how using OraPlayer we can reuse the business logic trapped within our existing Oracle Forms systems and deploy to new environments and platforms without costly and risky migration projects. Including live demos of running Oracle Forms business logic silently from an ADF faces UI and a mobile application.

More details on Modernizing Forms using Pluggable Java Components and the Forms Look and Feel project – François Degrelle
In this presentation, we will see that Oracle Forms is an open product into which we can plug third party widgets to increase the capabilities. These plug-ins are called “Java Beans” and can push the standard product boundaries. As an example, you will see a presentation and a demonstration of the “Forms Look and Feel Project” plug-in, that is a set of tools that permits decorating a Forms module by reading the graphical properties from an external CSS file, and also providing over one hundred new features. You will learn how the PJC-architecture and the substantial library of community contributed components easily allow for adding attractive, modern features to your Forms – including Google Maps and PDF Reader.

JHeadstart in depth: Real world experiences for migrating Forms to ADF – Steven Davelaar
In this presentation Steven will share his experiences with various customers he helped moving from Oracle Forms to ADF. He will explain how the JHeadstart toolkit helped these customers. In addition he will discuss common pitfalls, lessons learned, and some guidelines that can be extracted from these modernization projects.

Demonstrating YoForms – on your laptop / smartphone – Oliver Tickell & Don Smith
In our second presentation we will make our YoForms application available to participants via a local WiFi network, so that they can access it on their laptop, notebook, smartphone or any other device equipped with a browser. The session will feature the application itself, and the ‘treeview’ which presents any open YoForms session in tree format, including both form definition and live application data. Users will be able to edit the live session and observe the result take immediate effect.

Embedding existing Forms in new ADF applications using OraFormsFaces for perfect co-existence – Wilfred van der Deijl
After the brief session explaining the unique benefits of OraFormsFaces, this session will go into more detail. We will demonstrate, with live demos, how to take an existing Oracle Forms application and to integrate it with a basic ADF application. You can see how little, if any, changes are needed to the Forms application and how easy it is to use the OraFormsFaces JSF components within JDeveloper. Keep in mind, that even though the demo focuses on ADF and JDeveloper you can use OraFormsFaces with any HTML/JavaScript web technology.

Forms 11g, ADF and APEX: Co-existence in Enterprise Applications – Madi Serban & Andreas Gaede
For some time now, Oracle Forms has addressed all the needs for database development. And it still does. The next challenge is taking advantage of the newest features in Forms 11g and integrating enterprise Forms applications with other modern technologies, like ADF and APEX. We will present and exemplify live our first-hand experience of migrating large, enterprise Oracle Forms applications to Forms 11g, ADF and APEX. The exemplified case studies are taken from our latest migration projects. The demonstration will not only take into consideration the web layout redesign, but will also offer solutions for dealing with true challenges like: how to assess the amount of work, how to re-use components and preserve the investment in Oracle Forms, how to ensure a smooth coexistence of Forms 11g, ADF and APEX. Come and join us in discussing the lessons we have learnt from our latest migration projects, the dos and don’ts and much more.

The Future of Forms

Many organizations embarked on Oracle Forms at some point in the ’90s. Terminal-based (3.0 and before), Client/Server or using the Forms applet in a Web Browser. And in many of those organizations, the application(s) built in Forms are still an important factor. Key applications providing core back office functionality for a fairly highly skilled end user community.

Change is coming though. From the business and the end users of these applications, requirements are stated for more modern, more user friendly and more intuitive user interfaces – that for some functionality should be available on mobile devices as well. And this functionality should be delivered in an agile way: flexible with a high rate of quickly applied changes.

The technology arena has also undergone some dramatic changes. Client/Server is largely gone and use of Applets is also somewhat frowned upon. A traditional data-driven user interface (CRUD-style) is not acceptable anymore. HTML (Web 2.0) UIs for browser and mobile is much more in vogue. And of course the application needs to interact with the Service Oriented Architecture. Forms is no longer the strategic development platform at Oracle for applications with a User Interface (ADF has taken over that role). However, Oracle is still evolving Forms and Forms 11g today offers many options for creating a fairly modern and advanced user interface.
Abandoning Forms is not really an option for the short term. The investment needed to completely replace the Forms application is simply too big and time it will take too long to even seriously consider. Besides, there is generally no real need to completely drop the Forms application. The business requirements can frequently addressed for only selected areas of functionality and specific groups of users, using a variety of methods – most of them allowing for a hybrid scenario where Forms and other technologies are blended together:
•    evolve/improve/”pimp’ existing Forms that continue to run as Forms with modern look and feel
•    integrate Forms in a SOA & BPM environment
•    embed Forms in Web 2.0 – UI integration with ADF, .NET or other ‘modern’ web technologies
•    wrap Forms as service (publish business logic from Forms and reuse with new UIs or WebServices on top of them)
•    render Forms to new platforms (render existing Forms as they are to new platforms such as Mobile browsers)
•    migrate (selected) Forms to a new technology
•    rebuilt (selected) Forms in a new technology

During this event, several experts will present and demonstrate their vision and possible solutions – including Wilfred vd Deijl with OraFormsFaces, Mia Urman with OraPlayer, and Steven Davelaar demonstrating JHeadstart, as well as Francois Degrelle showing Pluggable Java Components and the Forms Look & Feel project, Oliver Tickell with YoForms and Madi Serban presenting the migration solutions from PITSS. Lucas Jellema kicks off with a presentation on the history, evolution and future of Forms and its role in an enterprise architecture and the day is concluded with a panel discussion with all the experts, discussing the future of Forms. After dinner, for real “techies”, there is option of technical deep dive & hands-on sessions.

The following document provides in depth details on program for this day: http://www.amis.nl/theme/amis/uploadedFiles/PDF/Future%20of%20Forms%20EN%20DAG.pdf.

Registration for this all- day event can be done via: http://www.amis.nl/event-inschrijving/?event_id=41.

Evening Session – Technical Deep Dive and Hands-On

In the evening, a second event is staged, where in technical deep dive and hands-on sessions, experienced developers can get up close and personal with six modernization options. This evening gives the perfect opportunity for Forms developers to get a hands-on experience with one or two methods for modernizing the Forms experience. The architects of a number of largely complementary solutions to the modernization challenge will host up close & personal sessions where in depth questions can be asked, experiences discussed and tools tried out. Strong technical skills and several years for Forms experience are strongly recommended to truly benefit from the availability of this fine selection of speakers.

The following document provides in depth details on the six sessions staged in the evening http://www.amis.nl/theme/amis/uploadedFiles/PDF/Future%20of%20Forms%20EN%20AVOND.pdf.

Registration for this technical evening event can be done via: http://www.amis.nl/event-inschrijving/?event_id=44.

Hands-on and In-Depth Sessions

Migrating Real Life Applications to Forms11g, ADF and APEX (Madi Serban & Andreas Gaede)
Join us in a practical session of migrating real life applications to Forms 11g, ADF and APEX. Got a complex application or migration example? We will take the challenge! We will discuss and exemplify the most interesting situations and solutions met in our latest projects.

Getting hands-on with YoForms (Oliver Tickell and Don Smith)
One aspect of the communications revolution of recent years is the ubiquity of handheld devices – iPads, Blackberries, Androids and numerous generic Smartphones. Increasingly Forms users want to deploy their applications to such devices – and to do so in a universal way so as not to be tied to any particular technology. We determined that this would best be achieved by rendering to the browser using only HTML and JavaScript. A further requirement was pixel-accurate rendition – necessary because so many forms are laid out with pixel accuracy. We also wanted to reproduce precisely the original functionality so that Forms users would experience no change in application behaviour. We were intially uncertain if this would even be possible. But we can now tell you that not only is it possible, but we have done it. Our solution, YoForms, is written entirely in JEE6 enterprise Java and runs on any standards compliant application server. It communicates with the browser via a lightweight AJAX layer designed to minimise traffic volume, and uses a small subset of HTML features to eliminate browser / device-specific display variations.

We will use this hands-on session to explore areas of particular interest in greater depth, in an informal and responsive style. YoForms will again be enabled over the WiFi network to facilitate a fully interactive approach.

OraPlayer Handson: Two heads are better than one: Create HTML,ADF and Mobile UI’s for an existing Oracle Forms business processes (service). (Mia Urman)

In this session you will see first-hand how you can run Oracle Forms business processes from any technology or UI. We will show how the same Oracle Forms system runs with the usual java applet on weblogic, then from a pure HTML UI in the browser, then from an ADF faces application using an “OraPlayer-Forms business process” data control and finally on your OWN mobile phone (wireless network permitting). We will then see how easy it is to maintain ( maintain one system and delpoy anywhere) when we change the FMB’s business logic in the Forms developer and see the change automatically reflected in all the UI’s.

JHeadstart Hands-on (Steven Davelaar)

By following this hands-on session, you’ll experience first-hand how Oracle JHeadstart 11g can help you in building a best-practice ADF web application. You will built a transactional web application based on 6 tables of the Oracle HR schema, that includes rich functionality like quick and advanced search, a wizard in a popup window, a shuttle picker, a tree control, validation using list of values, conditionally dependent items, a graph, dynamic breadcrumbs, context-sensitive linking, validation rules and multi-language support. In addition, you will see how you can easily customize the generated artifacts and how you can preserve these customizations upon regeneration. Since no Java coding is required to implement the tutorial, even developers with minimal-to-no Java skills can follow along.

Deep dive with OraFormsFaces (Wilfred van der Deijl)
While the time is too short for a complete environment set up and initiation to ADF – the first natural habitat for embedd Forms wih OraFormsFaces, this deep dive is not so much about hands-on, but intended to take a deep dive with OraFormsFaces. Wilfred will show advanced demos, explain about real life experiences gathered around the world and discuss various migration strategies. In this intimate setting, there is also plenty of opportunity for discussion and detailed Q&A.

Forms 11g – How modern can Forms itself be? (Lucas Jellema)
Forms 11g is quite something else than Forms 6.0. Many features have been added over the last decade, including Pluggable Java Components, Java Script integration, SOA integration and the WebLogic Server infrastructure. As a result, quite attractive, modern looking and interacting applications can be created using Forms 11g. In this hands-on session, participants will receive a Virtual Machine with Forms 11g and a number of labs that clearly demonstrate the power of some of these new features and make evident that a revitalization of Forms is within reach. To participate in this session, Forms development skills are a prerequisite.

In front of a live audience, the challenge was outlined. The high level design introduced and the various components discussed. The left-hand screen (for the audience) displayed the business process and the work done to it in terms of design and implementation. The screen in the middle demonstrated the user interface development using ADF and the right hand screen played various roles, from service development to Enterprise Manager display, BPM worklist and Email client.

The members of the band played the following instruments: Steven on ADF and JHeadstart, Luc on ADF and ADF DVT (Data Visualization Components) for the business dashboard, Ronald on SOA Suite – Mediator, Adapters – and Lonneke on BPEL and Human Task. Edwin played virtually every instruments and Lucas was the lead singer and audience participation person.

Being a fairly unknown group of artists, we do not yet have the luxury of groupies and roadies that prepare the stage for us.

Here is what we had accomplished after the first architectural discussions about the layout of our performance area:

Next the cables for the network:

and:

Then the real work got underway:

The business challenges by the way was the following: the company organizing conferences such as ODTUG, UKOUG, OBUG and OOW has this key business process of coordinating the presentations that make up the beef of the conference. This process is started with speakers submitting abstracts that need to be reviewed; upon acceptance, the speaker needs to upload the slides for the presentation, the presentation should be planned in the overall schedule, the speaker should be informed and when the presentation has taken place, an evaluation should be executed and the results fed back to the speaker. Only then – weeks and months after it was commenced – is the process complete.

During this live development show, we implemented two user interfaces (yellow tier in the picture below): the Speaker Portal and the Back Office Portal – the latter including the Dashboard. The Portals communicate with the database (green tier) via ADF BC, with the Human Workflow Engine in the SOA Suite and with the Event Delivery Network, also in the SOA Suite (red tier). The process coordination or orchestration takes place in BPEL (could also be BPM) and is positioned in the blue tier. The process works with various services and adapters – the red tier again – to get started, allocate tasks and retrieve and manipulate data.

Even though we have done it before, we can also do it better and a lot of discussion and brainstorming takes place during the session:

much to the enlightenment of the audience:

and work continues during our own breaks – when the audience is in the break-out sessions around the conference venue:

We were able to complete the session with an end-to-end demo of a speaker submitting an abstract through the speaker portal, the dashboard being updated with this information in the back office portal, a message getting published to AQ in the database, triggering an inbound AQ adapter that initiates a SOA Composite application. After the initial transformation, the Mediator in this instance invoked the Business Process – a second SOA Composite with a BPEL process and several Human Task components. The BPEL process initiates a Human Task allocated to the Back Office staff. An email is sent to all staff members and through the special Task UI in the Back Office Portal – ADF interacting with the Human Workflow API – the abstract submitted by the speaker is accepted. The process continues now the task is complete, updates the database via a service call and sends an email to inform the speaker of acceptance (or rejection) and a request for uploading the slides of the presentation via the speaker portal. The upload will cause the speaker portal to publish an event – slides uploaded event – from ADF BC to the Event Delivery Network in SOA Suite where the process will pick it up and once again continue with the next step – a human task for scheduling the exact slot for the presentation.

As always, it was great fun to collaborate with this high class team. Great job. We should do it again some time…

Many articles and presentations discuss various parts of Oracle Fusion Middleware, such as ADF or SOA Suite, WebCenter or Oracle Service Bus. Usually they do so in an isolated fashion and not seldom only in a theoretical (‘slideware’) fashion. In this very special session, attendees will see at close range how it all comes together and what steps are necessary to create a real end-to-end FMW application. A team of brave developers (doing database, ADF, SOA Suite, OSB and BPM) will develop an end-to-end Fusion Middleware application over the course of the afternoon. Their work will be monitored live on a number of big screens, while a moderator solicits audience suggestions for functional requirements and explains what is being done.

Many concepts and components from FMW appear in an integrated, meaningful context during this session. Attendees will now see first hand how it all comes together and what steps are necessary to create a real FMW application. They also get the chance to participate, help direct the team effort by contributing to the functional requirements, ask questions, get live demonstrations for an answer and get real insight in the FMW development process. This is the perfect way for the audience to get from an abstract idea of what FMW is all about to a clear understanding of what the Fusion Middleware development tools look like and how developers will work together in creating mutually interacting components that together constitute a FMW application architecture.

If you ever wondered about Fusion Middleware development – what it actually entails to create an ADF application or implement a SOA Suite Composite Application or what you should do to design a business process using BPM and implement a custom user interface for performing the human tasks in the process and what options are available to exchange events and achieve data integration across tiers – then this session will bring it all to life for you.

This session is a walk-in event – that you can also walk out of. Just come and watch the demo for short while or join for the full three hour event. Pick and choose as you like, to get the most out of it.

The team that staged this event at the ODTUG 2011 (Long Beach, California) and UKOUG 2011 (Birmingham, UK) now brings it home to Maastricht. Among its members are Fusion Middleware specialists from Vennster and AMIS Services, including Lonneke Dikmans, Ronald van Luttikhuizen, Luc Bors, Edwin Biemond and Lucas Jellema complemented with well know Oracle veteran Steven Davelaar from Oracle Consulting Services.

More details on OBUG 2012 are here: : http://www.obug.nl/images/stories/2012/Publish%20Connect%20program/index.html. Registration for this OBUG conference is done via http://www.obug.nl/index.php?option=com_ckforms&view=ckforms&id=8&lang=nl.

In a SOA environment I have a humantask in a BPEL process. The humantask has an Approve and a Reject outcome.
The humantask offers the possibility to change al kinds of process related data. By default these changes are not saved when you press the Approve or Reject button. As a result It happens often that changes are not saved by making the mistake not saving changes before Approvement.

Change the default button behaviour

In this blog I will decribe how to change the behaviour behind the ‘Approve’ button. I will change it to ‘Save and Approve’. On first hand I though this would be very simple. Add a second action to the button and tha’s all. But it is not possible to directly bind multiple actions to a button. However it is still possible by binding a new action to the button that on it’s turn executes multiple actions.

This can be implemented with a Managed Bean. I will descibe how to create the Managed Bean and to bind it to the Approve  and Reject button. 

At first, open the humantask (jspx file). In source mode find the ‘Approve’ commandToolbarButton.

Change the values of the Action and ActionListener properties. You can do this directly in the source code or via the properties window in the bottom-right. I prefer this last option because it makes things a litle easier.

Select the left arrow behind Action. Then select ‘closeTaskFlow’.  This takes care of closing the taskform after pressing the Approve button.

Now, select the right arrow behind ActionListener. Then select Edit. The following window appears.

Select ‘New’ behind Managed Bean.
Specify the Bean details as shown in the image below:

After pressing OK we will get back in the ’Edit Property’ window. The name of the new Managed Bean is shown.
Add a method to the Bean. Press New behind Method.

Specify a Method name (e.g. saveApprove) and press OK

Press OK again.

A java class ‘MedewerkerHT.java’ is now available in the Application Source. Change/replace the source code of this class:

package amis.nl;

import javax.faces.event.ActionEvent;
import oracle.adf.model.BindingContext;
import oracle.binding.BindingContainer;
import oracle.binding.OperationBinding;

public class MedewerkerHT {
    public MedewerkerHT() {
    }

    public void saveApprove(ActionEvent actionEvent) {

        // Save changes
  BindingContainer bindings = BindingContext.getCurrent().getCurrentBindingsEntry(); 
        OperationBinding method = bindings.getOperationBinding("update"); 
        if (method != null) {
            method.execute(); 
        }

       // Perform original function
        bindings = BindingContext.getCurrent().getCurrentBindingsEntry(); 
        method = bindings.getOperationBinding("APPROVE"); 
        if (method != null) {
            method.execute();
        }
    } 

    public void saveReject(ActionEvent actionEvent) {
        // Save changes
  BindingContainer bindings = BindingContext.getCurrent().getCurrentBindingsEntry(); 
        OperationBinding method = bindings.getOperationBinding("update"); 
        if (method != null) {
            method.execute(); 
        }

        // Perform original function
        bindings = BindingContext.getCurrent().getCurrentBindingsEntry(); 
        method = bindings.getOperationBinding("REJECT"); 
        if (method != null) {
            method.execute();
        }
    } 
}

The class contains the implementation for both the Approve and the Reject Button.

In the humantask the sourcecode of the commandToolbarButton is changed into:

&lt;af:commandToolbarButton actionListener="#{<strong>customization.saveApprove</strong>}"
             text="#{wf:getResourceValue('APPROVE', 'bindings.customActions')}"
              disabled="#{!bindings.APPROVE.enabled}"
              action="<strong>closeTaskFlow</strong>"
              partialSubmit="false"
              visible="#{wf:isCustomActionAvailable('APPROVE', 'bindings.customActions')}"
       id="ctb2"&gt;
                    &lt;f:attribute name="DC_OPERATION_BINDING" value="bindings.APPROVE"/&gt;
&lt;/af:commandToolbarButton&gt;

The actionListener is binded to the new created Managed Bean

For the reject button almost the same steps are required. Even though it is not needed to create the Bean and Method again. Now it is possible to select the existing one.

The two functions are now binded to the same button.

But some more things, headers en footers:
[code]
declare
t_rc sys_refcursor;
t_query varchar2(1000);
begin
as_pdf3.init;
as_pdf3.load_ttf_font( 'MY_FONTS', 'COLONNA.TTF', 'CID' );
as_pdf3.set_page_proc( q'~
begin
as_pdf3.set_font( 'helvetica', 8 );
as_pdf3.put_txt( 10, 15, 'Page #PAGE_NR# of "PAGE_COUNT#' );
as_pdf3.set_font( 'helvetica', 12 );
as_pdf3.put_txt( 350, 15, 'This is a footer text' );
as_pdf3.set_font( 'helvetica', 'B', 15 );
as_pdf3.put_txt( 200, 780, 'This is a header text' );
as_pdf3.put_image( 'MY_DIR', 'amis.jpg', 500, 15 );
end;~' );
as_pdf3.set_page_proc( q'~
begin
as_pdf3.set_font( 'Colonna MT', 'N', 50 );
as_pdf3.put_txt( 150, 200, 'Watermark Watermark Watermark', 60 );
end;~' );
t_query := 'select rownum, sysdate + level, ''example'' || level from dual connect by level as_pdf3.query2table( t_query );
open t_rc for t_query;
as_pdf3.refcursor2table( t_rc );
as_pdf3.save_pdf;
end;
[/code]

And the code for this package: as_pdf3