We have combined our Digital Experience Products Support Blogs with our Application Integration Middleware Support Blog. You will find new content for the DX suite of products at Application Integration Middleware Support Blog. Existing blog entries for DX will remain on this blog since there is a wealth of great information here, but be sure to follow us at our new location so you will be up-to-date on new content. Update your bookmarks and rss feeds and check us out at our new space! You can also find information on that blog about many of the other products in our middleware portfolio.
IBM Web Experience Factory Blog
Anthony Whelan (IBM) 31000066QG 2.819 Visualizações
Using Web Experience Factory as a data service provider for Script Portlet and WEF single page applications
gsager 060000WU3G 3.683 Visualizações
We've now posted an updated version of the Script Application builder samples as open source, using the OpenNTF repository. It's available here
gsager 060000WU3G Marcações:  wizard jquery openntf single_page_app builders 4.686 Visualizações
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
ruthspeaks 2700006S3X Marcações:  david-wilkerson ldap portlets wcm puma wef was davalen rad portal 4.021 Visualizações
IBM Web Content Manager (WCM) and portlet developers can benefit from a sandbox where the Lightweight Directory Access Protocol (LDAP) configuration matches that of their production environment. This is especially true when the LDAP schema of a production system has been extended. This article explains why and how to implement an enhanced LDAP configuration on a sandbox portal environment.
Read full article at: http://www.dzone.com/links/r/improve_users_digital_experience_by_extending_the.html
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.
Jonathan Booth 060000XRMC 3.978 Visualizações
Going forward we expect to use this open source OpenNTF approach for publishing sample builders or other reusable extensions for WEF, instead of posting them on the WEF wiki as we did in the past. For posting "how to" examples of techniques we will continue to use the WEF wiki, since there is already a large body of samples there (around 150 at my count!).
Across the wider Portal / Digital Experience team, we will also be using the OpenNTF repository to publish samples of many different types. For example, there is a new set of Script Portlet samples posted there, and going forward we expect to post Portal theme samples, WCM samples and plugins, and other samples and extensions. We are also working on creating a "mini-site" on developerWorks for accessing these samples and extensions.
For any of these OpenNTF posts, you can download the package from the OpenNTF project page and you can click the "Source Control" link to access the source code on Github. And we'd love for you to get involved. You can post feature requests, report defects, and take part in discussions. If you are interested in posting your own samples or extensions as open source (possible based on something we've posted), for WEF or for any part of Portal, this OpenNTF page has information about how you can contribute: http://openntf.org/main.nsf/page.xsp?name=Get_Involved
New samples, articles, and builder for using jQuery and other script libraries with Web Experience Factory
JQuery and other JS-based libraries are getting used more and more for application development across the industry, and there are now a huge number of open source and other script libraries available that support a wide range of features. We increasingly see Web Experience Factory (WEF) customers using these libraries in their WEF applications. To support this trend, we've just posted a series of articles and samples on using jQuery and other JS libraries, along with a "Script Application" builder that you can download.
By combining WEF with jQuery or other scripting libraries you can:
The new articles and samples show a few different scenarios for using WEF with script libraries. They show how you can do this using standard WEF builders, and then they show how the Script Application builder can make things simpler. The Script Application builder automates a common pattern for building script-based applications:
Using WEF and the Script Application builder, you supply the application JS/HTML, specify the libraries you want to use, and then the portlet or web application is generated for you. For access to data and services, you can reference a WEF Service Provider model and have all of its operations automatically available to your JS code via REST/JSON.
We expect to continue posting additional samples and downloadable tools related to building script-based applications and using script libraries with WEF. There are a lot of different potential scenarios for using WEF's model-based code generation with client script-based applications. If there are specific scenarios that you are interested in, we'd love to hear about them, by adding comments here, posting in the WEF forum, or email.
Here's a list of the recently posted articles and downloadable code, all available on the WEF wiki:
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
ruthspeaks 2700006S3X Marcações:  development wef portal davalen code technical adam-kewley java 4.960 Visualizações
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:
NiharT 120000Q88P 3.363 Visualizações
The recent conference (workshop) on Social interaction patterns, exceptional digital experiences has been good source of information. Take a look at this link for further information - https://www.ibmdw.net/social/2013/11/14/webinar-replay-technology-deliver-exceptional-social-digital-experiences
This Webinar also covered integrating web experience factory, Social Business toolkit and multi-channel feature pack for developing social integration using high level wrappers.
AdamG 110000672C 3.060 Visualizações
tom_be 270006P2EP 4.397 Visualizações
How to Integrate Bootstrap with Web Experience Factory for an Exceptional UI Experience
This is a short blog that describes a project I created on Github that contains a WEF Theme showing how to integrate WEF with Bootstrap. This includes the theme file, data definition, html template, DSUI base pages, and a sample model. The theme gives you basic DSUI functionality for list, details, and edits pages. Currently the Bootstrap css and jQuery are pulled in from a CDN.
This is just the initial version, and there is plenty of work to be done such as adding Bootstrap specific builders to fully leverage its features.
Download the attached wef_bootstrap.zip or fork the project and build it from source. To build from source you will need to run 'ant' from the project folder.
Once you have the wef_bootstrap.zip file use the Import > Web Experience Factory Archive to add to an existing project. Then run the provided sample DSUI consumer model (models/bootstrap/OrdersBootstrapSample.model)
If you would like to contribute you can clone this repo, and then submit a pull request for bug fixes or features.
Orders Sample Pages
This follow are the list,details, and edit page from the provided sample.
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 Marcações:  websphere-portal portlet digital experience web factory mobile wef mobile-development mobilefirst web-experience-factory 5.229 Visualizações
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
Jonathan Booth 060000XRMC 7.754 Visualizações
I'm very happy to announce the availability of the Multi-Channel Feature Pack 2 for Web Experience Factory 8.0. This is our second Feature Pack release of 2013, and it continues our focus on the key themes of developer productivity and support for mobile and multi-channel applications. We're using these Feature Pack catalog releases to get new tools that support these themes into the hands of developers quickly.
Here are the key features in this release:
This picture shows a few screenshots of some sample banking applications built with this Feature Pack.
This Feature Pack requires the latest Web Experience Factory Fixpack 18.104.22.168, and some of the enhancements listed above are part of that Fixpack.
Here are some key links for this Feature Pack. We hope you download the Fixpack and Feature Pack and try this all out!
Sri. 270001WW4Y Marcações:  web web-experience-factory wef app jqm mobile jquery 1 Comentário 9.381 Visualizações
Finally, I am here. With my first blog post for developerWorks!
I have built a sample Model that uses jQuery Mobile (called JQM hereafter) and builds the UI for mobile app. This sample Consumer Model uses the sample Provider Model (Tutorial_DB_Provider_WASCE.model) that is supplied with WEF. You get this sample Provider Model when you add “Tutorials and Samples” Feature Set to your project (I’ve included the same model here in the attached sample too).
The Consumer Model uses only two Service Operations from the Provider Model. When you run the Consumer Model, you will see the list of employees in a List View of JQM. Once you tap / click on an employee name, details of this employee will be shown.
Create a new project in WEF and extract the JQM library to the WebContent folder.
You can check out the HTML in employeeList Imported Page to see how a basic JQM page is created using HTML. A named tag (empList) has been added to the page to place the Data Page builder. After adding the Data Page builder, I have exported the HTML for Data Layout and modified the HTML to change the auto-generated table into JQM Listview. This can be seen in pages/employeeList MyDBRowSet.html. Here is a screenshot from my desktop browser (Chrome). When accessed from a mobile device browser, it will have the same look and feel. The filter provided on top is an out-of-the-box feature of JQM which is added by using just an attribute. You can filter the list by any of the fields / values shown in the UI.
Then I have added a Link builder which will call an Action List (showEmpDetails) which takes the employee number as input. This Action List passes the employee number to retrieveMyDB Service Operation, gets the employee details and shows the employeeDetails page. Again, this page has been customized using HTML Data Layout to use the responsive table provided by JQM. This responsive design too is OOTB and it can be customized to fit your needs. This feature is really cool and one of my favorites in JQM!
The above screenshot is taken with the browser window size set to simulate a mobile phone size. Now if you view the same UI in a tablet (Android or iPad or any other), you will get a layout like this:
This will really be helpful if you have a lot of records to be displayed in the UI; mobile phones will have a stacked view where all the records will be shown one below the other in two column layout with labels as the first column. And you can leverage the screen size in tablets and mobile phones with larger display by displaying data in the traditional tabular format where the labels are shown in one header row and the data below.
You would see a nice transition when the employee details page is shown after clicking on an employee name and again when you click on the Back button in the details page. This too is given by JQM with the addition of an attribute (data-transition=”slide”) to the anchor tag.
That’s pretty much the sample does. I have attached the WEF export below.
To run the sample:
1. Create a project (no Feature Set is required) and deploy it in WAS CE
2. Import the attached ZIP file to your project
3. Open the Tutorial_DB_Provider_WASCE model and click on Create Table button. (If you get a message that the table already exists, no problem. You can go ahead to the next step)
4. Run jqmConsumer.model
As you might already be aware, Web Experience Factory is a great tool to build highly-customized, rich web applications. With the simplicity and power of jQuery Mobile in WEF, we can build great mobile web apps with good UI & UX.
Hope this helps! Please feel free to ask any questions!
AdamG 110000672C 3.107 Visualizações
Hi folks, updated the Leveraging IBM Web Experience Factory whitepaper, to match the new IBM Exceptional Digital Experience messaging - click here
AdamG 110000672C 2.824 Visualizações
Folks, on Wednesday, July 17, 2013, 11:00 AM ET there will be an important Webinar covering Digital Experiences... register for it it should have some pretty cool stuff https://ibm.biz/BdxCZf
Together, IBM executives, leading industry analysts and customers will explore how you can create an exceptional customer experience and:
Understand the individuals in your market: Listen to and anticipate customer preferences and captivate them with rich, personalized digital experiences.
Deliver exceptional service: Delight users on any channel or device with integrated and tailored applications and content.
Engage individuals and communities: Exchange valuable insights and feedback and build trusted relationships, loyalty and advocacy.
Interesting survey results from Forrester: "Many organizations tell us that they’ve shifted their mobile strategy away from creating specific apps built for iOS and Android devices, unless and until they have a compelling reason to create a custom app experience."
See the article here.
This really highlights some of the power of what IBM are offering with http://ibm.com/webexperience with super strong mobile web and hybrid (IBM Worklight) technology. These are the exact scenarios we've been developing with IBM Web Experience Factory capability, demos and samples in this community.
Jonathan Booth 060000XRMC 3.394 Visualizações
Probably my favorite part of working with WEF is in the area of builder development, both developing new builders myself and teaching people how to make custom builders. The builder framework in WEF is extremely flexible in terms of what you can automate with a builder. There are UI control builders, high-level UI pattern builders, back end data access builders, builders that create and populate DB tables, cross-cutting builders that modify elements across a whole application, builders that generate complete Java classes, and more. And with the ability for a builder to invoke any other builders, you can create a new builder that uses any or all of the above types of builders at once. On a number of occasions I've been talking to customers about challenging development issues, and I've been able to show them how a custom builder can leverage WEF builder automation to address the issue in a powerful way.
Recently there have been several postings that anyone interested in custom builders should know about. There are new and updated resources on the WEF wiki, and there's also a nice blog written by Adam Kewley posted recently in this community,
ruthspeaks 2700006S3X Marcações:  generation best-practices dojo java development davalen builders 6.077 Visualizações
The original article can be viewed: http://wp.me/pPofT-vU
By Adam Kewley, Web Experience Factory Lead, Davalen
There are many benefits to creating your own custom builders. Be it setting standards, code reuse, or simply making it easier for other developers to implement your functionality across multiple projects. Writing builders and mastering the creation of them however can be tricky. While IBM provides a lot of documentation and samples, it’s nearly impossible to cover all the areas of builder creation. In this article, we’ll try to address a couple of these lesser-known areas, and provide tips on how to better understand builder creation. This article assumes a basic understanding of the creation of Java-based builders in Web Experience Factory.
We’ll start by generalizing builders into three major areas of interest. The first is the UI itself. The UI mainly consists of the BuilderDefinition (bdef), and the optional Coordinator class. The second area is code Generation. The Regen class generates code and webapp artifacts for the builder. The final area is composed of the Helper class, and other webApp artifacts which assist in the runtime execution of the builder.
The UI of the builder starts with the Bdef or Builder Definition file. You can create your own from scratch, use the builder skeleton to get you started (recommended), or simply clone an existing bdef file. This file contains the information about the builder itself, along with the builder inputs, tooltips, and other metadata. The best way to get a better understanding of how these files work is to open up the WEF builders and view them yourself. Most of the WEF builders can be found by extracting the WEB-INF/builders/webappbuilders.zip file. This archive contains most of the builders used in WEF, and will provide a valuable resource when constructing your own. Additional builders (such as Dojo or data service builders) will be automatically added to your project as you install various featuresets. These builders will not reside in an archive but simply be placed within subfolders of the WEB-INF/builders directory. While writing my own builders, I’ll often refer to these core factory builders to copy out different inputs or Widget types. All of the inputs are made up of Widgets. The widgets are defined in Widget Definition files, which drive the UI.
The BDEF or builder definition files will be your best source of information. Not only can you copy over builder inputs, but you can also view other builders to get information about various parameters that can be passed to customize these inputs.
The coordinator class is used to automate UI interactivity with the end user. They are not always required, but useful for making it easier for users to interact with complex builders. When creating a coordinator class, I usually rely on the builder skeleton to create the initial class for me. The builder skeleton (builder) will generate the class, and populate it with useful code and information. It will also follow the WEF recommended java based builder structure. This can be used as a great starting point for working with your coordinator. Unfortunately there is not much information for creating your own coordinator classes, and we cannot directly gain access to the core builder coordinator classes as we can the Bdef files.
The generation class does the work for the builder. Either by generating content, or manipulating the webApp, this class usually contains the bulk of the code and logic. You’ll be spending most of your time with this class when creating a java-based builder. I recommend using the builder skeleton builder to generate this class for you. It will setup the initial methods as well as define some useful structures for creating your own builder. Once again there is not a lot of information for the end user, so working with IBM samples and documentation is important here.
Most builders Implement the WebAppControlBuilder Class, and override the DoBuilderCall method. This approach gives you a PageLocation object in which to place one or more elements on the page of your choice. However, there’s another lesser-known approach which utilizes the BaseWebAppControlBuilder Class and overrides the handleControl() Method. Instead of a PageLocation object, you’re given the Page object, for the current page you’re operating on, and an IXml object that represents the tag you’ve selected for the builder. This means you can directly manipulate the content as an Xml object. Very useful for modifying existing content or adding elements directly to the page.
The regen class should contain a BuilderStaticValues Interface class, which contains builder input names, and enumerated input values. While updating the builder with new inputs, be sure to add to this interface. If you’re using helper classes or coordinator classes it will be useful for easily recalling various builder inputs.
Most builders also invoke other builders. Very few builders (aside from atomic builders) do all the work themselves. Invoking other builders is an essential part of most builder creation. It can be difficult knowing the proper incantation and set of inputs to assign before invoking a builder. Utilizing the builder API java doc, reading up on samples, and investigating the Model XML (for various builder inputs) will provide a lot of insight into how to invoke these external builders.
The regen class also handles capturing and manipulating of inputs. If you’re adding additional inputs, check the modelXML view of an existing model that uses a similar input. If the input value is XML you’ll want to call the appropriate get method from the BuilderCall class as getString will most likely not return the value in the format that you’re looking for. Setting these values for the helper class may be important as well.
WebApp Objects and Helper Class
The builder helper is a class that assists the builder during runtime. Any builder that contains a helper class will have an LJO associated with it in the webapp. A good example of this is the split pager builder. The pager builders have a pager helper api which control which page is being viewed, along with returning information on the current page, current record and other information. Helper classes are not always needed, but if your builder needs to interact with something across multiple requests, a helper class is a good idea. Furthermore, if you simply need to access static data, a variable can be added instead (to the webapp) which can be set at regen time. Any runtime changes should be handled by a helper class.
Additional WebApp artifacts may exist to aide in the runtime execution of the builder. Variables, Schemas, Methods, Linked Models, and other artifacts may be added by the builder to assist.
There are several areas where a builder can go astray and cause headaches. Most of the time I’m writing a builder for a one-off scenario where it really won’t be much of a use outside its current ecosystem, but it never hurts to think about reusability. There are many snares that can catch up a wayward builder if not properly planned for. Unfortunately, These traps are not always evident either. Here are a few scenarios:
This section focuses on tips and tricks for better understanding and constructing builders.
final String NEXT_ID = StringUtil.strcat( “IDGenerator.getNextID(
webAppAccess, \”", name, “\” )%>” );
final String CURRENT_ID = StringUtil.strcat( “IDGenerator.getCurrentID( webAppAccess, \”", name, “\” )%>” );
// “Implicit” here means “add to head tag and don’t rely on page location.”
// Cumulative warning message (will not block)final String message = “Negative Values for Offset are not recommended as undesirable effects may occur.“;builderCall.addMessage( BuilderCall.SEVERITY_WARNING, message );// Blocking error messagefinal String message2 = StringUtil.strcat( “Value:”, sysID, ” Out of Range! SysID must be greater than 0 and less than 15” );builderCall.addMessage( BuilderCall.SEVERITY_ERROR, message2 );
I will be discussing some of these topics and more in a technical presentation at the IBM Exceptional Web Experience 2013 at the Hilton Chicago, May 20 – 23, 2013. More details to come.
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
Streebo Inc 2700054RP4 Marcações:  portlet java web eclipse 1.6 factory build experience wef 6.189 Visualizações
Streebo Inc 2700054RP4 Marcações:  enterprise factory mobile applications strategy streebo experience faq ibm mobility web 6.488 Visualizações
Streebo Inc 2700054RP4 Marcações:  ibm wef web factory experience 1 Comentário 7.692 Visualizações
Jonathan Booth 060000XRMC 3.806 Visualizações
Recently we've had a number of people asking about examples of some common charting scenarios and about using Dojo's charting features in Web Experience Factory. To respond to this, we've just posted a pair of simple examples on the wiki that show how to implement charting with drill-down actions. There are two implementations of the same basic application, one using the Charts builder (which uses the ILOG JViews charting engine), and the other using Dojo's charting features.
If you look at the two charting implementation in these samples, you will notice that the Dojo example requires more work in the model since there's not yet a dedicated builder to generate Dojo charts. However, all the rest of the application, including the data service provider and the table and drill-down views are the same for both examples.
Here's a link to the sample and article: Chart With Drill-Down Sample
Jonathan Booth 060000XRMC 3.018 Visualizações
In some situations when developing with Web Experience Factory (WEF), you may want to quickly create a data provider model without depending on a back end data store. The new XML File Data Service builder just posted on the wiki is a sample builder that can be used for this. With it, a single builder can be used to create a service provider with complete CRUD (create, read, update, delete) access using data from an XML file. It has no external dependencies or configuration requirements.
Here's a link to the article with screenshots and downloadable package: Sample XML File Data Service Builder
As you may know, the SQL Table Create builder provided in the WEF product can also fill a similar role. It can create a new database table with the columns you want and implement a CRUD data provider accessing that table; however, it does depend on a JDBC data source. This new XML File Data Service builder removes any such dependencies.
The builder package includes all the sample source code, so you can enhance or modify it as you wish.
AdamG 110000672C Marcações:  multichannel wef websphere-portlet-factory multi-channel worklight websphere-portal wpf web-expeirence-factory 5.226 Visualizações
Check out this new demo on our youtube channel showing off some of the AWESOME new Web Experience Factory Feature pack we just made available recently. The demo includes the new IBM WebSphere Portal V8 Update capabilities including mobile themes, skins and responsive web design (RWD), as well as the Content Template Catalog v4 (CTC4).
Jonathan Booth 060000XRMC 3.283 Visualizações
There's a new Redbook just published on building multichannel web sites using IBM WebSphere Portal, IBM Web Content Manager, and IBM Web Experience Factory (WEF). It's based on an example of a city government web site that provides access to content and services for citizens, from any desktop or mobile device. Here are some of the functions described:
Link to Redbook: http://bit.ly/multichannelwiki
Jonathan Booth 060000XRMC 3.401 Visualizações
The slides from the two sessions I did at the IBM Connect conference this week are now posted on the wiki. The turnout was excellent (thanks to all of you who attended!) - there's definitely lots of interest in all of this. The releases last week of the Portal v8 Update with the multichannel responsive theme, CTC4, new Social Rendering, and the WEF Multichannel Feature Pack gives a great complete mobile and multchannel delivery story, and by combining with IBM Worklight it all extends to installed hybrid apps on mobile devices.
Here are the slides for my two sessions: