Liferay.com

Create an upgrade process in 6.2

2013-05-18T20:09:11Z

Introduction

Recently I've been working in some new features regarding to internacionalization the name and description of DLFileEntryType entity. I create all the logic and everithing was fine. Everthing went smoothly.

Due I was changing a DB table I had to create an upgrade process and the things became a litle bit hard (it's my very fist time creating an upgrade)... Why? Because I found an absolute lack of updated documentation about this kind of process.

It's true that I found a few wikis but it was a little messy (It was very funny to see five core engineers in the LA office triying to decode the [obsolete] documentation, true story...) So I've decided to create my fist blog entry regarding this.

But first of all... What is an upgrade process??

What we try to do in a upgrade process is guarantee that Liferay can upgrade from any previous version to any newer version.

We can see this in the following example.

I'm going to explain (based in the develop I made) the whole process, explaining how did I upgrade the DLFileEntryType entity by adding a new column called fileEntryTypeKey and changing the name and the description columns introducing localization properties.

Step 1 - Modify an entity

The first thing to do is to perfome all the required changes in the entity. It will give you the basis for the rest of the process. Not very much to explain, edit the service.xml ...

...Then run...

... and modifiy the Impl classes you need. Nothing special

Step 2 - Change .ftl if needed

If the entity has some default objects (i.e. DLFileentryType has 5 default types) maybe you'll need to change its .ftl file :

Step 3 - Create some UpgradeProcess classes

Go to the proper version UpgradeProcess[XXX].java file (for us it's UpgradeProcess_6_2_0.java) and search for the right Upgrade[XXX].java (in this case is UpgradeDocumentLibrary). In this class (wich extends UpgradeProcess) you must introduce and override the doUpgrade() method like this:

As you can see we are directly using pure sql to perform the database upgrade. This clauses are surrounded by a try…catch that calls the method upgradeTable(few params) if something goes wrong...

Let's see that method deeply:

In there we are creating an UpgradeTable.java instance and we pass some values regarding the table we are modifiying. We get this values from an autogenerated class called XXXTable.java (DLFileEntryTypeTable.java for us).

Step 4 - Create the [XXX]Table class

Create this class is as simple as make its skeleton, modify portlet-model-hints.xml to define the configuraiton of the columns...

...and then run...

This is the generated class:

Step 5 - Create some logic to format and persist the current data

The last method that we can see in doUpgrade() is:

Here we are getting the previous values and we pass them to...

...where we will reuse them in the modified table.

Step 6 - Regenerate all the service and TEST!

This is the final step. All you got to do:

VERY IMPORTANT!!

Run

Doing this you could be sure you are not breaking the default data.

And that's all!!!

Managing Liferay through the Gogo shell

2013-05-15T00:04:24Z

I have done a huge refactor for most of our OSGi related work, moving the majority of its components to the Liferay plugins SDK. Everything except the graphical admin UI is already in the master branch of the official repo so you can play with it; we would love to hear your feedback.

My goal with this post is to show you how create a new OSGi bundle in the plugins SDK using a practical example: extending the OSGi shell (we have spoken about it sometime ago). Let's try to do it:

Basic project structure

Currently there is no target in the SDK which allows you to create a bundle (I will push it soon) so you can use this example (or the other modules as http-service-shared or log-bridge-shared) as the basic skeleton for your tests:

As you can see, the structure is very simple; let my try to highlight the main OSGi related points:

All the new OSGi plugins will be based in the great bnd tool . You can configure all your bundle requirement through the bnd.bnd file
The build.xml of the plugin must import the build-common-osgi-plugin.xml build file: <import file="../../build-common-osgi-plugin.xml" />

As I have told you before I will include an Ant target to create this basic skeletons, but, until then, you need to do this by hand. Sorry about that :(.

Writing Gogo shell custom commands

As we have stated at the beginning of the post, we are going to write a bunch of custom commands for the Gogo shell. As you will see, this is an extremely easy task.

This commands can be created using a simple OSGi service with a couple of custom properties. We will use the OSGi declarative services approach in order to register our commands (Liferay already includes an implementation of the Declarative Services specification in the final bundle, so you don't need to deploy it by yourself).

At this point, we are ready to write our first command: the ListUsersCommand:

The @Component annotation let us to define a new OSGi service in an extremely easy way. The Gogo commands are registered in the console using the properties osgi.command.function and the osgi.command.scope. The first one establishes the name of the namespace where the command will be allocated (in order to prevent name collisions) while the latter specifies the name of the command. It is important to note that the Declarative Service annotations I am using does not support inheritance, so everything you declare in a base class will not be inherited down in the hierarchy.

And, how do I write the implementation of my new command? You just need to write a new public method named as the value written in the osgi.command.function. If your command needs some argument you will need to specify as a parameter of your method (an the console will do the coercion of the basic types). In our example we are creating a usermanagment namespace, with a command called listByCompany which expects the companyId (long) as the unique parameter.

Easy, isn't it?

Consuming Liferay services

I would like to highlight the implementation of the listByCompany command (I am sure you have already guessed the previous command retrieves all the users of a certain company).

In order to get all this info we need to call the corresponding method in the users service. We could do something like UserLocalServiceUtil.getCompanyUsers(companyId) but this is not a good approach, so we are to going to get all the benefits of having all the Liferay services as OSGi services. We just need to grab a reference to the UserLocalService bean:

@Reference

public void setUserLocalService(UserLocalService userLocaService) {

_userLocalService = userLocaService;

}

protected UserLocalService _userLocalService;

Building and running the bundle

Once we have written our command we need to build our final artifact: just type ant jar in the project folder and you will get the final jar file into the dist folder. Before deploying our new bundle let's connect to the Gogo shell in order to check which bundles we have already installed:

As you see, we have already a bunch of bundles running but nothing about the new commands we are writing. What commands are currently available in the console? Just type help in the console

Now we have to deploy our new bundle. To do that, we just need to copy it to the folder $liferay.home/data/osgi/deploy (it is the default folder, you can change it in the properties). You can use the deploy Ant task our just copy the folder into the previous folder. Once the bundle is deployed we should see it in the bundles list:

Take a look to the last line; you will see our bundle has been deployed and it is, hopefully, running. Let's see which commands we do have available once our new bundle is already installed.

Do you see the last two lines? These are the commands we have written (in this post we only have described one command, you can find the other one in the companion source code). So, if I type listByCompany ID_OF_A_COMPANY (mine is 10153) (since there is no collision I don't need to prefix the command with the namespace) you should get an output similar to this:

Users of the company 10153

User default@liferay.comwith id 10157

User test@liferay.comwith id 10195

Along this post we have seen how we can extend the Gogo shell creating new commands, consuming Liferay services and building a basic OSGi bundle in the plugins SDK. It is not a big deal but I think it is a good starting point to get used to the new OSGi abilities. Hopefully I will be able to push some more complex examples in the near future.

You can find the whole source code in the shared/gogo-commands-shared folder at my plugins repo.

Mavenize Liferay Plugins SDK - Using Maven

2013-05-14T04:27:40Z

Overview

When working with Liferay projects using Liferay IDE and Plugins SDK it becomes highly difficult to manage dependencies, as Liferay IDE or Plugins SDK by default uses Ant for building and deploying, though Liferay does support Maven based Plugins but as a seasoned Liferay Developer we will be inclined to use Ant preferred to Maven.
The problem rather I call it a difficulty arises when,

The number of dependencies for our Portlet project increases and we need to maintain a version based configuration
We need to use or integrate our Portlet application with an existing Maven based application from an Organizational build repository

In this article we will look at how we can use Maven dependency management in Plugins SDK by still using the default Ant based Liferay SDK build, you can use any of your existing Liferay Plugins SDK project which has external dependencies.

Technical Platform

I have tested this application on the following technical platform, this works irrespective of Operating System.

Software	Version	Download Link
Liferay CE Portal Server (Tomcat)	6.0.x	http://sourceforge.net/projects/lportal/files/Liferay%20Portal/6.0.6/liferay-portal-tomcat-6.0.6-20110225.zip/download
Liferay CE Plugins	SDK 6.0.x	http://sourceforge.net/projects/lportal/files/Liferay%20Portal/6.0.6/liferay-plugins-sdk-6.0.6-20110225.zip/download
Apache Ant	1.7.x or above, preferred 1.8.x	http://ant.apache.org/bindownload.cgi
Apache Maven	2.2.1 or above, preferred 3.0.3	http://maven.apache.org/download.html
Apache Maven Ant Tasks	2.2.1 or above	http://maven.apache.org/ant-tasks/download.html

The Server distribution is not required for the subject of the article it’s preferred to have as the Liferay Plugins SDK might/will use some dependencies from the server distribution

Setup and Installation

Assuming that you have downloaded and installed the above mentioned softwares, for the sake of convenience we will use the following variable names for respective installation DIR’s,

$LIFERAY_HOME - the home directory where Liferay server is installed e.g. C:\lportal-6.0.6
$LIFERAY_SDK_HOME - the home directory where Liferay server is installed e.g. C:\liferay-plugins-sdk-6.0.6
$ANT_HOME - the home directory where ANT is installed e.g. C:\apache-ant-1.8.2
$M3_HOME - the home directory where Maven 2.2.x is installed e.g. C:\apache-maven-3.03

Now copy the maven-ant-tasks-2.1.3.jar to $ANT_HOME/lib

Implementation

Let’s use the Liferay IDE to create a new Portlet plug-in look at Using Liferay Maven SDK or you can import the attached Liferay Google Maps demo project in to your workspace,
Open the build.xml of the project that has been created, by default the project build template looks like

Now to Mavenize the default ANT build.xml we do the following,

Add the xmlns:artifact=” antlib:org.apache.maven.artifact.ant” to the element of the orginal build.xml
Create a new ant target called “copy-dependencies”, this step is crucial, you can have any name for the target but then what the target does is important. This target will download (only time only) and copy the dependencies to docroot/WEB-INF/lib folder
Add an ant call to “deploy” target within the “copy-dependencies”, this will enable the build.xml to follow the default Portlet application building and deploying post copying the dependencies
Make the copy dependencies as the default target for the project

A example of build.xml with above configurations is available here

Observe the artifact:dependencies task portions those are important pieces of mavenizing our ant build. We add the dependencies to the project the same way we add them in Maven pom.xml with little bit of variation to the syntax.

After this once you execute the build in Portlets plug-in directory, it will first download the dependency jars if it does not exist in to the local Maven repository and they will added to the docroot/WEB-INF/lib directory when copy-dependencies target is called, which also includes call to the Liferay default deploy target

Voila! Now we are able to use the Maven dependency management with Liferay Plugins SDK default Ant build system. I hope this article has helped you, for further reading you can check the following links,

HOW-TO Clear Liferay Cache

2013-05-14T04:26:24Z

I was learning on how to implement the export and import functionality on Liferay, initially I thought it to be rather a tedious job but thanks to Liferay API/Framework which made my job easier with Liferay Portlet Data Handlers thanks to Jorge Ferrer who gave me an insight to the API/Framework and how to use the same. All I was required to do is just create a class that extends from BasePortletDataHandler and have it configured via the liferay-portlet.xml

But this activity lead to an interesting learning, initially when I implemented this I saw that data was getting exported/imported without any errors but then I see that its not refreshing the UI immediately after the import. This kind of annoyed me for long time .. thanks to Raymond Auge for is timely insight that we need to clear the cache for the same to be refreshed.. so started my next task on hunting the class which can do the job..

The initial analysis started with me doing the manual task of clearing the caches via the Portal Control Panel using the Server Administration --> Resources (tab) --> Actions panel where we have the action buttons that will clear the cache held by Database, Virtual Machine both local and clustered... when i did this sequence of actions after my Import, i see the data getting refreshed instantly.. so whats next ? finding out the class that did these jobs, when back tracing from the Server Admin page i landed up in the class EditServerAction, there I got the following three sweet little methods that can do the job for me,

CacheRegistryUtil.clear() - to clear all the Database caches
MultiVMPoolUtil.clear() - clearing cache across JVM clusters
WebCachePoolUtil.clear() - clearing cache in Single VM

All left with me post this findings is that i need to call the required or all methods post my successful import of the data to clear the required caches...

Using liferay-ui:search-toggle - with Basic or Advanced Search only

2013-05-14T04:15:25Z

I was using <liferay-ui:search-toggle> tag, and my requirement was to to show only advanced search and no basic search. but by default <liferay-ui:search-toggle> will show basic search unless and until user clicks the advanced search atleast once. I tried all possible ways and finally found the solution, this what i did to make my <liferay-ui:search-toggle>show only "Advanced Search" without "Basic" search toggle link.So what we need to do is,

We need to override the isAdvancedSearch method of the XDisplayTerms class to always return true, where "X" your class prefix e.g.ArticleDisplayTerms which extends form com.liferay.portal.kernel.dao.search.DisplayTerms
Update your *_search.jsp which has the <liferay-ui:search-toggle> with the following piece of code

<style type="text/css">   
             .toggle-link {display: none;}
</style>

This style overriding will prevent the "<<Basic" search link form being displayed, the next piece of code snippet will make the "Advanced" search displayed by default, we are a kind of triggering the Search link click
....
String key = "<replace with the id of your <liferay-ui:search-toggle> tag";
SessionClicks.put(request, key,"advanced");
.....

The key piece of code which does sends signal to the underlying liferay code to show only "advanced" is SessionClicks.put(request, key,"advanced");

The same could be achieved when we want to display only basic search and no advanced search just by changing the "advanced" --> "basic"

That is it, once we have done with this our <liferay-ui:search-toggle> will always display only "Advanced" or "Basic" search

Liferay Portal 6.1-CE on JBoss AS71

2013-05-14T04:11:38Z

After setting up Liferay Portal 6.1-CE on JBoss AS7 based in this post, i thought it was a piece of cake to deploy Liferay Portal 6.1-CE on JBoss AS7.1(Thunder) but not until i found that we need to do few more updates rather changes to Liferay 6.1-JBoss CE bundle.

Here is the list of what we need to do,

$JBOSS_70_HOME - refers to the Liferay 6.1-CE JBoss AS 7.0.2 directory or any JBoss AS 7.0.2 directory where you have deployed Liferay Portal

Liferay Modules -- Check the $JBOSS_70_HOME/modules/com/liferay/portal/main/module.xml you will see urn:jboss:module:1.0,the we need to update to urn:jboss:module:1.1, once one we can copy it to the $JBOSS71_HOME/modules directory
You need to repeat this for any additonal modules that you might have deployed to the JBOSSAS_70 JBoss Portal bundle
Deployment Structure (optional) -- Based on this AS71 post, I understood that JBoss AS71 does not export the system module, but if we check $JBOSS71_HOME/standalone/deployments/ROOT.war/WEB-INF/jboss-deployment-structure.xml you will see an dependency as follows,

</imports>

</module>

Just remove or comment that entry

And that's it once we do that and try redeploying the ROOT.war (rename the ROOT.war.failed --> ROOT.war.dodeploy) will trigger the deployment.

How-To implement Pagination in Liferay

2013-05-14T04:07:56Z

Liferay provides a rich set of tag libraries that can help in implementing certain complex functionalities like search container, pagination etc., with few lines of code. In this blog let’s see how we can implement the same.

For the demo purposed I used the following technical platform,

Liferay Portal v6.1.CE (beta)
Liferay Portal SDK v6.1.CE
Apache Ant 1.8.2
RHEL 6.1 (Windows could also be used)
Eclipse IDE 3.7.1 with Liferay IDE

Use case

This demo uses a very simple use case of displaying 200 list items of type ListItemModel, the ListItemModel is the model class as shown below,

ListItemModel.java

This model class holds the item its id, name and description. The application will build a Portlet that will display the Model List items with pagination as shown below,

PaginationDemoPortlet

The user should be able to paginate across 200 records with 10 records on each page with Previous, Next, First and Last options.

Implementation

To achieve the use case the application uses a small DAO utility class called Pagination Utility, this class will help in Querying for the records from the back end (here its mock objects), the PaginationUtlity class has only one method called getListItems(int n) that will return ‘n’ list items. The PaginationUtility class is shown below,

PaginationUtility.java

The following steps shows how to implement the Pagination using liferay-ui [1] tag, typically the code of the view page.

The first and fore most step is to define the pagination container, the liferay-ui 1tag provides a the search-container1 tag which could be used to initialize the container

<liferay-ui:search-container emptyResultsMessage="there-are-no-items" delta="10">

Parameter	Description
emptyResultsMessage	Used to display the message to the user when no records are found, a resource bundle key could be specified for internationalization
delta	the default number of items that needs to be displayed on the page

The next step is to manipulate the result and set the same in pageContext of the JSP page, this is done using the liferay-ui’s search-container-results1, when manipulating the result we need to set the following pageContext variables to enable the Liferay-ui tag to process and display them,

a. results – the variable that will hold the subList of the entire result set with its start determined by searchContainer.getStart() and end determined by searchContainer.getEnd(), where searchContainer is an implicit variable available to the page context after Step #1

b. total – The total result set size , in our case 200

<liferay-ui:search-container-results>

List<ListItemModel> tempResults = PaginationUtil

.getListItems(200);

results = ListUtil.subList(tempResults,

searchContainer.getStart(),

searchContainer.getEnd());

total = tempResults.size();

pageContext.setAttribute("results", results);

pageContext.setAttribute("total", total);

</liferay-ui:search-container-results>

The third step of the implementation is to define the result row which is done using the liferay-ui’s search-container-row tag, this tag takes the following parameters,

Parameter	Description
className	The model class that is contained in the result set returned by the PaginationUtil
keyProperty	The primary key or unique key property that will be used or passed to various actions
modelVar	The temporary variable where the current resultset object will be stored, typically an instance of className

<liferay-ui:search-container-row

className="com.accenture.icos.demo.portlets.ListItemModel"

keyProperty="id" modelVar="listItemModel">

The fourth step of the implementation is to define the columns that will be displayed in the resulting table, this is done using the liferay-ui’s search-container-column-text[1] this tag takes the following two properties,

Parameter	Description
name	The HTML name attribute for the table column
property	The model property form which the value of the column needs to be set

<liferay-ui:search-container-column-text name="id" property="id" />

The last and final step of the implementation is to define the paginator element of the results which will help in navigating across pages typically First, Next, Previous, Last etc., this is done using the liferay-ui’s search-container-row[1]

</liferay-ui:search-container-row>

[1] The tag libraries used above also take certain other parameters, which can be used on need basis for further details please consult the Liferay TLD documentation

Using Liferay Portal 6.1 Published in Print

2013-05-13T20:48:02Z

I am pleased to announce the immediate availability of the print edition of Using Liferay Portal 6.1! For those of you on your toes (and you know who you are), it's actually been available since Friday, but who reads a blog entry that is published on Friday afternoon?

It's a big book. We're getting close to 700 pages now in print, and that does not include the properties reference, which we think is better as an online reference than stuffed into the book (plus, we can lower the price if we excise those pages). I want to acknowledge the hard work of Liferay's Knowledge Management team for a job well done: Jim Hinkey, Stephen Kostas, Jesse Rao, and Cody Hoag. In addition to these guys, some other key contributors include James Falkner, Bruno Farache, Michael Han, Jeffrey Handa, Mark Healy, and Jonathon Omahen.

So if you like big, thick books on your shelf, especially ones with the Liferay logo on them, why not pick one up?

Of course, we're not stopping there. I'm in the midst of working on the styling of the epub version of the book, which we'll release next. Stay tuned!

RE:5 tips to improve usage of the Liferay script console

2013-05-13T19:31:28Z

// In reply to 5 tips to improve usage of the Liferay script console - by Sébastien Le Marchand

Sébastien wrote a very good article about Liferay script console. Here is one more tip in response of the call for sharing at the end of the article. I post it as a sepreate blog entry because I cannot use Gist or format in comment area....

Tip #6: Schedule your script to run as a CRON job

If you want to schedule your script to execute at certain times as a CRON job (One scenario can be: Run the task "deactivate users never logged and created since more than 2 years" every month.), you can use Liferay's Scheduler Engine API, like in the following example:

The following code outputs the string "test" to a file one time per minute in the next 10 minutes:

You can change your job schedule by changing the parameters in CronText constructor.

You will also need to use proper escape characters in the script.

Note that when Liferay Scheduler Engine execute the script, the following predefined variables are not available:

```
out (java.io.PrintWriter)
```

actionRequest (javax.portlet.ActionRequest)

actionResponse (javax.portlet.ActionResponse)

portletConfig (javax.portlet.PortletConfig)

portletContext (javax.portlet.PortletContext)

preferences (javax.portlet.PortletPreferences)

userInfo (java.util.Map<String, String>)

5 astuces pour améliorer l’usage de la console de script de Liferay

2013-05-13T06:31:31Z

// The english version of this article can be found here: 5 tips to improve usage of the Liferay script console.

// Si vous utilisez un lecteur RSS pour lire ce billet, veuillez basculer vers la page HTML pour voir correctement les morceaux de code.

Depuis la version 6.0, Liferay propose une console de script intégrée dans le Control Panel. Très puissant, cet outil devient vite indispensable dès que l’on y a goûté (si vous ne connaissez pas encore la console de script, jetez un oeil sur l’article d’introduction de Jeffrey Handa).

Dans la suite de ce billet, je vais vous présenter 5 astuces simples pour encore mieux profiter de la console de script.

Les exemples de mise en oeuvre qui suivent sont basés sur le langage Groovy, mais la plupart de ces astuces sont applicables avec les autres langages supportés par la console de script du portail.

Astuce n°1 : Mettez du HTML dans vos sorties

Il faut savoir que la sortie par défaut de la console de script est rendue directement en tant que contenu HTML. Pensez-donc à intégrer des balises HTML dans vos sorties pour bénéficier d’une mise en forme riche.

Exemple de script :

Résultat :

Astuce n°2 : Affichez les exceptions dans l’interface utilisateur

Lorsque une exception survient lors de l'exécution d’un script, le message d’erreur est toujours le même quelque soit l’exception et ne donne aucun détail, ce qui oblige à consulter les logs du serveur pour effectuer un diagnostique.

Pour obtenir le détail de l’exception directement dans l’interface utilisateur, encadrez l’ensemble de votre traitement par un bloc try/catch et affichez la stack trace de l’exception sur la sortie de la console (depuis la clause catch)..

Example de script :

Résultat :

A noter que cela ne fonctionne pas pour les erreurs liées à la syntaxe du script.

Astuce n°3 : Exploitez les variables prédéfinies

Un script exécuté depuis la console du control panel dispose des variables prédéfinies suivantes :

```
out (java.io.PrintWriter)
```

actionRequest (javax.portlet.ActionRequest)

actionResponse (javax.portlet.ActionResponse)

portletConfig (javax.portlet.PortletConfig)

portletContext (javax.portlet.PortletContext)

preferences (javax.portlet.PortletPreferences)

userInfo (java.util.Map<String, String>)

Lorsque vous écrivez vos scripts, soyez conscient des possibilités offertes par ces variables, tout particulièrement la variable actionRequest, utile pour beaucoup d’appel de méthodes.

Exemple de script :

Résultat :

Astuce n°4 : Implémentez un mode preview

La console de script ne permettant pas de faire de rollback sur l’exécution d’un script, il est très pratique d’intégrer un mode preview pour les scripts qui modifient les données en base.

Ce mode "preview" consiste à utiliser un flag qui détermine si les les opérations à effets de bord sont exécutées ou non, alors que les données parcourues sont systématiquement tracées. Ceci permet donc de se faire une idée des données impactées par un script avant de faire effectivement les mises à jour en base de données.

Exemple de script :

Astuce n°5 : Prévoyez une sortie fichier pour les scripts "longue durée"

Lorsque l’exécution d’un script dépasse une certaine durée, la console ne répond plus et retourne une erreur, alors même que le script peut continuer son exécution et potentiellement mener à bien l’ensemble de son traitement... Mais impossible de connaître le statut du traitement sans la sortie correspondante !

Pour remédier à cela, il suffit de prévoir une sortie fichier en plus de la sortie console, comme sur l’exemple ci-dessous :

Une fois le script initial exécuté, il est possible de lire le fichier généré sans pour autant avoir d’accès direct au système de fichier, en utilisant un second script :

A noter que cette technique basée sur un fichier de sortie dédié est préférable à l’utilisation d’un logger classique car elle facilite la récupération des données de sortie du script (qui seraient plus difficile à isoler parmi l’ensemble des logs du portail).

Et vous, avez-vous des astuces à propos de la console de script à partager avec la communauté ? Faites en part dans les commentaires de ce billet !

Lectures complémentaires

5 tips to improve usage of the Liferay script console

2013-05-13T06:30:31Z

// La version française de cet article est là : 5 astuces pour améliorer l’usage de la console de script de Liferay.

// If you use a RSS reader to read this post, please switch to the HTML page to correctly view the code snippets.

Since the release 6.0, Liferay provide a script console integrated into the Control Panel. Very powerful, this tool becomes fast essential for any portal administrator or developer (if you do not still know the script console, have a look on this article by Jeffrey Handa).

During this post, I am going to present you 5 simple tips to take better advantage of the script console.

The following implementation samples are based on the Groovy language, but most of them are applicable with other languages supported by the portal script console.

Tip #1: Use the HTML in your outputs

You need to know that the script console default output is rendered as HTML content. Thus, think to embed HTML markup in your outputs to enjoy rich formatting.

Script example:

Output:

Tip #2: Show up exceptions on user interface

When any exception arises during script execution, the error message is always the same and give no detail about the error. So, you need to access server logs to make a diagnostic.

To show up exception details on the user interface, envelop your whole code with a try/catch block and print the stack trace on the console output (from the catch clause). There is nevertheless a limitation: it doesn’t work for script syntax errors.

Script example:

Output:

Tip #3: Exploit the predefined variables

A script executed from the Control Panel can access the following predefined variables :

```
out (java.io.PrintWriter)
```

actionRequest (javax.portlet.ActionRequest)

actionResponse (javax.portlet.ActionResponse)

portletConfig (javax.portlet.PortletConfig)

portletContext (javax.portlet.PortletContext)

preferences (javax.portlet.PortletPreferences)

userInfo (java.util.Map<String, String>)

When you write your scripts, be aware of possibilities offered by these variables, particularly the actionRequest variable, useful for a lot of method calls.

Script example:

Output:

Tip #4: Implement a preview mode

The script console not allowing execution rollback, it’s very convenient to set up a preview mode for side-effect scripts (i.e. performing database updates).

This "preview mode" consists in using a flag which determines if the operations with side effects are executed or not, while the visited data are systematically printed. This thus allows to have an outline of the data impacted by the script, before effectively doing updates to database.

Script example :

Tip #5: Plan a file output for "long-running" scripts

When the execution of a script exceeds a certain duration, the console doesn’t respond any more and returns an error, whereas the script can continue its execution and potentially bring to a successful conclusion... But impossible to know the status without the corresponding output!

To by-pass this limitation, you can set up a file output besides the console output, like in the following example:

Once the initial script was executed, it is possible to read the generated file without direct access to the file system, by using a second script:

Note that method based on a dedicated output file is better than using a classic logger because it’s easier to get back the script output data (which would be more difficult to isolate among all portal logs).

And you, do you have some tips about script console that you can share with the community ? Let us know in the comments !

Using custom java classes in a JSP hook

2013-05-13T19:26:02Z

Issue

In Liferay hook development, one common question is:

How to import/use/access custom java classes in a JSP hook?

The question can be described as:

1. Create a hook project (for example: sample-hook)

2. Create a custom class (for example: com.kzhang.CustomJavaClass) in hook project.

3. Override a Liferay portlet jsp (for example, html/portlet/blogs/view.jsp) and try to use the CustomJavaClass in the jsp. Liferay will throw "class CustomJavaClass can't be resolved to a type" exception or ClassNotFound exception.

Cause

The jsps in hook plugin is deployed to ROOT servlet context. for example, the html/portlet/blogs/view.jsp in hook plugin will be copied to ${container.deploy.folder}/ROOT/html/portlet/blogs/view.jsp, and the origional view.jsp will be renamed as view.portal.jsp.

The custom classes are still remains in the hook servlet context. for example, the com.kzhang.CustomJavaClass in hook plugin will be still in ${container.deploy.folder}/sample-hook/WEB-INF/classes/com/kzhang/CustomJavaClass.class.

In html/portlet/blogs/view.jsp it can not find CustomJavaClass because each servlet context can only see it's own classes and those of the parent classloaders. In our case, the html/portlet/blogs/view.jsp is in ROOT servlet context which can not see the CustomJavaClass in sample-hook servlet context

Solution

There are some discussions in Liferay forum:
http://www.liferay.com/community/forums/-/message_boards/message/7454307
http://www.liferay.com/community/forums/-/message_boards/message/13467179
http://www.liferay.com/community/forums/-/message_boards/message/21397246
http://www.liferay.com/community/forums/-/message_boards/message/11508053

The most common solution is to use the ext plugin instead of hook plugin.

But can we avoid using the ext plugin and leave everything as a hook?

Solution 1: Use Spring + PortletBeanLocatorUtil + JAVA reflection

Step 1. Create the custom-spring.xml in /sample-hook/docroot/WEB-INF/src/context/custom-spring.xml folder.

Step 2. In custom-spring.xml, define the bean for your custom java class:

Step 3. In web.xml, add the context-param to load the custom-spring.xml:

Step 4. In custom_jsps/html/portlet/blogs/view.jsp, use PortletBeanLocatorUtil to load the custom java class:

If your CustomJavaClass implements an interface which is accessable in ROOT servlet context, then you can cast the customJavaClass to the interface and use the class thru interface. Otherwise you will need to use JAVA reflection to dynamically invoke the methods in the custom class.

Solution 2: Override Struts Action and call the custom classes in Struts Action.

Setp 1. In liferay-hook.xml, override the view action of blogs portlet:

Step 2. Create the CustomStrutsAction, invoke the custom class in CustomStrutsAction and set the result in to renderRequest attribute:

( Instead of result, you can also set the custom class in the renderRequest attribute and invoke it in jsp either by using it's Interface or use java reflection)

Step 3. In custom_jsps/html/portlet/blogs/view.jsp, get the result from the renderRequest attribute:

Liferay Sync Mobile 2.0

2013-05-11T19:18:11Z

We are pleased to announce that Sync Mobile 2.0 has been released!

In addition to having incorporated several bug fixes, this version represents the integration of noteable, new features:

Tablet Support: You can, now, use Sync on your iPads and Android tablets.

Revamped UI: Allows you to fully take advantage of larger screen sizes while providing for a heightened file-previewing experience.

Here are some screenshots of Sync running on an iPad:

You can install Sync from Google Play and App Store.

Liferay, WebSockets, and Node: Good Times!

2013-05-08T23:41:56Z

Lately I've been tinkering a lot with lightweight, asynchronous, event-driven apps on Liferay using a variety of established techniques and frameworks. It's a nice way to build apps! After working it for a while, I wanted to share what I've learned, so put together a talk and was fortunate to be selected to attend and speak at this year's KCDC, and presented my learnings and a demo via a presentation on Event-driven Programming with Java and HTML5 WebSockets.

You can find the slides on SlideShare, and the demo code on GitHub.

At the end of the presentation I showed a demo, and I wanted to go into a bit more detail here. It is essentially a WebSockets demo using a Google Heatmap to visualize the location of bloggers who are blogging on a Liferay site. I used Tomcat 8.x for the JSR-356 WebSockets implementation, partly because I am comfortable it, but also because it has a bug that I wanted to use to demonstrate a point I made during the talk :) I'm pretty sure GlassFish doesn't suffer from this!

Social Driver

To simulate lots of people doing activity on Liferay (and therefore generating activities for which I can listen), I re-used my Social Driver, resurrected from 7Cogs. This code spawns theads that programmatically create users and create blog entries, wiki pages, forum posts, and do other activities like vote and comment on content. It does this in separate threads, which simulates lots of people doing things on your Liferay site.

I have covered the basics of the SocialDriver in my series of "7Cogs is Dead! Long Live 7Cogs!" posts (here, and here), which I hope to finish off in the next couple of weeks.

Demo Part 1

In the first part of the demo, I have a Google Heatmap which visualizes the location of the fake users, based on their registered address (which is also faked). When content (blogs, wikis, forums) is created, a SocialActivity is generated. My hook listens for these events, and sends them to my WebSocket endpoint, which ships them to my client webpage with the Google map.

It all works great when you have a single thread generating events. The map builds nicely, and all is well. However, a few seconds after you start up more threads, things get weird, and WebSocket messages emitted from the server get jumbled and mixed together, causing the browser to immediately fail the websocket connection, and the client comes to a grinding halt (Liferay happily continues to create activities, though).

Demo Part 2

In part 2 we used Wireshark to inspect the network traffic, in an attempt to debug the problem. Looking at the network traffic reveals that in the end, the last few WebSockets frames are mixed up / jumbled up, causing the browser to misinterpret the bytes, and fail quickly (which is nice!).

The problem appears to be that the code in Tomcat for sending messages down the pipe isn't multithread-safe. Two or more threads can get into the same area of code, and send content at the same time, and this is exactly what happened here: my blog thread and my wiki thread tried to send messages to the client at the same time, and one's message was mixed in with the other, causing the browser to issue a cryptic Could not decode a text frame as UTF-8. Looking at the offending packet in Wireshark:

You can see the complete message of {"address":"Sudan"} but then some more bits that is the beginning of the next message, which the browser tries to interpret as text, and fails (it's actually the beginning of the next websocket frame).

Synchronizing the code that calls into Tomcat does the trick (e.g. via synchronized), but a) I shouldn't have to do that because it's part of the spec (and I think this is a bug in Tomcat), and b) Tomcat might not be the best place to scale out, especially because it's hosting Liferay already. Node.js to the rescue!

Demo Part 3

Here, we let Node handle the websockets broadcasts to the clients, while Tomcat and Liferay handle the portal itself.

The code in my tiny node server (which requires websockets.js, via npm install websockets) does the trick. It listens for messages over HTML (this could have, and probably should have been done with redis pub/sub but I was out of time), and then broadcasts them to all clients listening on the websocket. In this demo there's only one client,

With node in place, and click the switch on the portlet, to switch over to it and then happily start up many threads and watch our heatmap build nicely:

Lessons learned

Coding event-based, asynchronous web program is fun and exciting! There are many frameworks and technologies to make it easy, both on client and server, and if I can do it, anyone can do it :)
It's really easy to integrate awesome apps with Liferay, due to its Java heritage, rich APIs and lightweight JSON or RESTful web services.
Java EE features (like JSR-356, aka WebSockets) and other upcoming technologies in Java EE 7 will lower the Java EE learning curve even further.

Enjoy!

Creating A Big Media Site in Liferay

2013-05-08T17:31:26Z

I wanted to prototype a site similar to an online tv and movie streaming service that isn't Netflix. I wanted to find a versital carousel that worked well with responsive (Flexslider2). I wanted the heading to become more of a solid background color after you scrolled down past the main carousel.

The carousels are fluid when the window is resized.

screenwidth: 1280px

screenwidth: 1024px

screenwidth: 480px

(after scroll past the main carousel the banner becomes a transparent color instead of gradient background image)

I loaded the additional js file for the carousel when detected

In the Main Carousel.vm velocity template I tweaked some of the js.

After the first slide is loaded I remove the loading class on the body tag.
I detect if there is a banner and toggle the banner from absolute position to fixed if the dockbar was still on the screen.
Detect the height of the carousel - #banner height then if vertical scroll is larger than that number then I add a class of changed, which replaces the background image with a background color.

Download and Test

Download big-media-theme.war for 6.1.1+

Git Branch

Select Category And add Post in message board using velocity template

2013-05-07T12:25:37Z

Hi Guys,

It is possible to put web content of MB-category in every page rather than to display message board in every page in website .

On selecting category, we will open a pop-up dialog box for inserting Post in message board.

Template Code :

#set ($MBLocalService= $serviceLocator.findService("com.liferay.portlet.messageboards.service.MBCategoryLocalService"))

#set($cat=$MBLocalService.getCategories($groupId))

<option value= "select"> -select-- </option>

#foreach ( $c in $cat)

<option value= "$c.getCategoryId()"> $c.getName() </option>

#end

</select>

</form>

function pop(value)

{

var s=value;

alert(s);

AUI().ready('aui-dialog','aui-dialog-iframe','liferay-portlet-url', function(A) {

var url = Liferay.PortletURL.createRenderURL();

url.setPortletId("19");

url.setWindowState('pop_up');

url.setParameter("&_19_struts_action=%2Fmessage_boards%2Fedit_message&_19_mbCategoryId=");

window.myDialog = new A.Dialog( {

title: 'Ask a Question?',

width: 640,

centered: true

} ).

plug(

A.Plugin.DialogIframe, {

uri: url.toString()+""+s,

iframeCssClass: 'dialog-iframe' }

).render(); });

}

</script>

I implemented this code at http://liferay.medicalassociation.in/ask-question Visit For Better Understanding .

Liferay Blog Reader 1.2 released

2013-05-07T18:46:13Z

After the first release, version 1.0, with the focus on stability and the most fundamental features we released a version 1.1 with minor updates related to feedback from community. Also some functionality like opening links embedded as content in blog entries.

Now we have released version 1.2, which is a facelift. We are very happy with the result trying to use color scheme that matches the default Liferay Portal look; so it feels "like Liferay" for the users.

Please get back to us with your feedback; input to our roadmap if there are features that would be nice for you to get there soon or if you have other feedback on e.g. the user interface.

The application (at the moment supported for Android platform) can be visited on Google Play via this link. Or you can also visit the product page.

Paris Pre-Symposium Community Meeting, 5. June 2013

2013-05-06T09:37:16Z

Nous sommes heureux d'annoncer un pre-Symposium évènement communautraire le 5 Juin 2013 au Caveau Montpensier: 15, rue de Montpensier, 75001 Paris, à partir de 18h00. L’évènement est gratuit et nous vous offrirons quelques boissons et snacks lors de la soirée. Veuillez confirmer votre présence en commentant ci-dessous ce blog. Votre confirmation sera appréciée et utile dans l'organisation de l'événement.
Passez le mot aux autres ...plus nous serons, meilleur ce sera !

We are happy to announce a pre-Symposium Community Meeting on June 5th 2013 at Au Caveau Montpensier : 15, rue de Montpensier, 75001 Paris, from 18:00 onwards. Attendance is free and the first couple of rounds of drinks and snacks are on us! Please let us know if you plan to come & join us by commenting below this blog post. Your confirmation will much be appreciated and helpful in planning the event.
Now, please help spread the word… the more the merrier!

Creating a Portlet in 6.1 CE

2013-05-04T10:36:29Z

How do you develop a portlet for liferay? Since often asked and being ridiculously easy, I wrote down the steps here:

In this work-through, I assume you have successfully installed Liferay 6.1 CE as well as Eclipse Indigo and the Liferay SDK IDE.

Then you can start the standard eclipse "New... wizard" and chose to create a "Liferay project":

Give it a name and chose "Portlet" as the plugin type:

Of course, we will use the simpliest possible approach and thus choose Liferay MVC, the standard framework for creating portlets:

The IDE is now creating an empty Web-Project, complete with /docroot/WEB-INF and so forth.

Time to include the portlet. Start the "New Liferay portlet"-wizard available in the "New"-menu. Choose a meaningful name and let it subclass Liferay's "MVCPortlet". This will save you a lot of tedious work later on:

In the next dialog, you decide which modes (only view for the moment) your portlet will implement and whether JSPs and I18N-files are created. Click "Create resource bundle file":

The next dialog deals which CSS and JavaScript resources (leave untouched) and categorization. I chose to display hte portlet in the "Collaboration" section as well as in the Control Panel:

The last dialog page can be skipped. Finish the wizard. Your new project becomes populated with some default files now. Feel free to browse them:

Language.properties will hold the I18N messages.
Task.java is the Portlet itself - more on it below.
main.css - will hold your style classes - its empty now.
view.jsp of course is the user interface.
main.js may be included to use javascript code.
WEB-INF holds a lot of configuration code - lets take a look at it later.
build.xml is the ant build script.

Ok! Lets deploy this portlet. Use the context menu on the project to bring up the liferay build menu:

Hit "all" or "deploy" will fire up the Plugin SDK an deploy the project into your liferay. As usual, tail -f tomcat/logs/catalina.out is your friend for controlling deployment. If all runs well - and it should - you see the new portlet in the add menu of your page (don't be confused - I have deployed Social Office also and thus there is a Tasks portlet. But ours was called Task. Also, in a german installation like mine "collaboration" is called "Zusammenarbeit" ;-)

The output "This is the Task portlet in View mode" is generated from /docroot/html/task/view.jsp:

<%@ taglib uri="http://java.sun.com/portlet_2_0" prefix="portlet" %>

<portlet:defineObjects />

This is the <b>Task</b> portlet in View mode.

This JSP is in turn speified as an init-parameter to the portlet in /docroot/WEB-INF/portlet.xml. Liferays MVCPortlet the uses this init-parameter to render to view mode jsp.

So congrats! We just deployed a portlet successfully!

Integrate Jersey RESTful with portlet project

2013-05-04T04:48:55Z

Hello All Friends...

Recently I have succssfully integrate Jersey Framework with my existing portlet project.

It is very easy and very useful..

For this, you have to follow following steps..

1) Add following dependency if you are using maven, otherwise add this jars to your classpat.

<groupId>com.sun.jersey</groupId>

<artifactId>jersey-server</artifactId>

</dependency>

<groupId>com.sun.jersey</groupId>

<artifactId>jersey-json</artifactId>

</dependency>

2) Edit in web.xml

<servlet-name>jersey-serlvet</servlet-name>

<servlet-class>com.sun.jersey.config.property.packages</servlet-class>

<init-param>

<param-name>com.sun.jersey.config.property.packages</param-name>

<param-value>com.hrms.admin.jersey.service</param-value>

</init-param>

<init-param>

<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>

<param-value>true</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>jersey-serlvet</servlet-name>

<url-pattern>/rest/*</url-pattern>

</servlet-mapping>

3) Look out Web service class.

Example..

@Path("/mymessage")

public class MyWebServiceClass

{

@GET

@Path("hello")

@Produces(MediaType.APPLICATION_JSON)

public Message myMethod()

{

MyMessage msg = new MyMessage();

msg.setName("Good Day!!!");

msg.setTitle("Welcome");

return msg;

}

-> here, we can define @Path at two level. 1) class level 2) path level.

-> so Here, i provide both ultimately url become... <...>/mymessage/hello

-> @Produces(MediaType.APPLICATION_JSON) defines that this method returns data in JSON format.

This is web service class where we implelent service.

4) Now we have to create client which call this service.

<groupId>com.sun.jersey</groupId>

<artifactId>jersey-client</artifactId>

</dependency>

I am using GSON. So..

<groupId>com.google.code.gson</groupId>

</dependency>

5) Client program

public class MyClient {

Logger log = Logger.getLogger(MyClient.class);

public String createClient(String url) {

try {

Client client = Client.create();

String baseURL = "http://localhost:8080/admin-0.0.1/rest";

WebResource webResource = client.resource(baseURL + url);

ClientResponse clientResponse = webResource.accept("application/json").get(ClientResponse.class);

if (clientResponse.getStatus() != 200) {

throw new RuntimeException("Failed...... HTTP Error Code :"

+ clientResponse.getStatus());

}

String output = clientResponse.getEntity(String.class);

System.out.println("Output from Server :");

System.out.println(output);

return output;

} catch (Exception e) {

e.getMessage();

return "ERROR";

}

--> Here... http://localhost:8080/admin-0.0.1/rest define as a Base URL. and at the time of calling any service we have to pass remaining parameter in it.

like..

MyClient client = new MyClient();

String result = client.createClient("/mymessage/hello");

So... It will return MyMessage object in JSON format.

Thanksssssssssssssssssssss