Liferay Portal 5.2 Systems Development Table of Contents

Back to BOOK PAGE

Preface
Chapter 1: Introducing Liferay Portal Architecture and Framework
Chapter 2: Working with JSR-286 Portlets
Chapter 3: ServiceBuilder and Development Environments
Chapter 4: Experiencing Struts Portlets
Chapter 5: Managing Pages
Chapter 6: Customizing the WYSIWYG Editor
Chapter 7: Customizing CMS and WCM
Chapter 8: Building a Personalized Community
Chapter 9: Developing Layout Templates and Themes
Chapter 10: Building My Social Office
Chapter 11: Staging and Publishing
Chapter 12: Using Common API
Index

Preface

Chapter 1: Introducing Liferay Portal Architecture and Framework
- What's Liferay portal?
  - Liferay portal
  - Liferay CMS and WCM
  - Liferay collaboration and social networking software
- Why Liferay portal?
  - A rich, friendly, intuitive, and collaborative end user experience
  - A single point of access to all information
  - High adaptability to the demands of fast-changing market
  - Highest values
- Architecture and framework
  - Service oriented architecture: SOA
  - Enterprise service bus: ESB
- Portal development strategies
  - Extension environment
  - Plugins SDK environment
  - Development strategies
- Summary

Chapter 2: Working with JSR-286 Portlets
- Experiencing Liferay portal and portlets
  - What is a portal?
  - What is a portlet?
  - What is a portlet container?
  - Why JSR-286 portlets?
- Using JSR-286 portlets
  - Understanding portlet life cycle
  - Utilizing portlet modes
  - Employing window states
  - What's the difference between a portlet and a servlet?
    - Use cookies, document head section elements, and HTTP headers
- Employing portlet configuration, context, request, response, and preferences
  - Using portlet configuration
  - Employing portlet context
  - Using portlet request
  - Employing portlet response
  - Working with portlet preference
- Extending JSR-286 portlets
  - Using portlet filters
  - Using portlet-managed modes
  - Utilizing container runtime options
- Serving resources
  - Using Resource URL
  - Using caching levels of resources
  - Serving the AJAX data directly from the portlet
  - Utilizing other features
    - Using JAVA 5 features
    - Employing caching features
    - Sharing runtime ID
    - Using taglib
- Coordinating portlets
  - Sharing data via the session
    - Using PortletSession
    - Using PortletContext
    - Using page parameters
  - Using portlet events
    - Sending events
    - Receiving events
  - Employing public render parameters
- Summary

Chapter 3: ServiceBuilder and Development Environments
- Setting up Ext
  - Required tools
    - JDK
    - Ant
  - Databases
    - MySQL
  - Application servers
    - Tomcat
  - IDE
    - Eclipse IDE
    - Workspace
    - Subclipse
    - Tomcat plugins
  - Portal source code
- Building Ext
  - Getting portal source code
    - Source structures and Ant targets
  - Updating Tomcat to support Ext development
  - Customizing properties
  - Building via Ant
  - Navigating Ext structures
- Deploying Ext
  - Configuring database
  - Using Ant deploy
    - View portal structures in Tomcat
    - Fast-deploy in Ext
- Using ServiceBuilder in Ext
  - Viewing portlet development structures
  - Building services
    - Create service XML
    - Build services
    - What's happening?
  - Navigating portlet specification
- Setting up Plugins SDK
  - Building Plugins SDK project
  - Deploying plugins
  - Fast development of plugins with Tomcat
- Using development environments efficiently
  - How does Ext work?
  - When do we use Ext?
- Summary

Chapter 4: Experiencing Struts Portlets
- Developing a JSP portlet
  - Defining the JSP portlet
  - Changing the title and category
  - Using JSP portlet efficiently
    - Fast deploy
    - Employing JSP portlet
- Constructing a basic Struts portlet
  - Defining a Struts portlet
  - Specifying the page flow and page layout
  - Creating JSP pages
  - Changing the title and category
- Building an advanced Struts portlet
  - Adding an action
    - Creating an action
    - Defining the action
    - Adding a form in JSP page
    - Creating success and error pages
  - Interacting with the database
    - Creating a database structure
    - Creating methods to add and retrieve records
    - Updating existing files
    - Retrieving records from the database
  - Redirecting
    - Updating the action
    - Updating action paths
    - Updating existing JSP files
  - Adding more actions
    - Creating methods to edit and delete records
    - Updating the action
    - Creating actions menu JSP file
    - Updating existing JSP files
  - Setting up permissions
    - Setting up permissions in the backend
    - Setting up permissions in frontend
    - Deploying
- Using Struts efficiently
  - Why use Struts?
  - Why use tiles?
  - When do we use Struts?

Chapter 5: Managing Pages
- Extending Communities portlet
  - Building Ext Communities portlet
    - Constructing the portlet
    - Setting up actions
    - Setting up page flow and page layout
    - Preparing JSP files
  - Setting up the Ext Communities portlet in the backend
    - Creating database structure
    - Creating methods to update, delete, and retrieve
    - Updating the action classes
  - Setting up the Ext Communities portlet in the frontend
    - Updating and deleting Community customized columns
    - Retrieving community-customized columns
- Customizing the Manage Pages portlet
  - Building a standalone layout management portlet
    - Constructing the portlet
    - Setting up the action
    - Setting up page flow and page layout
    - Preparing JSP files
  - Setting up the Ext Layout Management portlet in the backend
    - Creating a database structure
    - Creating methods to update, delete, and retrieve
    - Updating the action class
  - Setting up the layout management portlet in the frontend
- Customizing page management with more features
  - Adding localized feature
    - Extending model for locale
    - Customizing language properties
    - Displaying multiple languages
  - Employing tabs
  - Applying layout templates dynamically
    - Setting up pages, layout templates, and portlets mappings
    - Adding layout templates
    - Displaying layout templates by sections
  - Tracking pages
- Using communities and layout page efficiently
  - Employing group, community, and permissions
  - Using communities, layout pages, comments, and ratings
  - Extending the community and layout pages
- Summary

Chapter 6: Customizing the WYSIWYG Editor
- Configuring the WYSIWYG editor
  - Extending the Ant target for fast deployment
  - Upgrading the WYSIWYG editor: FCKeditor
  - Setting up the FCKeditor
    - Adding customized icons
    - Employing default configuration
- Adding templates and styles in FCKeditor
  - Constructing styles and formats
    - Preparing CSS styles in themes
    - Employing customized CSS styles from themes
    - Customizing styles
  - Building templates
- Inserting images and links from different services
  - Configuring a File Browser Connector with Liferay portal services
    - Configuring the services for images, documents, and pages
    - Browsing images and links
    - Preparing Liferay portal services
  - Customizing the File Browser Connector with RESTful services
    - Adding advanced search view features
    - Adding advanced search functions to links and images
    - Preparing RESTful services
- Inserting content-rich flashes into Web Content
  - Querying flashes
  - Adding single flash SWF, videos, and slideshows to journal articles
    - Adding advanced search views
    - Adding advanced search functions
    - Adding flash objects
  - Adding video queue and video list as part of journal articles
    - Putting a video list into journal articles
    - Setting up video queue in journal articles
  - Adding games and playlists as part of journal articles
    - Playing games beside text message
    - Employing playlist as visualization of text information
  - Preparing RESTful services
- Using the WYSIWYG editor FCKeditor efficiently
  - Extending the file browser connector
  - Employing the WYSIWYG editor in portlets
    - Employing the WYSIWYG editor in the Web Content portlet
    - Using Liferay display tag
    - Adding the WYSIWYG editor in a custom portlet
  - When do we use the WSYIWYG editor?
- Summary

Chapter 7: Customizing CMS and WCM
- Managing Terms of Use dynamically
  - Customizing static Terms of Use
  - Building dynamic Terms of Use
- Constructing featured content
  - Customizing the Web Content Display portlet
    - Creating the Ext Web Content Display portlet
    - Building a view action
  - Setting up structure and template
    - Building a structure
    - Preparing the icon images
    - Building a template
  - Building featured content articles
    - Preparing images
    - Building an article with images and text
- Customizing the Web Content List portlet
  - Constructing the Ext Web Content List portlet
  - Building a view action
  - Setting up the view page
    - Adding custom article types
    - Consuming custom article types
- Customizing the Asset Publisher portlet
  - Adding a large-size image and a medium-size image in Web Content
  - Building the Ext Asset Publisher portlet
  - Extending view with tags
    - Configuring tags
    - Setting up default tags
    - Updating views
- Building dynamic articles with recently added content and related content
  - Displaying journal articles through asset ID
  - Showing touts with article ID
    - Adding Velocity services
    - Building touts structure and template
    - Building article touts
  - Listing recently added content
  - Exhibiting related content
- Building dynamic articles with polls
  - Adding template node poll
  - Updating the Web Content portlet with template node poll
  - Associating journal articles with polls
- Extending CMS and WCM
  - Employing articles, structures, and templates
    - Using journal template—Velocity templates
  - Enjoying the Web Content search portlet
  - Tagging content
  - Extending Image Gallery and Document Library
  - Adding Velocity templates in Asset Publisher
- Summary

Chapter 8: Building a Personalized Community
- Sharing content with friends
  - Building print preview as article template
  - Sharing applications on any web site by widget
  - Sending emails with sharing links to friends
    - Building the Share portlet
    - Setting up view action and email
    - Setting up the view page with jQuery
    - Preparing jQuery service
    - Building the article template
- Setting up the most popular journal articles
  - Adding a view counter in the Web Content Display portlet
  - Setting up VM service
  - Building article template for the most popular journal articles
    - Setting up the default article type
    - Setting up the article template
    - Putting all article templates together
  - Having a handle on view counter for assets
    - Using journal article tokens
    - Get view count on Wiki articles
    - Getting views count on blog entries
    - Getting views on Message Boards threads
    - Setting up view counter on the Image Gallery images
    - Setting up view counter on Document Library documents
    - Getting visits on bookmark entries
- Personalizing user comments
  - Creating user comments model
  - Building the Ext Comment portlet
    - Adding permissions based on user groups
    - Updating the UI tag
    - Setting up email notification
- Customizing My Account
  - Customizing login view
    - Locating the portlet My Account
    - Overriding login view
  - Creating a customized account on the fly
- Building personal community—My Street
  - Customizing user model
  - Building the portlet My Street
    - Adding Struts view page
    - Sharing the My Street theme
    - Adding videos, games, and playlists into My Street
- Using personal community efficiently
  - Extending user account and user preferences
  - Setting My Community
  - Using Control Panel to manage My Account
  - Using dynamic query API
  - Using pop ups
    - Applying Floating DIV pop up
    - Employing window pop up
- Summary

Chapter 9: Developing Layout Templates and Themes
- Building layout templates in Ext
  - Constructing custom layout templates
    - Experiencing default layout templates
    - Adding customized layout templates
  - Registering layout templates
- Developing layout templates in Plugins SDK
  - Building layout templates
  - Creating layout templates
- Building themes in Plugins SDK
  - Creating a customized theme
    - Setting up the theme project
    - Building differences of themes
  - What's happening after deploying themes?
    - Putting HTML to use
    - Experiencing CSS and images
    - Using jQuery JavaScript library
    - Employ theme settings
    - Adding color schemes
    - Adhering to WAP standard
    - Adding runtime portlets to a theme
  - Using theme, CSS, and JavaScript
    - Making use of themes
    - Applying CSS
    - Employing JavaScript
    - Experiencing the developing and debugging tools
- Customizing Velocity templates in themes
  - Using default Velocity templates
    - Experiencing default Velocity variables
    - Customizing Velocity variables
  - Adding customized Velocity templates
    - Using Velocity templates in drop-down menu
    - Using Velocity templates in journal article-based navigation
  - Setting up customized themes and layout templates as default
- Using Plugins SDK more efficiently
  - How does it work?
  - When to use Plugins SDK?
- Summary

Chapter 10: Building My Social Office
- Experiencing the Control Panel
  - What's Control Panel?
  - How does it work?
    - Using the Control Panel theme
    - Employing Control Panel settings
    - Configuring portlets for Control Panel
  - How to customize it?
    - Changing theme
    - Updating both edit page and view page
    - Configuring customized portlets
- Building Inter-Portlet Communication
  - Creating IPC portlet project
  - Constructing IPC portlets
    - Defining portlets
    - Defining events
    - Registering portlets
  - Specifying portlet process actions
  - Specifying portlet views
- Developing Social Office theme
  - Setting up the theme project
  - Constructing differences of the so-theme
- Adding mail and chat portlets
  - Setting up the mail portlet
  - Setting up the chat portlet
    - Deploying the chat portlet
    - What's happening behind?
- Building Social Office with portlets
  - Rearing the Social Office portlets project
  - Assembling social portlets
  - Raising JavaScript functions and friendly URL
  - Erecting social views
  - What's happening?
    - Experiencing social models
    - Experiencing social services
    - Adding social activity tracking
- Hooking properties and JSP files into Social Office
  - Building hooks
    - Applying portal event handlers
    - Putting model listeners to use
  - Erecting portal properties
  - Employing JSP hooks
- Using hooks more efficiently
  - General usage
    - WOL—World of Liferay
  - Special usage
    - Document library hooks
    - Auto-login hooks
    - Mail hooks
- Summary

Chapter 11: Staging and Publishing
- Building dynamic navigation and site map
  - Constructing custom navigation and street navigation
    - Build portlets' views
  - Establishing custom site map
    - Constructing the street site map portlet
    - Building up portlet view
- Customizing event handlers and model listeners
  - Handling events
    - Configuring global startup and shutdown actions
    - Creating a custom cookie on login
  - Building custom model listeners
    - Creating custom model listener
    - What's happening?
- Undergoing local staging and publishing
  - Activating staging
  - What's happening?
    - How does it work?
  - Staging and publishing locally
    - Copying from live
    - Publishing to live
- Employing staging workflow and other workflows
  - Activating staging workflow
    - Creating a proposal
    - What's happening?
  - Customizing staging workflow
    - Extending model
    - Building a standalone workflow portlet
    - Employing the journal article workflow
    - Play with the jBPM workflow
    - Using Intalio | BPMS
- Scheduling web content
  - Scheduling pages
    - Scheduling the web content
  - What's happening?
    - Setting a scheduler engine
    - Scheduling layouts
    - Configuring scheduler class
- Experiencing remote staging and publishing
  - What's remote staging and publishing?
  - How does it work?
    - Importing and exporting
    - Using tunnel web
    - Setting up tunnel web
  - Using LAR to export and import
    - Defining portlet-data-handler
    - Configuring a portlet with portlet-data-handler
    - Using portlet-data-handler
    - Using SCORM
- Summary

Chapter 12: Using Common API
- Adding custom attributes
  - Building dynamic table with Velocity Expando template
    - Creating a journal structure
    - Creating a journal template
    - Building Book Title List
  - What's happening?
    - The Expando Velocity template variables
    - Models and services
    - Extending custom attributes
  - Enhancing users and organizations
    - What's happening?
    - Sharing the Expando portlet
- Building OpenSearch
  - What's happening?
  - Adding the OpenSearch capability on custom portlets
  - Adding search capabilities in portlets
  - Using Solr for enterprise search
- Overriding the Spring services
  - Overriding method validation
  - Changing model name via ServiceBuilder
  - What's happening?
  - Consuming Liferay services in portlets
    - How does it work?
  - Customizing friendly URL mappings
    - What's happening?
- Constructing web services
  - Building custom web services
  - Consuming web services in portlets
    - How does it work?
  - What's happening?
- Enjoying best practices
  - Using JavaScript Portlet URL
  - Customizing user and organization administration
    - Creating a new section
    - Customizing fields of form section
    - Customizing columns of the list
  - Speeding up the portal
  - Sharing UI Taglibs in portlets
    - How does it work?
  - Consuming WSRP
    - How do we get the WSRP portlets?
    - How does it work?
  - Integrating with SharePoint
  - Integrating with Terracota DSO
- Summary