Here's a quick presentation and demo (video) of what's new with the Multi-Channel Feature Pack 2 for Web Experience Factory 8.0
IBM Web Experience Factory Blog
AdamG 110000672C Tags:  websphere-portal portlet digital experience web factory mobile wef mobile-development mobilefirst web-experience-factory 5,196 Views
Jonathan Booth 060000XRMC 4,991 Views
I'm very happy to announce the release of the Multichannel Feature Pack for Web Experience Factory 8.0. This feature pack builds on the existing mobile and multichannel support of Web Experience Factory (WEF) and adds two new key features:
This feature pack release coincides with the release of an update for WebSphere Portal 8.0 which includes a new responsive mobile theme and a new version of Content Template Catalog (CTC4) for use with Web Content Manager. All these releases come just in time for the IBM Connect 2013 conference in Orlando next week, so for anyone attending that conference you'll be seeing lots of demos of all of this. And you can stop by the "Meet The Developers" lab to talk to me and other developers.
To go along with the feature pack we've published some samples and articles so that you can easily get going with the new features. For using Worklight and the new camera builder there are several steps involved in configuring everything, involving Worklight, a mobile device SDK such as Android or iOS, and WEF; to help you through this, there's a detailed article linked below showing the steps involved. And for the new data layouts and styles, there's a set of samples you can download and run.
Here are key links related to the feature pack. I hope you download it and try it out!
ruthspeaks 2700006S3X Tags:  development wef portal davalen technical code java adam-kewley 4,934 Views
Adam Kewley walks us through how to implement your own portlet page tracker which will not only be able to tell when page changed, but also track whether or not a portlet has registered this page change.
by Adam Kewley
Once in a while during product development we run into scenarios where we need to extend the functionality of IBM Web Experience Factory (WEF) & IBM WebSphere Portal above and beyond what’s supported out of the box. The product goes a long way to make things easier to develop with but it’s impossible (and impractical) to expect it to cover every scenario. Fortunately we can usually rely on custom API and sample workarounds to get us through. This article will discuss one such scenario: Tracking Portal Page states with WEF.
In general a portlet isn’t supposed to know (or care) which page it is placed on. It also shouldn’t worry which page the user was on previously. Due to this construct, it’s not always easy to tell when a portlet is being reloaded or when it’s processing a request from a form action.
In some instances however, a project may require a portlet to refresh itself when a user navigates back to that page. A client may wish that an input form resets itself despite what the JSR specification may state. IBM provides a few API classes that expose the page structure. We’ve used them in the past to get the unique page name as well as generate a portal navigation menu inside of a portlet. In this segment we will discuss how to implement your own portlet page tracker which will not only be able to tell when page changed, but also track whether or not a portlet has registered this page change.
The WebSphere Portal API provides the ModelUtil and NavigationNode classes to gain access to the page models within the portal. Using the following sample code, we can obtain the unique name of the current portal page:
AdamG 110000672C Tags:  websphere-portlet-factory portal wef wpf web-experience-factory portlet 1 Comment 4,910 Views
Check this out new tool for graphing models available from a business partner
Recently we've been asked by multiple customers how they can dynamically control the generation of forms and views based on some data that is determined at runtime.
For example, here are a couple of slightly different scenarios we've been asked about:
Developers familiar with Web Experience Factory have seen that application UI is typically built at design time using a schema-driven approach. The schema is used to generate a set of page fields, and the Data Field Settings builder or Rich Data Definition builder can then control all the field behavior. For the scenarios above, in order to change the inputs that control this code generation at runtime, you need to use the profiling feature of Web Experience Factory. For portlets, you can tie profiling to portlet preferences which are configured at runtime in the Edit, Edit Shared Settings, and Configure modes. But what may not be obvious is how you can get profile data dynamically at runtime from some other data source, for example from a database or web service.
The answer is with a Profile Values Handler. When you edit a Profile Set, one of the tabbed screens is for "Select Handler." Here you can specify a "Value Setter" Java class that will be called to determine all the profile values for a profile set. Whenever a model is first executed in a session, the Factory engine will call your handler to get the profile values before the model is regenerated.
There's one more useful feature available when implementing this. The Profile Values Handler is a Java class, but suppose you'd like to use some of the Web Experience Factory connectors to retrieve your profile data. For this, you can actually call a Method or Action List in any model from your handler. To do this, use the ModelInstanceCreator object that's passed into your handler to obtain a WebAppAccess object for any model (but not the model that's profiled). Then you can call any method in the model. The method you call should return the profile data, typically String or IXml. It's that simple! In the model you're calling from your handler, you can use any data access builders such as the SQL builders or the REST or Web service builders.
With this mechanism in place, you can use profiling however you want in your models. For scenario #1 above, you would probably have a single profile entry containing a chunk of XML data, and you would use the data to drive an XML input of Rich Data Definition or Data Field Settings. Scenario #2 is more complex, since you have to profile the builder inputs that control the schema generation. In other scenarios you might profile a number of individual String values, using the profile entry name to locate values in your database for example.
We don't yet have a complete sample of these techniques posted on the wiki, but there is a sample showing a profile values handler that gets profile values from a properties file. See below for a link to this sample, which also shows how you can select a profile name from a properties file. This sample could be easily modified to retrieve profile values by calling an action in another model using ModelInstanceCreator.
Hopefully this gives a high-level picture of how you can leverage the flexibility and extensibility of the Web Experience Factory engine in order to implement some very dynamic code generation scenarios. From the very first release of the product, we've tried to make sure that the code generation framework is very extensible and flexible so that you can adapt it to all sorts of needs.
Exceptional Shopping Experience - Using Web Experience Factory to integrate WebSphere Commerce and WebSphere Portal
Check this cool article out by Joseph George - Exceptional Digital Shopping Experience (xDSx) - Enabling Omni-Channel shopping Experience with WebSphere Commerce and WebSphere Portal - click herePresentation on this @ ASEAN Tech Talk http://www.slideshare.net/josephgeorgek/ibm-x-dx-omnichannel-commerce-experience
AdamG 110000672C Tags:  web-experience-factory mobile websphere-portal wef multichannel portlet portal worklight 4,773 Views
In todays world, users expect to be able to access their information and applications anywhere, anytime on any device.
There's been a lot of buzz around recently about having a single site / web experience that can drive a OPTIMIZED multi-channel web experience for folk accessing the site and applications using desktop browsers, smartphones and tablets.
When you look at a site it's usually made up of a mish-mash of various content and application sources, including web content management, social software and applications. It's often the applications that are often the critical component that deliver some key value like doing your banking, checking the order status or interacting with some important business process.
Before the mobile revolution, these applications have had the luxury of the desktop browser, with all it's plugins, screen real-estate and desktop capabilities you can develop some easy to use very functional applications. Now with the need to access those same applications in the new disconnected world we live in, you're dealing with limited screen real-estate, many different form factors, fat fingers, mobile operating systems like iPhone, Android, Blackberry and Windows Phone etc and many other new capabilities and restrictions.
Using WebSphere Portal as the backbone for the multichannel web experience, with IBM Web Experience Factory to develop these multichannel applications, it makes it possible to have a single application the uses dynamic profiling to adapt itself to the specific device being used. The application can optimize itself to suite the form factor, operating system of the user. Developing this as single application that knows how to deal with the form factor creates a potential for massive time and cost savings.
A lot of the time, the native mobile/tablet browser will provide you all the capability you need and you have one application that knows how to deal with desktop browsers, mobile and tablet. However in certain situations you need to be able to go beyond the mobile browser's capability to access smartphone and tablet device specific capabilities like the camera, address book, accelerometer etc... Now many organisations have seen this gap and looked to start from scratch and develop completely separate native phone applications.Starting from scratch often means using device specific development environments, APIs which often require new skills, or even new people, not to mention the initial outlay to redevelop existing applications and the massive ongoing cost of maintaining them.
So, a separate native app is one approach, another is to leverage your single multi-channel site and applications you developed with WebSphere Portal and Web Experience Factory and combine it with IBM Worklight to provide the option to deliver your web-applications as a native-like app. I say "native-like" as it is actually a hybrid app, that takes your web-app... you supply special markup (dynamically profiled of course) which allows you to create application that look like and work like native phone/tablet applications.... all from a single core application source. Wow!!!
Check out some of these videos:
Multi Channel Web Experiences Part 1 of 2 - a quick 90 second into on challenges and benefits
Multi Channel Web Experiences Part 2 of 2 - a 7 min demo on actually using Web Experience Factory to create a hybrid IBM Worklight application.
Over the last couple of years developer Adam Kewley has had the need to create a Dojo Form Dialog in IBM Web Experience Factory (WEF) that interacts with the end user. The dialog is expected to update itself without refreshing the entire page. By utilizing custom refresh features within WEF you can construct a dialog that will behave more like a popup window.
Read the blog article and download the sample here.
AdamG 110000672C Tags:  wpf conference ibm portlet websphere-portlet-factory websphere wef web-experience-factory portal 4,752 Views
if you have not registered for the IBM Exceptional Web Experience Conference 2012 in Austin Texas, you should think about it :-)
Click this link for details and to register:http://www-304.ibm.com/jct03001c/services/learning/ites.wss/us/en?pageType=page&c=H812960D80151X25
We have an awesome line-up covering IBM Web Experience Factory covering the latest and greatest, customer examples, integration examples, best practices etc, including:
For details on each of these agenda items, see the current schedule here (subject to change): http://www-304.ibm.com/jct03001c/services/learning/pdfs/2012_Exceptional_Web_Experience-Americas_Directory.pdf
Looking forward to seeing you there :-)
But what is WEF great at? Taking a pattern and automating the repetition of that pattern. So we created a wizard. Which has been added to our OpenNTF offering. This wizard allows to create a new portlet based on an existing application or a blank application for your creation. The wizard asks if you want the model to be a portlet, if you want to include WEF services that are available from an existing service provider and if you want to create a new application or reference an existing one as is. If you choose a new one it asks which libraries you plan to use what application template you want to use and it creates a new model that is available for your use. If you say you want to reference an existing HTML file, you are then asked if it is one that is currently in the project or you have a zip file that contains the application. If it is an existing file then you select the file and the model is created for you. If you choose the zip file you are asked to choose the zip file. The chooser is limited to files that are already in the project by default, but there is a button that allows you to add a file to the project. You can use this to reference zip files that you have downloaded or received from other places. There is also an option to delete the referenced zip file after the wizard has extracted the files into your project. There is also a convert any templating check box that is included to help you convert your applications that need this as they are imported. The most common issue we have run into so far is the default ERB templating that underscore.js supports. So the defaults for the conversion fields are set to convert the
There's a new sample builder just posted on the wiki called “Application Page”. It lets you create a page that implements one of several common UI design patterns including data view and data entry pages. It automates and simplifies the multiple steps that would otherwise be required, for example to import a page, apply the Data Page builder, and add “submit” button support. I'm hoping that people find this builder useful, and I'm also hoping to get feedback on it, since we're considering something like this for a potential future product release. The article and sample includes a description of the builder with screenshots, the complete builder source, and a set of example models that implement various UI design patterns.
Background and motivation
To build a UI (portlet) model in Web Experience Factor (WEF), the key initial steps/builders we generally recommend are:
For step #2 (creating the initial display), this is a place where we'd like to provide more options and better guidance. Currently if you can't use a high-level page builder for this step, you have to drop down into a more complex level of WEF development requiring more builders and more configuration steps.
The Application Page builder is designed to help address this. With this builder you can fill out a few inputs to create a page that implements one of several common UI patterns. Then you can proceed with steps 3-5 above. You can also use this builder to add pages to any model.
With this builder you'll still (of course) need other builders to create a complete application. In terms of how much automation it provides, it sits at a level midway between the current high-level builders such as View & Form and the lower-level builders such as Imported Page and Data Page.
I'd love to hear your feedback on this builder. You can leave comments to this blog or on the wiki page.
Here's a link to the sample and article: Application Page Sample Builder
AdamG 110000672C Tags:  wef wpf websphere-portlet-factory let portal web-experience-factory port 4,474 Views
FYI, new Whitepaper available: Basic guide for using IBM Web Experience Factory
Learn how to use IBM Web Experience Factory 8; specifically, how to create a simple Create, Retrieve, Update, Delete (CRUD) portlet and how to add a filter to the portlet, using one or two input text or combo boxes. This white paper also explains the steps to add validation rules to the portlet and to add notifications to the portlet input form. We focus on the step-by-step process and provide images for all steps.
AdamG 110000672C Tags:  wef sphere web-experience-factory wpf portlet mobile development web mobile-development portal 4,473 Views
In the spirit of a community that helps itself, one of the things we were thinking of doing in this community is providing a place for IBM Web Experience Factory developers to access sample code, share code etc.
For example, perhaps you have done some cool stuff that works with IBM Web Experience Factory that you'd like to share or perhaps you've created a new builder you think others would be keen to use.
What are your thoughts about this?
Please comment below
One of the things about WEF, as a development tool, is its friendliness to plugging in custom Java code. And so you know the basic mechanics but people don’t talk a lot about the strategy of how to organize the LJOs that you do create. As you might imagine, there is value in putting a little thought into this, and the following ideas have evolved into a pretty useful strategy.
by Kevin Wilmeth
One of the things we love about IBM Web Experience Factory (WEF), as a development tool, is its friendliness to plugging in custom Java code. And by this we mean optionally plugging in code, only where it is truly needed, not being covered natively by the buider set. You can do this in…a lot of places, including places people wouldn’t necessarily even think to look. (Ironically, the full extent of this capability often eludes the highly experienced Java programmer, who may be mentally wired in to a different way of organizing code, and not intuitively “see” how WEF presents itself for such extension.)
And so we have the humble “Ell Jay Oh” as part of the toolkit—we teach its basic mechanics within the first five days of training—but we don’t talk a lot about the strategy of how to organize the LJOs that you do create. As you might imagine, there is value in putting a little thought into this, and the following ideas have evolved into a pretty useful strategy that I like more the more I use it.
LJO layers that work together
The big inspiration for my strategy came some years ago now, when the Domino builder set first became available and I worked on a number of projects that needed it. As a longtime Domino developer before I discovered the Factory, I understood that really getting value out of Domino meant going beyond (way beyond) the limited capacity of the builder set. And so lots of core Domino functions wound up as Java methods in LJOs. Enough so, that I had to do something to organize them!
At some point, it dawned on me to look at my LJOs in layers, much like you’d think of SOA layers. It turns out that there are two very clear separation points that you can lean on to do this: IXml, and WebAppAccess. This implies three layers of LJOs in your project architecture.
Continue reading: http://dzone.com/Zf6w
AdamG 110000672C Tags:  wpf portal wef websphere-portlet-factory web-experience-factory 4,409 Views
just to let you know we have rolled a new version of the IBM Web Experience Factory V8.0 into a trial...Try it out!!! :-)