Main

Using Inforama Service with .Net Clients 1.2

2010-08-04T00:36:52Z

== Using Inforama Service with .Net Clients == === WCF === When using a WCF client to connect to Inforama Service, you may encounter errors about missing doc parts: //{... Error reading body: System.Xml.XmlException: MIME part with Content-ID 'cid:f985237a-cf1a-439e-81aa-a0998e7d8e4d@http%3A%2F%2Fcxf.apache.org%2F' not found. ...}// The issue is often caused by the use of [[http://en.wikipedia.org/wiki/MTOM|MTOM]] encoding from Inforama Server. To fix the issue: === Under Tomcat === Make the following changes in: * DocumentManagerImpl * RepositoryManagerImpl * DocumentGeneratorImpl in the namespace ///org/in4ama/documentservice// # Remove the @MTOM Annotation above the @WebService declaration # Recompile # Redeploy

Integrating Inforama with SugarCRM 1.7 (minor-edit)

2010-04-28T11:15:16Z

The new Rest services in Inforama now make it even easier to call Inforama from PHP based systems such as SugarCRM or Moodle. In this example we will show how easy it is to start producing documents from Inforama templates via the SugarCRM interface. We'll use the SugarCRM

Getting Started

Anyone who is familiar with SugarCRM will know that its default installation uses a MySQL database and sets up a contacts table which allows users to instantly start recording contact information. Within Inforama Studio create a new project and define a new connection to the SugarCRM database.

Connecting to the SugarCRM database in Inforama Studio

Next create a dataset which will return the details of a particular contact based on the unique id field.

Define the dataset that will be used in letter templates

This project has a 'contact_id' parameter defined in it which will be passed to the Inforama engine when generating contact correspondence. The query which is used is "SELECT id, first_name, last_name FROM contacts WHERE id = '$P{contact_id}'".

Next create letter templates that you wish to make available from SugarCRM. As usual the fields defined in the data frame on the right of the Studio are listed and can be double-clicked in order to insert the data bindings into the template.

Define a letter template

Setup on Inforama Enterprise

Now that the basics of the project have been created it can be deployed to the server running Inforama Enterprise. Click the Project - Compile menu item and then the Project - Deploy.

The Studio deployment dialog

Now in the Inforama Enterprise you will see the project listed.

The project within Inforama Enterprise

Customisation of SugarCRM

The project has been deployed to Inforama Enterprise and is ready to be called from SugarCRM. In this example we want to print Inforama documents from the contact details page so we need to create a custom button on that page. Begin by editing the file 'sugarcrm\custom\modules\Contacts\metadata\detailviewdefs.php'. This file is created by the studio in SugarCRM whenever customisations are made to the application. The following code shows how a print button is added to the list of buttons at the top of the page.

array ( 0 => 'EDIT', 1 => 'DUPLICATE', 2 => 'DELETE', 3 => 'FIND_DUPLICATES', 4 => array ( 'customCode' => '<input title="Print Document" class="button" onclick="javascript:printDoc(\'{$fields.id.value}\');return false;" type="submit" name="Print Document" value="Print Document">', ), ),

This code creates a new custom print button on the contacts details page as shown below.

The custom print button in the Contact details page

The customCode element in the array defines a new input button and attaches a javascript handler to it for click events. The printDoc javascript event is defined in the following HTML code. This code is copied to the top of the sugarcrm\modules\Contacts\views\view.detail.php file so that it's available for each contact.

<div id="inforamaDiv" style="width:300px; height:200px; background-color:#FFFFFF; visibility:hidden;position:absolute;top:100px;left:100px; border:1px solid #AAAAAA>

<div style="background-color:#3333AA; color:#FFFFFF; padding:3px">Select a document</div> <div style="padding:10px"> <div style="padding-bottom:2px">Available documents</div> <select id="documentList" size="8" style="width:100%"></select> <div style="width:100%; padding-top:5px; text-align:right"> <input type="button" value="Print" onclick="javascript:generateDoc();"/> <input type="button" value="Cancel" onclick="javascript:cancel();"/> </div> </div> </div> <script> var currentContactId; var inforamaDiv = document.getElementById( 'inforamaDiv' ); var documentList = document.getElementById( 'documentList' ); function cancel() { inforamaDiv.style.visibility = "hidden"; } function printDoc( contactId ) { currentContactId = contactId; var url = "inforama.php?action=gettemplates"; var resp = null; if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); xmlhttp.open("GET",url,false); xmlhttp.send(null); resp = xmlhttp.responseText; } else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); xmlhttp.open("GET",url,false); xmlhttp.send(); resp = xmlhttp.responseText; } var docs = resp.split( "," ); documentList.options.length = 0; for ( var i = 0; i < docs.length; i++ ) { var elOptNew = document.createElement('option'); elOptNew.text = docs[ i ]; elOptNew.value = docs[ i ]; try { documentList.add(elOptNew, null); // standards compliant; doesn't work in IE } catch(ex) { documentList.add(elOptNew); // IE only } } inforamaDiv.style.visibility = "visible"; } function generateDoc() { var url = "inforama.php?contactid=" + currentContactId + "&doc=" + documentList.selectedItem; var resp = null; if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); xmlhttp.open("GET",url,false); xmlhttp.send(null); resp = xmlhttp.responseText; } else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); xmlhttp.open("GET",url,false); xmlhttp.send(); resp = xmlhttp.responseText; } inforamaDiv.style.visibility = "hidden"; } </script>

At the beginning of this HTML there is a div defined which contains a list which will display the documents available on the Inforama server. The printDoc function calls the inforama.php file which resides in the root sugarcrm directory and is shown below.

<?php $action = $_GET[ "action" ]; if ( $action == 'gettemplates' ) { getTemplates(); } else { $printDestination = ""; $customerId = $_GET[ "contactid" ]; $doc = $_GET[ "doc" ]; $requestStr = '{"request":{"project_name":"SugarTest","document_requests":[{"parameters":[{"value":"' . $customerId; $requestStr .= '","name":"contact_id"}],"output_type":"pdf","input_type":"Compound", "actions":[{"properties":[{"value":"' . $printDestination; $requestStr .= '","name":"printdestination"}],"name":"print"}],"template_name":"' . $doc . '"}],"type":""}}'; callInforama( $requestStr ); } function callInforama( $requestStr ) { $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, 'http://localhost:8080/Inforama/restful/requests'); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC); curl_setopt($ch, CURLOPT_USERPWD, 'admin:password'); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $requestStr); curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: application/json', 'Content-Type: application/json')); $data = curl_exec($ch); curl_close($ch); } function getTemplates() { $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, 'http://localhost:8080/Inforama/restful/projects/SugarTest/templates'); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC); curl_setopt($ch, CURLOPT_USERPWD, 'admin:password'); $data = curl_exec($ch); curl_close($ch); $jsonResp = json_decode($data); $resp = ""; $iCount = 0; foreach ($jsonResp as $value) { foreach ($value as $value2) { if ( $iCount > 0 ) { $resp .= ","; } $resp .= $value2->{'name'}; $iCount++; } } echo $resp; } ?>

Now when the print button is clicked the div appears with the list of documents in Inforama as shown below.

Letters available for printing are listed in the new custom dialog

Now when the user selects a document template and clicks the print button the generateDoc function is called with the contact id and the template name. This example simply prints the resulting document to the default printer but it could easily be changed to print to specific printers or to email to the contact's email address.

Roadmap 2.2

2010-03-10T17:34:12Z

{{http://www.in4ama.org/images/roadmap.png}} == 2.0 == * Storage of projects in Alfresco. This is a significant change to the way Inforama projects are stored. By storing Inforama project files in Alfresco, project editors can access the same projects from the central repository. * CMIS interface - In the same way as generated documents are stored via the JSR 170 interface, they can also be stored using the new CMIS interface. This will open up integrations with a wider range of CMS systems including Sharepoint. == 1.6 == === Studio === * Addition of UI component for CSV datasources * New XML Datasource allowing datasources to be defined from xml and schema files * Change data frame table to a tree to allow heirarchy of XML and Hibernate datasources to be expanded and selected * New reference functionality which allows long expressions to be referred to throughout a project using shorter expressions within documents == 1.5 == === Studio === * New installer for the Studio * Launcher to run Studio from executable * Google Docs plug-in which will allow documents to be generated from the contents of a Google Docs spreadsheet === Enterprise === * JConsole addition to monitor Inforama Enterprise - remotely monitor jobs as they are processed and how memory and other metrics are behaving. * New Rest API as an alternative to the SOAP API * Improved error reporting == 1.4 == === Studio === * Ability to merge OpenOffice documents on the server and export to multiple formats including .pdf and .doc * Addition of a CSV datasource similar to the spreadsheet datasource === Enterprise === * More advanced user rights management using Spring * Change to Ajax browser interface using the Spring DWR library == 1.3 == === Studio === * Make data sets, fragments, templates, etc. more reusable. [[Resource Reuse|Click here for more information on this feature.]] * Change to the syntax for referring to documents. [[Document Reference|Click here for more on this feature.]] * New mailshot dialog which makes it easier to select datasets to be iterated and email fields to be used * Ability to save mailshots as scripts which can be rerun again * Mailshot events which can be triggered before and after documents and packs are emailed or printed * Enhancements to the plug-in architecture to allow for more integrations with the Studio * Early version of the Salesforce plug-in allowing documents to be generated from Salesforce contact data === Enterprise === * Improved font handling. Addition of a page on the Enterprise version which will allow Fonts to be added to the FOP engine. [[Font Handing|Click here for more on this feature.]] * Support for multiple document providers. [[Multiple document providers|Click here for more on this feature.]] == 1.2 == === Studio === * Hibernate and POJOs integration. Ability to load data thru a set of Hibernate POJOs and create document bindings. [Click here for more information on setting up POJOs as a data source|Java Beans] * Excel integration. Similar to the Hibernate integration, ability to create bindings from a spreadsheet. Particularly useful for mailshots where lists of users with names and email addresses have been stored or exported to a spreadsheet. [Click here for more information on this feature|Spreadsheet documents] * Refactoring of codebase to allow documents to be created in a more generic way. * Localisation support. Languages supported out of the box are English and Polish. Other language can be added easily * New projects structure that allows easier document migration between projects as well as overriding document properties in web service calls. [Click here for more information|New Inforama project structure, version 1.2] === Enterprise === * Extended document generation formats. Ability to deploy a project with an OpenOffice document, request that document and return it as a modified OpenOffice document. The returned document will be populated with the bound data with any tables created. This does not require OpenOffice to be installed on the server. [[New types of document generation formats|Click here for more information on this feature.]] * Localisation support. Languages supported out of the box are English and Polish. Other language can be added easily == 1.1 == === Studio === * Update to work with both OpenOffice 2.x and 3.x. * Improvements to the UI. Trees to categorise document types for larger projects. * More advanced table creation. Ability to create tables with dynamic row and column counts. Customise table content and styles through custom Java classes. Table templates to help with reuse. [[Tables|Click here for more on this feature.]] * Introduction of the Office2fO transformation project to help create more accurate XSL-FO documents from the OpenOffice ODF formats. === Enterprise === * Integration with Alfresco and Jackrabbit via JSR170. [[http://in4ama.org/web/guest/news/-/blogs/inforama-meets-alfresco?_33_redirect=%2Fweb%2Fguest%2Fnews|Click here for more on this feature.]]

Using Data from a Google Docs Spreadsheet 1.4

2010-01-25T21:48:48Z

With the release of 1.5 we have included a plug-in for Google Docs^tm which will allow you to use data directly from a Google spreadsheet. As you may or may not know Google have developed a neat way of gathering form and survey information into a Google spreadsheet. For a quick overview of the technology take a look at this video...

http://www.youtube.com/watch?v=IzgaUOW6GIs

or this article from the Google Docs site...

http://googledocs.blogspot.com/2008/02/stop-sharing-spreadsheets-start.html

You might also want to take a look at the introductory webcast for this plug-in at http://www.inforama.org/web/guest/resources/webcasts

In this example we will show how to work with the data that's been collected in the 'User Registrations' spreadsheet shown in figure 1 below.

Figure 1 - The User Registrations spreadsheet

You can see an example of the form that was used to gather this data here. Feel free to fill it out if you want to keep updated about Inforama and the Google Docs integration as it progresses.

Getting Started

In order to get started with the Google Docs plug-in download version 1.5 of Inforama from SourceForge at http://sourceforge.net/projects/inforama/files/

Once installed you will see a 'plugins' folder in the Inforama application directory. Download the Google Docs plug-in zip file from SourceForge and extract it to the plugins directory. If Inforama is already running close it, restart it and create a new project.

Create a data source

Click the Data - Connections/Datasources... menu item to open the DataSources dialog shown in figure 2 below.

Figure 2 - The Google Docs data source

The Google Docs data source now appears in the list of available datasources. Select the Google Docs datasource type and click the next button.

The next dialog shown in figure 3 shows where you enter details of the Google Docs spreadsheet that you wish to use. Begin by giving your data source a name that will be used in your Inforama project. Next enter your Google Docs username and password. Click the List Spreadsheets button and all of the spreadsheets available in your Google Docs account will be listed.

Figure 3 - Selecting the spreadsheet which will be used

Create a dataset

Next you want to create a dataset that will retrieve a subset of the data from your data source. To do this open the datasets dialog shown in figure 4. In this case we're going to mailshot all of the users in the spreadsheet so you can just enter a name for the dataset and click the execute button. A list of fields from the spreadsheet will be returned in the list on the right of the dialog. Click the save button to save the dataset.

Figure 4 - Creating a dataset to be used in the project documents

This new Google Docs dataset can be used in the same way as any other dataset in Inforama.

If you want to filter the data in the spreadsheet you can enter a simple clause in the SQL field in the dialog. For example you could use the clause email=info@inforama.org or index=${index}. In this case ${index} is a parameter that will be provided to the Inforama engine prior to processing.

You can use it to run mailshots with or without PDF attachments as described in the tutorial at http://www.inforama.org/web/guest/community/wiki/-/wiki/Main/1.3+Mailshot+Dialog

You can use it to create dynamic tables in your documents as described in the tutorial at http://www.inforama.org/web/guest/community/wiki/-/wiki/Main/6+-+Table+Iterations

This is our first step in working with Google Docs and we intend to develop more integrations with it in upcoming versions of Inforama. We created this plug-in for Inforama using Inforama's plug-in architecture. You may be interested in downloading the source code for this plug-in in order to see how the Inforama plug-in architecture is used or to see how to work with Google Docs from Java.

If you're interested in getting more information about this plug-in and further integration with Google Docs click the link at the bottom of this page and fill out the Google Form.

Google Docs Sample Form 1.0

2010-01-25T21:43:28Z

1.3 Mailshot Dialog 1.9

2010-01-22T17:38:57Z

===Introduction=== Version 1.2 of Inforama introduced the ability to send mailshots which has proven very popular and effective in generating personalised PDFs for lists of recipients. In version 1.3 we have improved this functionality with a dedicated mailshot wizard. ===Getting Started=== To get started with this improved version of the mailshot wizard create a project with a letter template which you would like to generate. If you want to get started quickly with a sample project you can download the SampleSpreadsheet project from [[http://sourceforge.net/projects/inforama/files|SourceForge]]. This project generates its documents from a spreadsheet which is included in the download. Once opened, the new mailshot dialog can be launched by clicking the 'Project - Run a mailshot...' menu item. The dialog shown in figure 1 will appear. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot1.jpg|Figure 1 - The new mailshot dialog}} From the list of documents and packs in the left-hand list, select the document(s) or pack(s) that you wish to generate and move them to the select list on the right. Click the next button to proceed to the screen shown in figure 2. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot2.jpg|Figure 2 - Select the dataset to iterate}} In this screen select the dataset which contains the list of recipients to whom you wish to send the mailshot. If the mailshot is to be emailed then the dataset should contain an email address field. Once the dataset is selected click the next button to proceed to the screen shown in figure 3. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot3.jpg|Figure 3 - Specify actions to be carried out}} In this screen you select which actions should be carried out with the generated documents. In this example the generated documents will be emailed to the contacts in the dataset. In order to use the email address within the dataset click the button to the right of the 'To' address field. A dialog will appear with a list of fields in the dataset. Select the field name which contains the email address and click OK. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot4.jpg|Figure 4 - Specify actions to be carried out}} The 'To' address will automatically populate with a reference to the email address field as shown in figure 4. Click the next button to proceed to the screen shown in figure 5. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot5.jpg|Figure 5 - Carry out additional tasks using the mailshot events}} This screen is designed to carry out additional tasks as mailshot items are processed. In many cases it would be desirable to record the action which is carried out in a database for example. The screenshot shows a query being executed against a database datasource within the project. Click the next button to proceed to the screen shown in figure 6. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot6.jpg|Figure 6 - Apply a document name format}} This screen allows you to apply a format or mask to the generated document names. This can be useful in cases where you wish to archive the generated documents and want to have a unique identifier as part of the file name. This will be come evident on the last screen where you have the option to save the entire mailshot. Click the next button to continue to the screen shown in figure 7. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot7.jpg|Figure 7 - Specify parameters to be used}} This screen allows you to specify parameters which should be sent to the document generation job. In this example there are no parameters so there are none prompted for but you may wish to limit your mailshot to users in a particular region or age bracked for example. Click the next button to proceed to the screen shown in figure 8. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot8.jpg|Figure 8 - Preview of the generated documents}} When this screen first appears it contains a list of all the rows which were used in the dataset to generate the mailshot PDFs. The actions specified earlier have not yet been carried out at this point. This first appearance of this screen allows you to preview the generated PDFs and emails which will be used when the next button is clicked. On this screen you can also choose to save the documents which have been generated. You can do this by clicking the 'Save documents' button. A dialog will appear prompting you for a location to save them to. Choose an empty directory and the documents will be saved. If you specified a file name mask in step 6 the files will be saved using this format. You can also choose to save the mailshot steps as a script which can be reused. You can do this by clicking the 'Save mailshot script' button and you will be prompted to provide a name as shown in figure 9 below. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot9.jpg|Figure 9 - Name the mailshot script}} You can preview individual documents which have been generated by double-clicking an item in the list. The dialog shown in figure 10 below will appear. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot10.jpg|Figure 10 - Details of an individual mailshot}} From this dialog click the 'Show document' button to preview the PDF. An example of a generated PDF is shown in figure 11 below. {{http://www.in4ama.org/resources/wiki/tutorials/mailshots1.3/mailshot11.jpg|Figure 11 - A generated PDF}}

Building Inforama on Linux 1.1

2010-01-21T12:29:48Z

The following dependencies need to be installed in order to build the //Inforama// and //Inforama// Installer * **OpenOffice.org** - on //Ubuntu// the package can be installed by executing command "**sudo apt-get install openoffice.org**" * **OpenOffice.org Office Bean** - on //Ubuntu// the package can be installed by executing command **"sudo apt-get install openoffice.org-officebean"** * **IzPack** - available at http://izpack.org * **Launch4j** - available at http://launch4j.sourceforge.net In order to build the //Inforama//, variables **openoffice.lib** and **openoffice.lib2**, which are configured in Ant's configuration files (e.g. //DocumentEditor/build.properties//) need to point to the //Open Office// installation folder. On //Ubuntu Linux// the variables can be set as follows: **openoffice.lib=/usr/lib/openoffice/basis-link/program/classes** and **openoffice.lib2=/usr/share/java/openoffice**. In order to build the //Inforama Installer// the locations of //IzPack// and //Launch4j// need to be specified in the //Installer/build.properties// file (e.g. **izpack.dir=/usr/lib/IzPack** and **launch4j.dir=/usr/lib/launch4j**). The installer can be started by executing **java -jar install.jar** in the //Installer/dist// folder. In order to start the //Inforama// the //run-oo2.sh// (OpenOffice 2.x) or //run-oo3.sh// need to be amended to point to the correct //OpenOffice// installation folder. The default locations work for //OpenOffice// installed as //Ubuntu// package. Before starting //Inforama// the script files need to be make executable (e.g. **chmod +x *.sh**). Once this is done the //Inforama// can be started by executing //run-oo3.sh// or //run-oo2.sh// dependeing on the version of OpenOffice that is installed.

CSV Files 1.5

2009-11-05T18:11:00Z

==CSV Data Source== The description below shows how to configure //Inforama// project to use **CSV Files** as a data source. ===CSV Data Source configuration=== In order to make the **CSV** data source available in the project the following entry should be added to the **datasources.cfg.xml** file. {{{ ... ... }}} The data source definition doesn't take any configuration properties, it just indicates that the **CSV** data source should be available under the name specified by the **name** attribute. (//csv_datasource// in the example above). ===CSV Data Set configuration=== In order to configure a **CSV** data set the following properties needs to be specified: * **filepath** - points to a CSV file that should be used. * **firstrowcols** - indicates whether the first row of the CSV file should act as column names. The value of this property should be specified as either //true// or //false//. * **separator** - the value of this property specified a separator character (e.g. "," or "\t") used in the CSV file. * **query** - this property specifies a SQL-like query used to retrieve the data from a CSV file. A sample data set configuration is shown below. {{{ ... .... }}} The example above specifies the data set named "csv" created from the "csv_datasource" data source. The path to a CSV file should be provided in a "csvFileName" parameter. The first row from a CSV file should act as column names. The specified query "select *" means that the entire content of the file should be used as data set and, finally, values in a CSV file should be separeted by a "," character. ===The "query" property=== The "query" property from a data set definition specifies whith part of the CSV file should be used to build the data set. The query should be in the form: **select //column_names// where //conditions//** * **column_names** - a list of comma separated column names or '*' character meaning "all columns". The columns can be referenced using indexes enclosed within square brackets (e.g. ~[2] - means second column) or column names (works only when the first row of the associated CSV file acts as column names). So, for example, query: //select ~[1],~[2]// will built a data set only from the first two columns from a CSV file. * **conditions** - list of conditions filtering a data set that will be built. For example query: //select first_name, last_name where city='Dublin'// will be build a data set only from rows whose "city" columns' value equals "Dublin". ===Accessing a CSV data set within a document=== There are two ways of referring to a CSV data set within a document. * The 'standard' way, which is: $F{~[data_set_name].~[column_name]}, for example: $F{csv.first_name} - will get the value from the "first_name" column. * Using column indexes: For example: $F{csv.~[3]} will retrieve the value from the third column. The first (standard) way will work only when the first row of the associated CSV file acts as column names (i.e. "firstrowcols" property is set to "true"). Sample Inforama Project using a CSV data source (CsvProject.zip) and a sample WebService client application using the project are in the attachemt. You can download the following sample files which demonstrate how to use this datasource... *[[http://www.inforama.org/resources/wiki/technical/csv/CsvProject.zip|CsvProject.zip]] - A sample Inforama project *[[http://www.inforama.org/resources/wiki/technical/csv/TestClient.zip|TestClient.zip]] - A sample client application which invokes the Inforama Enterprise web service *[[http://www.inforama.org/resources/wiki/technical/csv/TestClientEclipseProject.zip|TestClientEclipseProject.zip]] - The sample code for the project which invokes the web service. This is an Eclipse project.

Configuring Eclipse for Editing and Debugging 1.5 (minor-edit)

2009-10-01T19:36:16Z

Setting up the Eclipse development environment for Inforama Community Edition

Check the code from the SVN repository

Check out the project suite from the SourceForge.net subversion repository. The address of the

server is “https://inforama/svn.sourceforge.net” and respository path is “svnroot/inforama/trunk”. This

can be done with the following instruction of the Subversion command line client: “svn co

https://inforama.svn.sourceforge.net/svnroot/inforama/trunk inforama”.

If you're using an SVN client such as SmartSVN (http://www.syntevo.com/smartsvn/index.html) the dialog to create the will look similar to that shown in figure 1.

Figure 1: Configuring the connection to the SVN repository using SmartSVN

Enter your SourceForge user id and password along with the SVN paths.

Click the Project – Check out... menu item, select the Inforama repository you created and click the Next button. If you are only interested in checking out a particular version of Inforama you can use the next screen to select this as shown in figure 2.

Figure 2: Select the version of Inforama

The different branches in SVN relate to the Inforama versions. Select the branch you are interested in and click the Next button to view the screen shown in figure 3.

Figure 3: Specify the location for the checked out code

On this screen select the location on your filesystem to which the checked out code will be copied. Click the Next button and the screen shown in figure 4 will be displayed.

Figure 4: Specify a project name

The default action here is to check the source code out and manage it as a project. To do this enter the name you wish to give the project. Click the Next button and on the next page click the Finish button to complete the wizard.

You can update your local copy of the code from the repository by right-clicking the project in the SmartSVN explorer and clicking the Update popup menu item. When you first update from the repository five directories will be downloaded to your local project location. These are...

Directory	Descripiton
DataSourceManager	This project manages dataconnections via JDBC and to spreadsheets and can be extended to connect to custom datasources.
DocumentAutomator	This project manages the actions which are carried out on projects such as emailing, printing and returning.
DocumentEditor	This is the studio and contains code for creating the UI, managing projects, etc.
DocumentEngine	This project controls the generation of documents from templates, merging data from datasets into PDFs and other formats
lib	This directory contains all of the jar files which are required by the various projects.

Install OpenOffice

These instructions assume that version 2.4 of OpenOffice is being used. If you wish to configure Inforama to use version 3.x of OpenOffice please refer to the specific instructions on the Inforama Wiki at http://www.in4ama.org/web/guest/community/wiki/-/wiki/Main/Building+Inforama+with+Open+Office+3.x+in+Eclipse+IDE

Setting up the Eclipse environment

These instructions are based on Eclipse version 3.2.2. Download Eclipse from http://www.eclipse.org/downloads/ and start it up. Create a workspace in the root directory which you specified as your Inforama project location in figure 3 earlier. Click the File – Import... menu item in Eclipse and in the resulting dialog shown in figure 5 select the Existing Projects into Workspace item.

Figure 5: Import project dialog

Click the Next button and in the next screen locate the DataSourceManager project. Click the Finish button and the project will appear in the workspace frame. Right click the project in the workspace frame and click the Properties menu item. Select the Java Build Path node from the tree on the left and select the Libraries tab. Click the Add Variable... button and in the New Variable Classpath Entry dialog click the Configure Variables... button. In the Preferences dialog click the New... button to display the dialog shown in figure 6.

Figure 6: Specifying the variable folder path

Now build the project by clicking the Project – Clean... menu item in Eclipse. Select the DataSourceManager and it should build without errors. You can now build the project using the build.xml file in the DataSourceManager folder. Before doing this make sure that the build.properties file exists in the directory above this.

In Eclipse, right-click the build.xml file and select the Run As – Ant Build... menu option. In the build dialog select the clean, compile and jar targets and make sure they are configured to build in that order. Click the Run button to run the Ant build. The resulting DataSourceManager.jar file will be created in the dist folder.

Now you can import the DocumentAutomator project into Eclipse. Once imported rebuild it and it should build without errors.

Next import the DocumentEngine project and once import right-click it and select Properties from the menu. Select the Java Build Path node from the tree on the leftm select the Projects tab and make sure that the DataSourceManager and DocumentAutomator projects are included as shown in figure 7.

Figure 7: Project dependancies for the DocumentEngine

Now switch to the Libraries tab and click the Add Variable... button. Next click the Configure Variables... button and then the New... button. In the dialog enter the value openoffice_lib in the Name field and the path to the classes folder for OpenOffice in the Path field. In OpenOffice 2.4 the classes folder can be found in the program folder which in turn is in the default root installation directory for OpenOffice. Click the OK button to save the variable.

Figure 8: Adding the openoffice_lib path variable

You should now be able to build the DocumentEngine project without errors.

Running Inforama Studio

The final project you need to import is the DocumentEditor project. Once imported the project should build without errors. Next select the DocumentEditor project and click the Run – Open Run Dialog... menu item to display the run dialog shown in figure 9.

Figure 9: The Inforama Studio run configuration

Select the Java Application node in the tree on the left of the dialog and click the New launch configuration button as indicated by the red circle in figure 9. Enter a name for the configuration and make sure that the DocumentEditor project is selected as the project. Enter the value org.in4ama.editor.xui.Launcher as the main class.

Now select the Arguments tab as shown in figure 10.

Figure 10: Specifying arguments for the launch configuration

In the Program arguments field enter the path to the OpenOffice installation directory followed by the value '2' indicating that version OpenOffice 2.x is to be used.

Click the Run button to run the Studio for the first time.

Building Inforama with Open Office 3.x in Eclipse IDE 1.0

2009-10-01T10:42:20Z

Steps below describe how to configure //Inforama// with //Open Office 3.x// in //Eclipse// IDE. ==== Configure **Document Editor** project's build path. ==== Right-click the **DocumentEditor** project and select **Properties**. Go to **Java Build Path** and remove all references to the jar files pointed to by the **openoffice_lib** variable. Click **Add External JARs...** and select all jar files from directories: //openoffice_folder/Basis/program/classes// (e.g. //C:\Program Files\OpenOffice.org 3\Basis\program\classes//) and //openoffice_folder/URE/java// (e.g. //C:\Program Files\OpenOffice.org 3\URE\java//). {{http://www.in4ama.org/resources/blog/wiki/eclipse_with_oo3/screen1.jpg|configure the build path}} ==== Create the **Launch configuration**. ==== In the **Document Editor** project properties dialog select **Run/Debug Settings**, choose **Java Application** and click **OK**. In the **Launch configuration properties** dialog specify as follows: - **Main** Tab Specify the **main class** as //org.in4ama.editor.xui.Launcher//. {{http://www.in4ama.org/resources/blog/wiki/eclipse_with_oo3/screen2.jpg|specify the main class}} - **Arguments** Tab Specify the **Program arguments** as //"openoffice_folder" 3// (e.g. //"C:\Program Files\OpenOffice.org" 3//). {{http://www.in4ama.org/resources/blog/wiki/eclipse_with_oo3/screen3.jpg|specify the program arguments}} - **Environment** Tab Add a new variable named **UNO_PATH** and sets its value to //openoffice_folder/program// (e.g. //C:\Program Files\OpenOffice.org\program//). {{http://www.in4ama.org/resources/blog/wiki/eclipse_with_oo3/screen4.jpg|specify UNO_PATH variable}} ==== Rebuild the DocumentEditor project ====

Building and Debugging 1.0

2009-10-01T09:53:26Z

This section contains building and debugging tips for **Inforama**.

4 - Creating and working with PDF forms 1.7 (minor-edit)

2009-09-11T15:40:31Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

Inforama allows you to create new PDF forms within the Studio using the embedded OpenOffice editor. Alternatively, you can import existing PDF forms into your Inforama project.

Creating a PDF form from an OpenOffice document

To create the document click the File – New document... menu item and the new document dialog will appear.

Figure 1: Creating a new AcroForm from Document

In this case we're creating a change of address form which needs to be printed out and signed by customers of Dividy Films. Enter the name ChangeOfAddressForm and select AcroForm from Document from the Document type dropdown list. Click the Create button and the new document will appear in the Document frame tree and the new document will open for editing in the OpenOffice editor.

When this document is saved it will be automatically converted to a PDF. In order to make form fields appear in the resulting PDF it's necessary to insert OpenOffice form controls into the document. To see the OpenOffice form controls toolbar make the OpenOffice menu bar visible and click the View – Toolbars – Form Controls menu item as shown in figure 2.

Figure 2: Enabling the form controls toolbar

The toolbar shown in figure 3 below shows the form control toolbar.

Figure 3: The form control toolbar

Begin creating the form by opening the new ChangeOfAddressForm document. Insert a frame into the document using the Insert – Frame OpenOffice menu item. Resize the frame so that it appears about 4cm from the top of the document, is about 4cm in height and spans the width of the document. Now create a new 2 column x 5 row table in the frame. In the right hand columns we want to create text fields. First make sure design mode is switched on in OpenOffice by toggling the button indicated by the number 1 in figure 3. Next click the new Text Box button as indicated by the number 3 in figure 3. Draw the Text Box in the second column on the second row of the table.

Double-click the new Text Box to display the form control properties dialog as shown in figure 4. Change the default name of the Text Box and also change the Border property to Flat.

Figure 4: Form control properties dialog

Continue to add the form controls and prompts until the table looks like that shown in figure 5 below.

Figure 5: The customer details frame

Binding data to the PDF form

In order to create the PDF form and bind data to it we now need to switch the view of the document. First save your changes and click the Switch to AcroForm button shown in figure 6.

Figure 6: Switch to acroform button

The document is automatically converted to a PDF form as shown in figure 7.

Figure 7: The document converted to PDF

The Text Box controls which were created in the OpenOffice editor are converted to PDF form fields and are listed in the Components Frame at the bottom left of the Studio. If you click on one of the names in the Component Frame the component will highlight in red in the editor. It is also possible to add new PDF form fields in this view but this is not recommended as the PDF document is generated from the OpenOffice document and any changes to the layout, etc. should be made in this.

In order to bind data from the database to the form fields expand the Data Frame, select the form field you wish to bind to and double-click the field which should appear there. The mapping will appear in the Data text box in the Components Frame. Continue to create your mappings and preview the document by clicking the Document Manager toolbar button. In the Document Manager dialog click the Preview button and the document will appear as in figure 8.

Figure 8: Preview of the document with data merged

Create a PDF letterhead

Using this type of document it's possible to create a letterhead which can be applied to documents. To demonstrate this we'll create a new document of type AcroForm from Document with the name Letterhead.

When this document opens for editing insert logos and address information at the top and bottom of the document to produce something like that shown in figure 9.

Figure 9: Sample letterhead document

Now to apply this letterhead to a document we need to create a compound document which we can do in the Letter Manager dialog. But first re-open the WelcomeLetter document and move the entire body of the letter down by about 6 lines in order to accommodate the header.

Now click the Project – Manage documents... menu item and move the WelcomeLetter to the Selected fragments list. In the Background dropdown list select the Letterhead document and now click the Preview button. The document will appear as shown in figure 10.

Figure 10: Previewing the letterhead document

Importing existing PDF forms

In Inforama Studio it's possible to import and modify existing PDF forms. In this example Dividy Films have hired an external design company to create their application form. To import this form click the File – Import a document... menu item and the import dialog will appear as in figure 11.

Figure 11: Importing an existing PDF form

Select PDF as the Document type from the dropdown list and locate the PDF on the filesystem. The Import as field will automatically default to the current file name but this can be changed if you want to import the document under a different name. Click the Import button and the document will appear in the tree in the Documents frame and will open for editing in the main editor.

Figure 12: The imported PDF form

You can see that the PDF editor is similar to the one used when switching from the OpenOffice document earlier in this step. Once again, the PDF fields are listed in the Components frame on the bottom left of the Studio and data can be bound by double-clicking the fields in the Data frame. So we can go ahead and create the bindings as before and preview the document using the Letter manager dialog. The document will preview as shown below in figure 13.

Figure 13: Previewing the PDF form with merged data

Modifying PDF forms

In many cases the PDF documents which you import don't have form fields embedded within them or there may be more information which you would like to add. If this is the case then it's possible to add fields using Inforama Studio.

Figure 14: The PDF editor toolbar

Figure 14 shows the PDF editor toolbar which can be used to add and remove form fields

Item	Description
1	Zoom in on the PDF document
2	Zoom out from the PDF document
3	Select the page to edit in the document
4	Remove a component from the document
5	Unlock the document. If locked, components cannot be resized or moved
6	Add a text field to the document
7	Add a bar code to the document
8	Add an image to the document
9	Add a checkbox to the document
10	Preview the document

As an example imagine that the form needed an amendment to include the customer reference. Unlock the form by clicking toolbar button 5 above. Add a text field to the document by clicking toolbar button 6 and clicking the form where you want it to appear. Resize the text component and set the background and border colours.

Figure 15: The text component properties

Now create the binding with the following text.

Reference : $F{customerDS.customer_id}

Now preview the document and it will appear as shown in figure 16.

Figure 16: The custom text field previewing with merged data

3 - Datasources and Datasets 1.7

2009-09-11T15:39:19Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

Importing the MySQL JDBC driver

In this tutorial we are working with the Sakila database which runs on MySQL. In order to connect to this database we need to use a JDBC driver which is compatible with MySQL. You can download a MySQL JDBC driver from the MySQL site at http://dev.mysql.com/downloads/connector/j/5.1.html.

Once downloaded, you can reference the jar file by clicking the Options – Classpath editor... menu item and the Classpath dialog will appear as shown in figure 1.

Figure 1: The classpath dialog

Click the Add a JAR button and you will be asked to locate the jar file. Select the jar file and the path to it will appear in the list. Click the Save classpath button to save your changes.

Creating a MySQL DataSource

Now that the JDBC driver has been referenced it's possible to connect to the Sakila database. To do this click the Data – Connections/Datasources... menu item and the wizard shown on the left of figure 2 will be displayed. Click the New button and the screen shown on the right of figure 2 will appear.

Figure 2: Wizard to add JDBC connection

Select JDBC Connection from the list and click the Next button. The next screen is where the database connection is established.

Figure 3: Configuring the JDBC connection

Field	Value	Description
Name	sakilaDB	This is the name of the connection being created and will be use throughout Inforama as a reference
Database	MySQL	This is a dropdown list for convenience. Select the MySQL driver and the following fields will be populated with template configurations
Driver	com.mysql.jdbc.Driver	This is the name of the JDBC class file which is used to register the MySQL JDBC driver
URL	jdbc:mysql://[server]/sakila	This is the URL to the database. Replace the servername with localhost if the database is running on the local machine
User	[MySQL User]	This is a valid MySQL user
Password	[MySQL Password]	This is the password for the MySQL user

When the connection information has been entered click the Test connection button and you wil see the message Connection succeeded if everything has been configured correctly. Click the Save button to save this connection.

Creating a MySQL Dataset

Now that the dataconnection has been created it's possible to define a query which will retrieve data from the database. To do this click the Data – Datasets... menu item. The Datasets dialog will appear as in figure 4.

Figure 4: Datasets dialog

In this case there is only one Datasource configured for the project – sakilaDB. It's possible to have more so make sure that the correct datasource is selected. Enter a name for the new Dataset – in this case were calling it customerDS. Enter the query into the main query area. The query being used is...

SELECT customer_id, first_name, last_name, email, cust_addr.address, cust_addr.address2, cust_addr.district, cust_addr.postal_code, cust_addr.phone, city.city, country.country FROM customer, address as cust_addr, city, country WHERE customer.address_id = cust_addr.address_id AND city.city_id = cust_addr.city_id AND country.country_id = city.country_id

Click the Execute button and a list of the fields returned by the query will appear on the list on the right of the dialog. Click the Save button to save the dataset and the Close button to dismiss the dialog.

This new dataset can now be accessed from the Data frame in the editor. To see this expand the Data frame as shown in figure 5.

Figure 5: Previewing a dataset in the data frame

Item	Description
1	Launch the Dataset editor
2	Display the fields from the dataset selected in 4 below
3	Prefix field names with their corresponding table names
4	Menu to allow the dataset to be switched
5	List of field names retrieved from the dataset
6	Preview of data in the dataset
7	Show parameters dialog to preview a specific row in the dataset where parameters are used
8	Insert the selected field into the current document with formatting applied
9	Insert a text box acro field into the current document

Click the down arrow icon identified by the number 2 to preview the fields in the dataset. Click the table icon identified by the number 3 to prefix the field names with their corresponding table names. This is useful where fields from different tables have the same name. Click the button identified by the number 7 to launch the parameter dialog and preview the data in the dataset.

We now want to start merging the data from this Dataset into documents within our project. Re-open the WelcomeLetter document template which was created in the previous step in the tutorial and where it said 'Dear Subscriber', delete the word 'Subscriber', place the cursor after the word 'Dear' and double-click the field first_name in the Data frame. The field name will be inserted into the document as shown in figure 6 below.

Figure 6: Field placeholder within the document

Now preview the document as described in the previous section of this tutorial and the generated document will appear as shown in figure 7 below.

Figure 7: Previewing the document with merged data field

Specifying Parameters for Datasets

So far we have merged data with the document in such a way that the first row from the dataset is used. Naturally we want to control what row is used by applying a filter to the dataset query. This is achieved by using a parameter.

Create a new parameter as described in the previous section called customer_id. Once again open the Dataset dialog shown in figure 4 and select the Dataset customerDS. Change the query to add this clause to the end...

AND country.country_id = city.country_id and customer.customer_id = '$P{customer_id}'

As a convenience you can automatically insert the parameter by clicking the Add a parameter button. The dialog shown in figure 8 below will be displayed. Select the parameter you wish to insert and click the OK button.

Figure 8: Adding a parameter automatically

Now when we go to preview the document again we can supply the new customer_id parameter in order to filter on the row we require.

Figure 9: Previewing filtered data

Creating a Spreadsheet Datasource

In many instances, customer and other data is stored in spreadsheets so it can be very convenient to work directly with these spreadsheets. Since Inforama version 1.2 data from spreadsheets can be used in much the same way as database data.

In order to demonstrate this feature of Inforama we will export the data from the staff table to a spreadsheet. Run the following query to generate a CSV file from the staff table...

SELECT "staff_id", "first_name", "last_name", "email", "username" FROM staff

Union SELECT staff_id, first_name, last_name, email, username FROM staff

INTO OUTFILE 'c:/temp/staff.csv'

FIELDS TERMINATED BY ','

ENCLOSED BY '"'

LINES TERMINATED BY '\n'

Note the path to the csv file as specified by the line beginning INTO OUTFILE. Open the generated csv file in Excel or Calc and save as a .xls file. A preview of the spreadsheet can be seen in figure 10 below.

Figure 10: The exported staff spreadsheet

Now we need to create a Datasource from the spreadsheet as before. Open the Datasource dialog shown in figure 2 by clicking the Data – Connections/Datasources... menu item. On the next page in the wizard select Spreadsheet from the list, click next and the screen shown in figure 11 will appear.

Figure 11: Creating the spreadsheet datasource

Again, give the datasource a name – in this case we have called it staffSheet. Locate the spreadsheet file on the filesystem and click the Save button to complete this step.

Now we need to create a Dataset from this spreadsheet which will filter on the staff_id. Using the parameters frame create the parameter staff_id. Click the Data – Datasets... menu item. The Datasets dialog will appear as in figure 4. Select the staffSheet Datasource from the list of datasources and enter the following query into the query editor...

SELECT * FROM staff where staff_id = '$P{staff_id}'

Enter the Dataset name staff_ss_DS, click Execute and then Save to complete. The dataset configuration will appear as in figure 12.

Figure 12: Spreadsheet dataset setup

Now create a new letter called StaffWelcome and insert data placeholders from the staff_ss_DS, dataset as shown in figure 13.

Figure 13: Creating a letter template with spreadsheet data placeholders

Now preview the document and enter a value for the staff_id. The document will preview as shown below in figure 14.

Figure 14: Preview the document merged with spreadsheet data

6 - Table Iterations 1.4 (minor-edit)

2009-09-11T15:38:12Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

Inforama has the ability to iterate datasets to duplicate document elements such as tables. This can be useful where a list of items relating to a customer or account need to be listed.

Simple Table Iterations

In this example we'll create a simple list of films filtered by rating. To begin with, create a new parameter called file_rating and a new dataset called film_by_rating with the following SQL statement...

SELECT title, length, rental_rate, special_features FROM film WHERE rating = '$P{film_rating}'

And now create a new letter template called FilmsByRating. Add an introduction paragraph at the top of the document and follow it will a new 4 column by 1 row table as shown in figure 1.

Figure 1: Simple table iteration command

As you can see the table is preceeded by the command $iterateRows{film_by_rating} which tells the Inforama engine to iterate the following table with the dataset between the braces which in this case is film_by_rating. When this document is previewed it will appear as in figure 2.

Figure 2: Simple table iteration preview

This is a very basic table and it would be nice to add a header row which shows the column names. Create a new row in the table before the existing row and enter the column names in this new row. You can also format this new row in whatever way you want it to appear as shown in figure 3.

Figure 3: Simple table command with header

The command has now been changed to $iterateRows{film_by_rating, 2}. The second parameter in this command indicates that the second row in the table needs to be iterated when generating the table. We have also changed the length and rental_rate columns to align their data to the right. The length field also includes the text mins after the value and the rental_rate field is preceded by the euro symbol.

Now when previewed the document will appear as shown in figure 4.

Figure 4: Simple header table iteration preview

Sub Tables

In many cases it's necessary to have tables within tables and this is possible with Inforama. Begin by creating a new parameter called numInCategory in the project. Next create a new dataset called allCategories with the following SQL Statement...

select * from category

Create another new dataset called filmsInCategory with the following SQL Statement...

select film.* from film, film_category where film.film_id=film_category.film_id and film_category.category_id = $F{allCategories.category_id} limit 0, $P{numInCategory}

The second dataset refers to the first in the where clause and limits the output of films in the category to the number specified by the numInCategory parameter.

Now you can create the document template which will include the table as shown in figure 5.

Figure 5: Sub table template

The first table has a single cell and is preceded by the command

$iterateRows{allCategories}

Within the cell, the name of the current category is displayed and after this another 3 column by 2 row table is created. The instruction before this table is

$iterateRows{filmsInCategory, 2}

When the document template is previewed it will appear as shown in figure 6.

Figure 6: Preview of the sub table

Using Table Templates

If you intend to format several tables using the same styling you might want to consider using a table template. This will allow you to refer to the same table template from any number of documents. You can also use elements of the table templates without having to use all of them.

Begin by clicking the File – New template... to open the new template dialog as shown in figure 7.

Figure 7: New template dialog

Enter the name you want to give the new template in the Template name field and make sure that the Template type dropdown list has Table selected. Click the Create button and the new template will open as an OpenOffice document in the main editor and the new template will appear in the tree of documents in the documents frame.

In the OpenOffice document create a new 2 column by 1 row table and format the cells as shown in figure 8.

Figure 8: The table template

The text in the first column has red text and we'll use this to display information in a table in another document. Create a new dataset called customerRentals with the following SQL Statement.

select film.film_id, film.title, rental.rental_date, film.rental_duration, rental.return_date from film, rental, inventory where film.film_id=inventory.film_id and inventory.inventory_id=rental.inventory_id and rental.customer_id = '$P{customerId}' order by rental.rental_date

And create another dataset called customer with the following SQL Statement.

select customer.first_name, customer.last_name, customer.email, city.city, address.address, address.address2, address.phone from customer, address, city where customer.address_id=address.address_id and city.city_id=address.city_id and customer.customer_id = '$P{customerId}'

Next create a new letter fragment called customerDesc as shown in figure 9.

Figure 9: Customer paragraph

And follow this by creating a new letter template

Figure 10: The main letter template

The first line in this document tells the Inforama engine to include the customerDesc fragment. The second line outputs the customer id and the third line before the table is the following instruction.

$createTable{ customerRentals, $template{ *.*->customerRentals.value('return_date') == null ? rentalCells.at(0,0) : rentalCells.at(1,0) } }

The first parameter to this call is the name of the dataset to be used to create the table. The second parameter checks if the return_date field in the customerRentals dataset is null. If it is then the first cell in the rentalCells template should be used otherwise the second one should be used. The resulting document will appear as shown in figure 11.

Figure 11: The table template preview

As you can see we've set one of the rental rows to have a null return_date value with the result that the row uses the first column in the table template and the text is displayed in red.

Customising Table Output from Java

As you imagine, the code required to be used in-line in the letter templates can get quite verbose if there are a number of checks to be made in order to determine what template to use. In these cases it's useful to create a custom Java class which will take care of the code to apply the formatting.

To begin this example create a new Java class called CustomTableFormatter as listed below.

package org.inforama.formatters;

import java.util.Enumeration;

import java.util.Properties;

import org.in4ama.documentautomator.DocumentRepository;

import org.in4ama.documentautomator.documents.xslfo.templates.XslFoTableTemplate;

import org.in4ama.documentengine.format.table.DataSetTableFormatter;

public class CustomTableFormatter extends DataSetTableFormatter {

/** Don't include the ID column in the result table */

@Override

public boolean isCurrentIncluded() {

int currentCol = getCurrDSCol();

return (!dataSet.getColumnName(currentCol).equalsIgnoreCase("film.film_id"));

}

/** Gets the number of columns that should appear,

* since we don't include the "id" column, subtract "1" from what would be

* returned by default.

@Override

public int getNumCols() {

return super.getNumCols() - 1;

}

/** Change the column widths of the first and fourth column

* (column indexes start with 0, hence "2" and "0" in the conditions) */

@Override

public Properties getColumnProperties(int colIdx) {

Properties properties = super.getColumnProperties(colIdx);

if (colIdx == 2) {

properties.put("column-width", "3cm");

} else if (colIdx == 0) {

properties.put("column-width", "8cm");

}

return properties;

}

/** Change the properties of the cell contents in the first column,

* use the "rentalCells" template's first cell.

@Override

public Properties getCurrentContentProperties() {

Properties properties = super.getCurrentContentProperties();

DocumentRepository documentRepository = evaluationContext.getProjectContext().getDocumentRepository();

XslFoTableTemplate template = (XslFoTableTemplate)documentRepository.getDocument("rentalCells", XslFoTableTemplate.TYPE);

if (getCurrentColumn() == 0) {

properties = template.getContentProperties(0, 0);

}

return properties;

}

/** Change the properties of the cells in the first column,

* use the "rentalCells" template's first cell. For the other

* cells use the properties of the first row's last cell in the

* "myTemplate1" template.

@Override

public Properties getCurrentCellProperties() {

Properties properties = super.getCurrentCellProperties();

DocumentRepository documentRepository = evaluationContext.getProjectContext().getDocumentRepository();

XslFoTableTemplate template = (XslFoTableTemplate)documentRepository.getDocument("rentalCells", XslFoTableTemplate.TYPE);

if (getCurrentColumn() == 0) {

properties = template.getCellProperties(0, 0);

} else {

properties = template.getCellProperties(1,0);

}

return properties;

}

This custom class extends the Inforama DataSetTableFormatter class and which, in turn, implements the TableFormatter interface. If you look at the getNumCols method you'll see that we will display all of the fields less one as we don't want the film_id field to appear in the resulting table. Now take a look at the isCurrentIncluded field and you'll see that if the class is processing the column who's name is film.film_id it will return false indicating that the field shouldn't appear.

The getColumnProperties method shows how the individual cell properties can be set. In this case the cells in columns 0 and 2 are set to non-default values and the others are left as the default values. In the getCurrentCellProperties method it's possible you can see that the table template we created earlier is used to load the properties for the cell.

In order to reference this class from the document templates you will need to use the following command.

$createCustomTable{org.inforama.formatters.CustomTableFormatter, customerRentals}

This simplifies the template command quite a bit and moves the logic into the Java class where it can be reused if necessary.

8 - Sending Mailshots 1.6 (minor-edit)

2009-09-11T15:36:45Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

In version 1.3 a dedicated mailshot wizard dialog was introduced into Inforama Studio. This has given greater control over how mailshots are sent. In this step we're going to create an email template using OpenOffice and attach a rental history PDF document to the email.

Create the Datasets

To begin with we'll create the main dataset containing the customers which we wish to target with the mailshot. We will only be targeting customers in a single district so you will also need to create a parameter called district.

Open the dataset dialog and create a dataset called customer_district with the following SQL statement.

select customer_id, first_name, last_name, email from customer, address where address.district = '$P{district}' and customer.address_id = address.address_id

Next we need to create the dataset which will produce the rental history table so create another new dataset called customer_rentals_list with the following SQL statement.

As you can see the second dataset references the first, using the customer_district.customer_id field to produce the table for the correct customer.

Create the Documents

Create a new letter template called MailshotCustomerRentals similar to that shown in figure 1.

Figure 1: The rental history letter template

The first line simply outputs the customer's first and last names. The second line is the instruction to create the table using the customer_rentals_list dataset and the single cell table simply outputs the fields in the dataset. If you preview this document now it will appear as shown in figure 2.

Figure 2: Preview of the rental history document

Next create an email body template called RentalsEmail as shown in figure 3.

Figure 3: The email template

Note that we use the same dataset, customer_district, that's being iterated.

Next create the compound document, CustomerRentalsEmail, that includes these documents by opening the Document manager dialog as shown in figure 4.

Figure 5: Select the document to be sent

Move the CustomerRentalsEmail document to the list to be sent and click the Next button to display the screen shown in figure 6.

Figure 6: Select the dataset to iterate

Select the customer_district dataset that we created earlier and click the Next button to display the screen shown in figure 7.

Figure 7: Select the email field from the dataset

Click OK on the dialog and the To email field will populate automatically as shown in figure 8.

Figure 8: The To email field populated

The To email field is automatically populated with the required syntax in order to send the emails to the email field from the dataset.

Click the Next button to proceed to the screen in figure 9.

Figure 9: Specifying actions for the mailshot

After each email in the mailshot is sent we want to insert a row into the mailshot_history table that we created earlier. The syntax we use for this is the following.

sakilaDB.execute("INSERT INTO mailshot_history (customer_id, mailshot_id, date_sent) VALUES ( $F{customer_district.customer_id}, 3, now())")

We use the sakilaDB datasource as the database connection in order to execute the SQL statement. The current customer_district.customer_id field value is used as the value to insert into the table.

Click the Next button and the screen shown in figure 10 will be displayed.

Figure 10: Specifying the generated document filename format

This screen allows you to specify the format for the filename of the generated documents. We'll see how this can be used later when the documents have been created. In this case the format is the following

$F{customer_district.customer_id}-$document

In this case we want the document name to begin with the value in the customer_district.customer_id field.

Click the Next button to proceed to the screen shown in figure 11.

Figure 11: Specifying parameters for the mailshot

This screen allows you to specify the parameters which are required to generate the documents. In this example we're going to send the mailshot to all users located in the district of Texas.

Click Next and the mailshot documents will generate and display in the list shown in figure 12.

Figure 12: List of the generated documents

This screen has a list of mailshot recipients with an entry for each row in the filtered dataset. The mailshot has not yet been processed and this screen allows you to preview the documents before they are sent. Before we preview the documents click the Save script button and the dialog shown in figure 13 will be displayed.

Figure 13: Save the mailshot script

Enter a name for the script and click the OK button to save the script.

Double-click a row in the table in figure 12 and the dialog shown in figure 14 will be displayed.

Figure 14: Mailshot details dialog

The To address contains the email address to which the email will be sent. Now click the Show Document button and a preview of the document will be displayed as shown in figure 15.

Figure 15: Preview the generated document

Now click the Show Email button in figure 14 and the email preview will display with the plain text version of the email as shown in figure 16.

Figure 16: Email preview dialog

Now click the Show events button in figure 14 and the dialog shown in figure 17 will be displayed.

Figure 17: Preview the generated events

You can see that the SQL statement which inserts into the mailshot_history table is generated with the correct value for the customer_id field.

Next click the Save Documents button in figure 12 and select an empty directory to save the documents into. The documents will be saved with the name format we specified in figure 10. Figure 18 shows the saved documents in windows explorer.

Figure 18: The saved documents

Now we'll go ahead and process the mailshot by clicking the Next button in figure 12. The list in the mailshot dialog will update as each email is sent as shown in figure 19.

Figure 19: Sending the mailshot

The emails are sent and will appear in the recipients inbox as shown in figure 20.

Figure 20: The delivered email

That completes the mailshot so now close the mailshot dialog and reopen it. In the screen shown in figure 5 click the Open Script button and select the district_script from the list presented. Now go through the mailshot again by clicking Next on each screen and you will see the values in the screen populate automatically.

7 - Email Templates, Compound Documents and Packs 1.3 (minor-edit)

2009-09-09T11:55:09Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

Once letter templates have been setup it's possible to email them. In doing so the email body which will be addressed to the user needs to be defined. Once again OpenOffice is used to create these templates.

Configuring the SMTP Settings

Before you send emails you will need to configure your Inforama project with valid SMTP settings. Click the Project – Properties... menu item to display the Project settings dialog as shown in figure 2.

Figure 1: The project settings dialog

Select the email node from the tree on the left of the dialog and enter some valid SMTP settings similar to those shown in figure 2.

Create an Email Template

Now to create the email template click the File – New document... menu item to show the New document dialog shown in figure 2.

Figure 2: Create a new email template with the new document dialog

Enter the name of the email template you wish to create – in this case the name is WelcomeMail. Select Email as the document type from the dropdown list. The new template will appear in the tree in the document frame in the editor and will also open in the OpenOffice editor.

Create the email template with whatever datafields and parameters you want within the email body. An example email template is shown in figure 3 below.

Figure 3: The email template

This template contains an image. This image needs to be inserted into the document as a linked image and not embedded within the document. To make sure that it's done in this way click the button indicated by the toolbar button 1 in figure 3.

Now it's possible to test how this email template will appear when it's emailed to a customer. Click the button indicated by the toolbar button 2 in figure 3 and the dialog shown in figure 4 will appear.

Figure 4: The email parameter dialog

Enter the email address to which you want to send the email and also enter a sample email subject. Any parameters which are required by the email can be entered in this dialog. When the information has been entered click the Send an email button to send it and it will arrive in your email client as shown in figure 5.

Figure 5: The test email viewed in the email client

Creating a compound document

You can create a compound document which will consist of several different elements using the Letter manager dialog. Click the Project – Manage documents... menu item to display the Letter manager dialog shown in figure 6.

Figure 6: The letter manager dialog

Add the CustomerRentalsClass letter template to the list of selected fragments and select the WelcomeMail Email template from the dropdown list. Enter a name for the compound document you want to create and also enter the email subject which is going to appear when the email arrives. Click the Save document button to save the compound document.

You can test the email process within the Studio using the Documents and Packs Generator dialog. Click the Project – Generate documents and packs... menu item. The dialog shown in the first page of figure 7 will be displayed.

Figure 7: Steps 1 & 2 of the document generator

Leave the request type as the default Normal and select the CustomerRentalsEmail document from the list of avaliable documents. Click the Next button and on the second page select the CustomerRentalsEmail. Select the Email parameters checkbox and enter the email address to which the email should be sent. Click the Next button and the first screen shown in figure 8 will be displayed.

Figure 8: Steps 3 & 4 of the document generator

Enter the parameters required for the generation process and click the Next button. The email will be sent and finally the second screen shown in figure 8 will be displayed.

Figure 9: The emailed letter

This time when the email arrives the generated letter will be attached and can be opened by the recipient.

Creating Packs

If you want to send multiple documents in a single email you can organise several documents into a pack. Click the Project – Manage packs... menu item to display the dialog shown in figure 10.

Figure 10: Creating a pack with the pack manager

Move the documents you want to include as part of this pack to the selected documents list on the right of the dialog. Enter a name for the pack, select the WelcomeMail email template and enter an email subject. Click the Save pack button to save it and close the dialog.

Click the Project – Generate documents and packs... menu item once again to display dialog shown in the first page of figure 7. This time the new pack will be displayed in the dialog and when you send it by email it will have the two pack documents attached.

5 - Data formatting and expressions 1.4

2009-09-09T09:53:24Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

So far we have merged data directly into the generated documents as is, but in many cases it's desirable to manipluate the data before it gets inserted. It may also be required to check data values in order to set the state on checkboxes. In this section we'll look at how the built-in data formatters can be used to automatically format data and also how custom formatters can be created in Java and introduced into your projects.

Basic formatting

To begin with, we'll look at how you might want to format string, numeric, currency and date data. Before doing so we'll amend the customer query to include the fields create_date, last_update and active.

SELECT customer_id, first_name, last_name, email, cust_addr.address, cust_addr.address2, cust_addr.district, cust_addr.postal_code, cust_addr.phone, city.city, country.country, create_date, customer.last_update, active FROM customer, address as cust_addr, city, country WHERE customer.address_id = cust_addr.address_id AND city.city_id = cust_addr.city_id AND country.country_id = city.country_id and customer.customer_id = '$P{customer_id}'

Enter this query in the Datasets dialog and save it. Open the WelcomeLetter where we'll enter a line about the registration date as shown in figure 1.

Figure 1: Data binding

Immediately below the binding is the generated PDF and as you can see the date isn't in the format that we would want to send to a customer. In order to rectify this we can use the built-in date formatter. In the Data frame shown in figure 2 below, select the field that you wish to insert into the template and click the bottom toolbar button indicated to display the data formatter dialog shown in figure 3.

Figure 2: The data frame

Figure 3: The data formatter dialog

Item	Description
1	List of built-in formatters
2	Easy to read preview of the formatter mask. This shown how the formatted data will appear when documents are generated
3	Actual mask to be applied to the formatter. This varies depending on the formatter type
4	The expression which will be used in the document to apply the mask to the data

Select the Date formatter from the list indicated by the number 1 in figure 3. This will automatically fill the list indicated by the number 2 in figure 3 with easy to read format masks. Select the format that you would like the date field to appear in and the actual format mask will appear in the text box indicated by the number 3 in figure 3. If you wish to change the value in this text box you can so and the expression in the text area indicated by the number 4 in figure 3 will automatically change to reflect this.

These format masks use standard Java formatting. For more on how to use these format masks have a look at the Java documentation at http://java.sun.com/j2se/1.4.2/docs/api/java/text/SimpleDateFormat.html

When you are happy with the format that will be applied to the data click OK in the data formatter dialog and the formatting expression will be inserted into the document as follows.

$E{$V{DateFormatter}.format($F{customerDS.create_date}, "dd MMM yyyy")}

The beginning of this expression, $E{$V{DateFormatter}, uses a built in variable which refers to a formatter Java class. Passed to this variable are the data to be formatted and the mask to be applied to the data. More on this will be explored when we look at creating custom data formatters.

Now when we preview the document the date value will appear in the generated document using the format we specified as shown in figure 4.

Figure 4: Preview the formatted date

Using expressions to implement basic logic

To demonstrate how we can implement some basic logic we'll assume that we have had our application form modified to indicate whether a customer is active or not. We've added a checkbox to the application form which we will turn on or off depending on the value of the active field in the customer table of the database. Select the new active checkbox in the editor and double-click the active field in the Data frame to create the binding to the checkbox as shown in figure 5.

Figure 5: Binding data to a checkbox

Preview the document and depending on the value of the active flag in the database the checkbox state will toggle as shown in figure 6.

Figure 6: Preview the checkbox data binding

More advanced expressions

In the previous example we simply used the value of the active field in the database to determine state of the checkbox. There may be cases where data in several fields needs to be checked in order to set the state. This is where expressions come into play and this will require more advanced bindings to be created. Say for example that we wanted to check the active flag and also check that the customer's profile has been updated after a certain date we could do the following.

$E{$F{customerDS.active} && ($F{customerDS.last_update}.getYear() + 1900)>2006}

Expressions contained within the tag $E{ ... } will get processed as Java expressions using the Groovy runtime interpreter. Before the expression is evaluated any fields or parameters will be replaced with the actual values so that the data is worked upon.

For more on the Groovy scripting language go to the Groovy homepage at http://groovy.codehaus.org/

Now when you preview the document the checkbox won't get checked. Try changing the year to 2005 in the expression and when the document is previewed it will be checked.

Now we can try changing some text in a letter depending on the value of a parameter. To do this open the WelcomeLetter document template and enter the paragraph shown in figure 7.

Figure 7: Returning different string depending on data values

We have added the subscription_level parameter and the following expression tests this parameter to control the text that is displayed within the paragraph.

$E{ if ( $P{subscription_level}.equals("1") ) { return "Silver" } else if ($P{subscription_level}.equals("2")) { return "Gold" } else if ($P{subscription_level}.equals("3")) { return "Platinum" } }

Now when we preview the document and set the subscription_level parameter it generates with the correct text value in the paragraph as shown in figure 8.

Figure 8: Previewing the subscription level conditional text

Creating a custom formatter

When formatting expression are getting lengthy and complex it may be a good idea to create a custom Java class which can also be reused thoughout a project. To demonstrate this we'll replace the somewhat unwieldy code used earlier to display the subscription level. Begin by creating the custom class below.

package org.inforama.formatters;

public class CustomFormatter {

public static String getLevel( String level ) {

if ( level.equals( "1" ) ) {

return "Silver";

} else if ( level.equals( "2" ) ) {

return "Gold";

} else if ( level.equals( "3" ) ) {

return "Platinum";

}

return "";

}

As you can see the code is doing the same as earlier code was doing. Compile the class and create a jar file. Open the classpath dialog by clicking the Options – Classpath editor... menu item as shown in figure 9.

Figure 9: Referencing the custom library from Inforama

Click the Add a JAR button, locate the CustomFormatter.jar file and it will appear in the list of jars referenced. Click the Save classpath button to save your changes. Now open the WelcomeLetter template and replace the line original line which output the subscription level to the following.

$E{ org.inforama.formatters.CustomFormatter.getLevel($P{subscription_level}) }

Registering the formatter as a variable

It's possible to make the reference to the CustomFormatter class within the document even cleaner. All of the built-in formatters are registered by using the variables.xml file in the project directory. Open this file in a text editor and add the line shown in red below.

...

<variable name="CustomFormatter" class="org.inforama.formatters.CustomFormatter"/>

</variables>

You will need to restart the Studio in order for this change to be picked up. When the Studio has restarted open the project again and once again open the WelcomeLetter template. Now change the line outputting the subscription level to.

$E{ $V{CustomFormatter}.getLevel($P{subscription_level}) }

This isn't a dramatic change to what we had earlier but it does make it easier to reference the class from numerous templates if necessary. The document should now look like that shown in figure 10.

Figure 10: The modified paragraph referencing the custom formatter class

2 - Working with letter templates 1.8

2009-09-09T09:13:28Z

Inforama tutorial

You can download the Inforama project files for this example by clicking the attachments link at the bottom of this page.

Creating a new letter template

You can create a new letter template by clicking the File – New document... menu item and the dialog shown in figure will be displayed.

Figure 1: New document dialog

Enter the name that you want to give the document, select Letter from the Document type list and click the Create button. The new letter template will appear in the Documents frame and the new letter template will appear in the main document frame as an OpenOffice document as shown in figure 2 below.

Figure 2: The new letter template within the Studio

You can now start creating the template in the OpenOffice editor. As you can see in the screenshot the entire OpenOffice application is embedded within Inforama Studio. The OpenOffice menu can be toggled on and off by clicking the toolbar button marked as 1 in figure 3 below.

Figure 3: The OpenOffice editor toolbar

Click the button marked 3 in figure 3 and the Letter Manager dialog will appear as in figure 4

Figure 4: The letter manger dialog

Click the Preview button and the document will render in the Document preview dialog as shown in figure 5 below.

Figure 5: Previewing the document

The Document preview dialog has a number of features which are listed in the following table...

Item	Description
1 – Refresh button	Generate the PDF again from the template
2 – Print button	Print the generated PDF. This will only work if a print output method is specified in the project options
3 – Save button	Save the PDF document to file. You will be prompted for the location to save the generated document to
4 – Show PDF button	Display the saved PDF in the default system PDF viewer. This button will become enabled after the PDF is saved using the save button above
5 – Fit width button	Fit the PDF into the width of the preview area
6 – Fit height button	Fit the PDF into the height of the preview area
7 – Full size button	Display the PDF in it's full size
8 – Zoom in button	Zoom in on the PDF
9 – Zoom out button	Zoom out of the PDF
10 – Page list	Lists the pages in the generated PDF. Select a page from this list to change the page being preview in the preview area
11 – Preview area	This is where the generated PDF is displayed

Passing parameters to the letter

Parameters can be sent to the Inforama document generation engine for a number of reasons including filtering on a dataset, display conditions, etc. but parameters can also be displayed within the document as text. In order to pass a parameter to a document the parameter name needs to be declared within the Inforama project. To do this expand the Parameters frame shown in figure 6 below.

Figure 6: The parameters frame

Click the button marked 1 in the Parameters frame and you will be prompted to input a name for the new parameter. In this example the parameter name has been specified as dividy_username. Click OK in the dialog and the new parameter name will appear in the parameters list marked as 3 in the screenshot. Now to make a placeholder for this parameter in your document template, open the template and remove the name at the bottom of the template. Place the cursor where you want the parameter to appear and double-click the parameter name in the Parameters frame. The parameter name will appear in the template as shown in figure 7.

Figure 7: The parameter within the document template

nce again click the button marked 3 in figure 3 and the Preview button in the resulting Letter Manager dialog. This time when the Document preview dialog appears the document won't generate automatically. Instead, in the Required parameters section on the bottom left of the dialog the parameter will appear with the text <not specified>. Select the parameter by clicking it in the list and click the Modify parameters button. You will be asked for a parameter value in the resulting dialog and when all parameters have been completed the document will generate as shown in figure 8.

Figure 8: Displaying the parameter in the document preview dialog

The screenshot shows that the parameter value which was input replaced the parameter placeholder in the document template. Whatever parameter value was last input on this dialog will appear automatically whenever this project is used.

Working with letter fragments

There may be cases where you wish to construct a compound document out of a series of standard paragraphs or fragments. This can be achieved by using letter fragments within Inforama. Start by clicking the File – New document... menu item. In the New document dialog enter the name of the letter fragment you want to create and select Letter Fragment from the Document type dropdown list as shown in figure 9.

Figure 9: Creating a new letter fragment

Click the Create button and the new letter fragment will appear in the list of documents in the Documents frame as well as opening for editing within the embedded OpenOffice editor. In this case we're creating a standard conditions paragraph which will appear at the bottom of certain documents.

When the document appears in the OpenOffice editor enter the text that you would like to appear. Now re-open the WelcomeLetter document template and place the following text at the bottom...

$fragment{StandardConditions}

This is shown in the screenshot in figure 10 below.

Figure 10: Including the fragment in a document

Now when you preview the document the fragment content will be included in at the bottom of the main document as shown in figure 11.

Figure 11: Previewing the document with the fragment included

It's also possible to merge a number of document fragments. Create a new fragment which we will call Intro. Next, open the Letter manager dialog and click the checkbox From fragments. Move the two fragments to the right-hand list and click the Preview button. The fragments will merge to create a single document.

Applying conditions to letter fragments

You may not always want fragments to be included in generated documents and the way to control this is to have them display based on conditions. In this example we will base our condition on a parameter which we will pass to the Inforama engine.

In the Parameters frame create a new parameter called include_conditions. Now re-open the WelcomeLetter template and scroll to the bottom where the condition was inserted previously. Replace the include command with the following...

$IF{$E{$P{include_conditions}}, $fragment{StandardConditions}}

Now preview the document in the Letter manager dialog and set the include_conditions parameter to the value true. The fragment will display as shown in figure 12 below. By default you can supply values of true, on, yes or 1 to commands using this syntax in order for them to evaluate to true. If the parameter is any other value or blank the fragment will not appear.

Figure 12: Fragment displaying depending on condition

1 - Introduction 2.0

2009-09-09T09:07:11Z

Inforama tutorial

Pre-Requisites

Java Runtime

Before starting you will need to make sure that you have a Java Runtime of 1.4 or above installed on the machine which will be running Inforama Studio. If you already have a Java Runtime installed on the machine you can check the version by going to the command line and typing the following...

java -version

You will see the following output which will tell you the current JRE version...

java version "1.6.0_13"

Java(TM) SE Runtime Environment (build 1.6.0_13-b03)

Java HotSpot(TM) Client VM (build 11.3-b02, mixed mode)

If the JRE isn't the correct version the latest version of the JRE can be downloaded from http://www.java.com

OpenOffice

Inforama Studio uses OpenOffice as its embedded word processor to produce letter templates. Inforama Studio is compatible with OpenOffice 2.3, 2.4 and 3.x. If not already installed download OpenOffice from http://www.openoffice.org.

Installing Inforama Studio

Download the latest version on Inforama Studio from SourceForce at http://sourceforge.net/projects/inforama/files/. The downloaded file is a zip format and should be extracted to an empty directory.

Windows Users

For users of OpenOffice 2.x, open the file run-oo2.bat in a text editor and set the path to the OpenOffice directory. The default entry is SET OOPATH=C:\Program Files\OpenOffice.org 2.3. This will need to be changed to the path where OpenOffice was installed. Now you can double click the run-oo2.bat file to launch Inforama studio.

For users of OpenOffice 3.x, open the file run-oo3.bat in a text editor and set the path to the OpenOffice directory. The default entry is SET OOPATH=C:\Program Files\OpenOffice.org 3. This will need to be changed to the path where OpenOffice was installed. Now you can double click the run-oo3.bat file to launch Inforama studio.

Linux Users

For users of OpenOffice 2.x, open the file run-oo2.sh in a text editor and set the path to the OpenOffice directory. The default entry is OOPATH="/usr/lib/openoffice". This will need to be changed to the path where OpenOffice was installed. Now you can double click the run-oo2.bat file to launch Inforama studio.

There is a problem with locating the OpenOffice program on some Linux distributions. This can be resolved by adding a symbolic link to the OpenOffice program folder from the root directory as follows...

ln -s /usr/lib/openoffice/program/soffice /soffice

Work on the Linux shell script for OpenOffice 3 is underway.

Once started, the Inforama Studio application will appear as shown in Figure 1.

Figure 1: Inforama Studio

Installing the sample database

In this tutorial we will be developing a project which will use data from the Sakila database which is a sample database published by MySQL. Documentation on the Sakila database can be found in the downloadable PDF at http://downloads.mysql.com/docs/sakila-en.a4.pdf.

For information on downloading and installing the Sakila database go to http://dev.mysql.com/doc/sakila/en/sakila.html

Please note that the Sakila database requires MySQL version 5.

A quick tour of Inforama Studio

The screenshot in figure 2 shows the main elements of the Inforama Studio application.

Figure 2: Main elements of the Studio

Frame #	Description
1 – Toolbar	Shortcut toolbar for quick access to application functions.
2 – Documents Frame	List of documents contained in the current project. Documents can be opened for editing by double-clicking the document name in this frame. When a new document is created in the editor or is imported into the project it will be listed in this frame.
3 – Components Frame	When editing Acrobat Forms, the acrobat fields contained in the Acrobat Form are listed in this frame. The icon beside the acrobat field indicates whether the acrobat field is a text field, a check box, an image, or a bar code. The Acrobat Field Value text area at the bottom of this frame is where data bindings and evaluations are defined. When a binding is created by double-clicking the data field list in the Data frame described below, it will appear in this text area.
4 – Main Document Editor	When a new document is created or is opened by double-clicking a document in the documents frame described above, it will appear for editing within this main content frame. There are two main types of document which can appear in this frame – OpenOffice Documents or Acrobat Forms. When an Acrobat Form from OpenOffice document is opened in this editor there is the option to switch between document and Acrobat Form mode.
5 – Data Frame	Datasets defined within the Inforama project are listed here and can be previewed in the table. When bindings are required within documents the fields within this frame can be double-clicked in order to create them. This frame also contains buttons at the bottom to allow fields to be formatted using the data formatters within Inforama.
6 – Parameters Frame	When generating documents, parameters are provided which are used by the datasets in order to retrieve the relevant datasets. These parameters are added and removed within this frame. Parameters can also be bound directly to documents allowing them to be send directly to the document generation engine. As with the Data frame, a button at the bottom of this frame allows access to the data formatter.
7 – Properties Frame	When editing Acrobat Forms this frame is populated with Acrobat Field properties when an Acrobat Field within the document is selected. Different properties will appear depending on the type of Acrobat Field selected. Properties can be changed from here and will be applied to the document when it is saved.

Creating your first Inforama Project

Whether you intend to generate documents within Inforama Studio or within Inforama Enterprise, the first step is to create a project within Inforama Studio. You can do this by clicking the File – New project... menu item and the dialog shown in figure 3 will appear.

Figure 3: New project dialog

Enter the name that you want to give the project and also the path to an empty directory where you want the project to be created. Click the Create button and the basic project files will be created in the specified directory.

You're now ready to create your datasources, document templates and other resources which will be outlined in the following section.

Inforama Studio Tutorial 1.3

2009-08-28T10:43:59Z

This tutorial will guide you through the features of Inforama Studio