Liferay.com

Integrating Alfresco Repository to Liferay Documents and Media Portlet

2013-05-22T17:11:06Z

We can integrate Alfresco Repository with Liferay Documents and Media Portlet by using CMIS feature. Liferay 6.1 provides with the very simple configuration management for cmis settings.

Let’s follow few steps for configuration of CMIS in Document and Media portlet.

NOTE: If you are not using any SSO for both servers, Make sure you create a same user admin/admin in Liferay. Doing this you will have common user in both environment.

1. Login with the admin user, go to Control Panel and check your site content setting, which site it is referring, make sure it refers to your desirer site. And Click Documents and Media Portlet.

2. Now In Documents and Media Portlet go to add button and click repository, New Repository page will open. Fill the bellow settings.

Name: Alfresco Repository

Description: Alfresco Repository

Repository Type: CMIS Repository (AtomPub)

Repository URL: http://localhost:8080/alfresco/service/cmis

And Save it

After all done, you will be seeing the Alfresco Repository (Company Home) inside Documents and Media Portlet.

Now you can place the Documents and Media Portlet any page where you want the users should access.

Other related Blog : Integration with alfresco 4.x and Liferay 6.1

Integration with alfresco 4.x and Liferay 6.1

2013-05-22T17:13:34Z

We will be seeing here the proper way of intregrating Alfresco 4.x with Liferay 6.1 version. So, here I have given details process, How you can achive the integration.

Let’s do some few steps for integrating Alfresco 4.x with Liferay 6.1.

As we can have assumption that you might have installed the Alfresco and Liferay Tomcat bundles into separate directories. Let’s say as <ALFRESCO_HOME> and<LIFERAY_HOME>.

NOTE: If you are not using any SSO for both servers, Make sure you create a same user admin/admin in Liferay. Doing this you will have common user in both environment.

1. You need to have different ports number for Alfresco and Liferay running on to resolve port conflicts, Say Alfresco is running on 8080 and Liferay on 5050. So, you can configure the Liferay port in Tomcat server by editing <LIFERAY_HOME>/<tomcat>/conf/server.xml

...

<Server port="5005" shutdown="SHUTDOWN">
...
<Connector port="5050" protocol="HTTP/1.1"

        connectionTimeout="20000"

         redirectPort="5443" URIEncoding="UTF-8" />
...

<Connector port="5009" protocol="AJP/1.3" redirectPort="5443" URIEncoding="UTF-8" />

...

2. Now, You need to change the Share Loader by editing <LIFERAY_HOME>/<tomcat>/conf/catalina.properties and locate the "shared.loader" entry and replace it with this:

shared.loader=${catalina.base}/shared/classes,${catalina.base}/shared/lib/*.jar

These will load the alfresco custom and extension configuration with respect to the XML and other properties files. And also if you have the custom jar files.

3. You have to enable the external authenticate services of alfresco, we can do that by editing <ALFRESCO_HOME>/tomcat/shared/classes/alfresco-global.properties and add to file.

Add the following line at the end of the file

authentication.chain=alfrescoNtlm1:alfrescoNtlm,external1:external

external.authentication.proxyUserName=

Note: Leave the value of proxyUserName blank

4. You can deploy the share.war file in Liferay deploy folder.

Copy <ALFRESCO_HOME>/tomcat/webapps/share.war to <LIFERAY_HOME>/deploy

5. As you set the share loader in catalina.properties inside Liferay tomcat. You need to copy the Share Loader from Alfresco to Liferay. Let copy the entire folder

<ALFRESCO_HOME>/tomcat/shared directory to <LIFERAY_HOME>/<tomcat>/

Note: Alfresco requirement is to copy the shared/classes/alfresco/web-extension/ directory where all the custom xml configuration files are placed, to have a common bridge between Liferay and Alfresco.

So, it’s convenient task to copy entire folder.

6. Finally you need to configure SSO, what we called as Bridge.

Create a file <LIFERAY_HOME>/<tomcat>hared/classes/alfresco/web-extension/share-config-custom.xml, and copy the below code to enable remote authenticator. shared/classes/alfresco/web-extension/share-config-custom.xml

<alfresco-config>

<config evaluator="string-compare" condition="Remote">

<remote>

<endpoint>

<id>alfresco-noauth</id>

<name>Alfresco - unauthenticated access</name>

<description>Access to Alfresco Repository WebScripts that do not require authentication</description>

<connector-id>alfresco</connector-id>

<endpoint-url>http://localhost:8080/alfresco/s</endpoint-url>

<identity>none</identity>

</endpoint>

<id>alfresco-feed</id>

<name>Alfresco Feed</name>

<description>Alfresco Feed - supports basic HTTP authentication</description>

<connector-id>http</connector-id>

<endpoint-url>http://localhost:8080/alfresco/s</endpoint-url>

<basic-auth>true</basic-auth>

<identity>user</identity>

</endpoint>

<id>alfrescoCookie</id>

<name>Alfresco Connector</name>

<description>Connects to an Alfresco instance using cookie-based authentication</description>

<class>org.springframework.extensions.webscripts.connector.AlfrescoConnector</class>

</connector>

<id>alfresco</id>

<name>Alfresco - user access</name>

<description>Access to Alfresco Repository WebScripts that require user authentication</description>

<connector-id>alfrescoCookie</connector-id>

<endpoint-url>http://localhost:8080/alfresco/wcs</endpoint-url>

<identity>user</identity>

<external-auth>true</external-auth>

</endpoint>

</remote>

</config>

</alfresco-config>

NOTE: If you're running Alfresco's Tomcat server on a different host or port, please change the corresponding endpoint.

7. Last but not the least, you can startup both the servers Liferay and Alfresco

8. Now you can able to see the 3 portlets under Alfresco category in Dock bar menu | Add portlet in Liferay. Try to add the Share Document library portlet in Liferay Page.

Reference Site : http://wiki.alfresco.com/wiki/Portlets

Radio Liferay Episode 26: Ville Ingman (Vaadin)

2013-05-21T12:08:54Z

At this year's Jax I met Ville Ingmann, "Your Business Buddy" at Vaadin (the business card says "VP of German Operations"). With some inadvertent background noise (sorry) we talk about the history of Vaadin in Liferay, the meaning of the name, which also explains the logo, and the integration of Vaadin in Liferay (Vaadin is technology partner of Liferay, the library comes bundled with your Liferay installation and is available in the "New Project" wizard of Liferay IDE).

We talk about

Turku, Finland
When to use Vaadin vs. the other available technologies
How Vaadin differs from GWT (hint: GWT is used for front-end UI rendering, but generally processes server-side
A performance comparison and benchmarks that have been executed with Vaadin - and how it will change further with Server-Push in Vaadin 7.1
The Devoxx-Talk "World Wide Wait" included Vaadin in its comparison as the fastest server-side solution.
Vaadin recently released version 7 which is a huge step forward, unfortunately not 100% backward compatible with the version that ships with Liferay (6.x) but 6.x continues to be maintained. The backward compatibility for version 7 depends on the technology used by the applications, for regular applications it should be ok though.
Arcusys, a Liferay Partner in Finland, picked up the development for the Vaadin controlpanel
Vaadin is licensed under the Apache 2.0 license, despite the main product being available for free (like Liferay), Vaadin has built quite a good business around the product. The company is sized at ~60 employees, offering services, consulting, training and some extra components that we briefly talk about.
Eating your own dogfood vs. drinking your own champagne.
Vaadin supports SASS and integrates easily with external javascript
Widgets
The Vaadin repository is hosted on github - go ahead, fork and collaborate

Follow Ville, RadioLiferay or me on twitter

Thanks a lot to Auphonic for improving the sound quality drastically - this is the first episode I had processed by them and it's been a really good experience - especially given the recording cirumstances.

You'll find this episode - and make sure that you don't miss any of the future episodes - by subscribing to http://feeds.feedburner.com/RadioLiferay. You can also subscribe on itunes.: Just search for "Radio Liferay" or just "Liferay" in the podcast directory.

Behavioral Analytics: Who moved my coffee cup?

2013-05-20T17:16:08Z

I would like to bring attention to a hot topic around the Liferay offices lately, and one that you should definitely consider for the websites that you are working on: behavioral analytics. I'd like to explain this with a small example that you might be able to relate to:

Let's all start with a lovely place that I call Cup Island:

I took this photo in the Liferay LA office last Friday morning. This is one of the small tables downstairs near our lounge/reading area. You can see this table immediately when you enter our North entrance. It is usually dotted with different mugs and glasses throughout the day. This is Cup Island.

As I was taking this photo, Shannon from our Marketing department said to me, "why are people leaving their used cups around? Someone should probably put them away."

And to someone who notices Cup Island for the first time, this is the natural response. In fact, I have left a cup here before, and had it disappear into the hands of the facilities cleaning team (which they kindly gave back to me after panicking over its disappearance).

But I explained to Shannon the purpose of Cup Island. "Don't worry, these cups aren't left here to die," (I'm paraphrasing a little bit), "this is a temporarily holding place until their owners come back for them."

You see, the reason that Shannon didn't realize this is because she is a woman. Wait - I don't mean this in a bad way - what I mean is, Cup Island only exists near the men's restroom.

So that is the purpose of Cup Island - a convenient place to put cups when using the restroom. To other people, this might only be Decorative Plant Island. It really depends on why you use the table.

So why use it to hold cups? Let's understand the audience. This restroom is near the kitchen, the only kitchen at our office, and the only place to get drinks from. And more than half of the employees at Liferay don't work on this side of the building, but instead work either upstairs or in another wing.

So when an engineer who sits upstairs needs to use the restroom, they are probably thinking, "I should also bring my cup with me so I can visit the kitchen in one trip." And right before they go into the restroom, they see this table, leave their cup, and pick it up when they exit the restroom.

So how can we improve this situation? Well, it depends on what we want to achieve. We cannot ask employees to stop drinking water, or to stop using the restroom (some of you may be thinking that asking for one may lead to the other anyway, but after a while our employees would cease to exist).

If our goal is to stop people from leaving cups on the island, we could try providing larger cups, so refills might not be as necessary. Or we could build a kitcken that is closer to the employees (or move employees closer to the kitchen). Or we could simply just remove the table. Employees may leave their cups further away, or just take two trips from their desks, which might cost them convenience and time.

If our goal is to make Cup Island easier to use, we could remove the huge plant and make more cup space. Or we could turn it into a Super Cup Island, with more capacity and a handy labeling system so people never get their cups confused.

Whatever we choose, these needs still exist: (1) everyone needs to drink water, and (2) everyone needs to use the restroom. But behavioral analytics tells us that the kitchen or bathroom may be too far away.

Learning to improve websites based on user behavior

For the redesign of liferay.com, we are trying to study where people are leaving their "cups" on our website. We know that there are community members, enterprise customers, trainees, partners, event goers, internal staff, liferay newbies, and evaluators - each of us enjoying the site, or fighting with it. We are studying how people use the site, where they are clicking, and trying to figure out why. If we can really understand our users, only then can we improve their experience. We're playing around with Crazy Egg, Google Analytics, and some other marketing tools. We're suggesting to the core product team that it would be killer to bake web analytics directly into Liferay Portal. Hey, it would make my job a lot easier.

Admittedly, this is not a new subject at all. Admittedly, Liferay has lots of room for improvement (the webteam would know, as we are working on our instance of 6.1 day in and day out). For Portal 6.2, we've started doing in-house user testing - I know this because I was just tested last week! And we've begun to make incremental improvements to the website. I already have examples of some small victories we've had lately, but I will save that for the next post.

We do have some lovely UI and content changes on the way. Just to prove how serious I am: the code is already committed and was approved by Brian Chan himself (well, he approves everyone's code). Stay tuned, same web time, same web channel.

- Ron

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.com

Integrating Alfresco Repository to Liferay Documents and Media Portlet

Other related Blog : Integration with alfresco 4.x and Liferay 6.1

Integration with alfresco 4.x and Liferay 6.1

Other related link : Integrating Alfresco Repository to Liferay Documents and Media Portlet

Radio Liferay Episode 26: Ville Ingman (Vaadin)

Behavioral Analytics: Who moved my coffee cup?

Create an upgrade process in 6.2

Introduction

Step 1 - Modify an entity

Step 2 - Change .ftl if needed

Step 3 - Create some UpgradeProcess classes

Step 4 - Create the [XXX]Table class

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

Step 6 - Regenerate all the service and TEST!

VERY IMPORTANT!!

Managing Liferay through the Gogo shell

Basic project structure

Writing Gogo shell custom commands

Consuming Liferay services

Building and running the bundle

Mavenize Liferay Plugins SDK - Using Maven

Overview

Technical Platform

Setup and Installation

Implementation

HOW-TO Clear Liferay Cache

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

Liferay Portal 6.1-CE on JBoss AS71

How-To implement Pagination in Liferay

Use case

Implementation

Using Liferay Portal 6.1 Published in Print

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

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

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

Astuce n°1 : Mettez du HTML dans vos sorties

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

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

Astuce n°4 : Implémentez un mode preview

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

5 tips to improve usage of the Liferay script console

Tip #1: Use the HTML in your outputs

Tip #2: Show up exceptions on user interface

Tip #3: Exploit the predefined variables

Tip #4: Implement a preview mode

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

Using custom java classes in a JSP hook

Issue

Cause

Solution

Liferay Sync Mobile 2.0

Liferay, WebSockets, and Node: Good Times!

Social Driver

Demo Part 1

Demo Part 2

Demo Part 3

Lessons learned

Creating A Big Media Site in Liferay

Download and Test

Select Category And add Post in message board using velocity template