User Management Guide

Creating and Updating User Profiles

Developers can use Workshop for WebLogic to create JSP tags and controls that add and edit user profiles. A user profile consists of a username and any additional properties you collect and store about a user. These properties can be used to personalize the user’s experience in your portal.

Properties can consist of personal data, work-related data, geographic data, or something else that logically categorizes your users. For example, you could create a property set in Workshop for WebLogic called human resources that contains properties such as gender, hire date, and e-mail address.

You must use Workshop for WebLogic to programmatically create user profiles, edit the profile’s default property values, and enable property value encryption.

Administrators can edit the profile’s property values in the Administration Console. See Editing User Profile Property Values for instructions.

When users log into a portal, the portal can access the property values and target them with personalized content, e-mails, pre-populated forms, and discounts based on the personalization rules you set up. See the Interaction Management Guide for more information.

Developers can use the following tools to programmatically create and edit user profile default property values:

This chapter includes the following sections:

Creating a User Profile

A user profile is a collection of user property values for a user from all available user property sets. Each piece of metadata in a user profile is called a user property. A user profile property set organizes the properties that it contains and provides a convenient way to name a group of properties for a specific purpose. The properties you create can be used to define rules for personalization, delegated administration, or visitor entitlement.

User properties can range from statically-defined properties (such as a user’s phone number and e-mail address) to dynamically-created and persisted properties (web site tracking information for the user, for example). A property set called personal could contain properties, such as age, gender, marital status, and address. Another property set called preferences could contain properties, such as hobby, favorite color, and news preference.

You must create user profiles and edit the profile’s default values in Workshop for WebLogic. You can edit the profile’s values in Workshop for WebLogic or in the Administration Console.

WebLogic Portal provides a default user profile property set called CustomerProperties.usr that contains common properties.

This section contains the following topics:

Creating a User Profile Property Set

You can create a user profile and a property set in Workshop for WebLogic. You can edit the profile’s default values in Workshop for WebLogic or in the Administration Console.

To create a property set for a user profile:

Adding Properties to a Property Set

After you create a property set by following the instructions in Creating a User Profile Property Set, you can capture user information by adding properties to the profile.

To add properties to a user profile property set:

Transferring an Encryption Key Between Custom UUPs

If you use more than one UUP for your user data and you want to share encrypted data across portal applications or domains, you must transfer the encryption key from one UUP to another UUP. The 3DES symmetric algorithm uses the same key to encrypt and decrypt data.

If you use the Profile Manager to encrypt profile data, you have to transfer the managed encryption keys to another portal application or domain. This transfer is required because the Profile Manager manages encryption keys for each encrypted property set through the Portal application’s deployment descriptor and plan. Transferring the encryption key ensures you use the same encryption key for all domains and applications.

To determine if this is the best way to encrypt data for your application, see Planning Data Encryption.

To generate an an encryption key:

To transfer the encryption key to re-use the user profile data from another application:

Editing Properties and Values

You can use Workshop for WebLogic to create user profiles and the profile’s default values. You can edit the profile’s values in Workshop for WebLogic or in the Administration Console. See Editing User Profile Property Values for instructions on editing the values for property sets in the Administration Console.

This section contains the following topics:

Editing Properties and Values in the Property Editor

Developers use the user profile editor in Workshop for WebLogic to create a user profile and add the profile’s properties. Then you can edit properties and their default values that are part of each user’s profile.

To modify properties and their values in Workshop for WebLogic:

Editing Properties and Values with JSP Tags

A set of JSP tags allow for easy access to property set data:

For more information on these tags, see JSP Tag Javadoc.

The <profile:getProperty> JSP tag retrieves property values for a specified property set. The <profile:setProperty> JSP tag updates a property value for either the session's current profile or for the anonymous user profile.

Typically, the <profile:getProperty> tag is used after the <profile:getProfile> tag is invoked to retrieve a profile for session use. The <profile:getprofile> JSP tag retrieves a user profile and its properties. The <profile:getProperty> and <profile:setProperty> JSP tags let developers retrieve and rapidly edit properties for a large number of users. If the <profile:getProfile> tag is not used before the <profile:getProperty> tag, the specified property value is retrieved from the anonymous user profile.

See the JSP Tag Javadoc for more information on the Java class.

You can retrieve an authenticated user profile by using the <profile:getProfile> JSP tag in a page flow as shown in the code sample in Listing 5-1.

<%@ page import="com.bea.p13n.usermgmt.SessionHelper"%>
<%@ taglib uri="http://www.bea.com/servers/p13n/tags/usermanagement"
   prefix="profile"%>
<%@ taglib uri="netui-tags-databinding.tld" prefix="netui-data"%>
<%@ taglib uri="netui-tags-html.tld" prefix="netui"%>
Profile is: [<code><%= SessionHelper.getProfile(request) %></code>]<br>
<%-- This tag works for authenticated users. --%>
<profile:getProfile profileKey="<%=request.getUserPrincipal().getName()%>"
   profileId="profile"/>
Profile is: [<code><%= profile %></code>]<br>

<%-- You would generally want to do this in your PageFlow, not your JSP. --%>
<netui-data:declareControl controlId="profileControl" 
   type="com.bea.p13n.controls.profile.UserProfileControl"/>
<netui-data:callControl resultId="getProfileFromRequestResult"
   controlId="profileControl" method="getProfileFromRequest">
<netui-data:methodParameter
   value="{request}"></netui-data:methodParameter>
</netui-data:callControl>
Profile is: [<code><netui:label value="
   {pageContext.getProfileFromRequestResult}"></netui:label> </code>]<br>

If the user is registered, then the profile can be retrieved without a reference to the session, as shown in the code sample in Listing 5-2. This method is useful if you do not have access to the session object.

import com.bea.p13n.usermgmt.profile.ProfileFactory;
import com.bea.p13n.usermgmt.profile.ProfileNotFoundException;
import com.bea.p13n.usermgmt.profile.ProfileWrapper;
import java.rmi.RemoteException;
public class MyHelper 
{
    public static String helperMethod(String username)
    {
        try
        {
            ProfileWrapper profile =
               ProfileFactory.getProfile(username,null);
            // do something helpful here.
            return profile.toString();
        }
        catch (RemoteException ex)
        {
        }
        catch (ProfileNotFoundException ex)
        {
        }
        return null;
   }

For anonymous and tracked anonymous users, you must retrieve the profile from the session. Anonymous profiles have no identity. Tracked anonymous profiles have an identity that is not valid for authentication. A safe way to retrieve the identity for a user, based upon the user’s profile type, is shown in Listing 5-3. This code sample retrieves the current ProfileWrapper and gets the username associated with the wrapper.

<%@ page import="com.bea.p13n.usermgmt.SessionHelper"%>
Profile Id is: [<code><%= SessionHelper.getUserId(request) %></code>]<br>

Use the following returned values to determine the user type:

Editing Properties and Values with Controls

Developers use the getProperty and setProperty actions in the Property control to let users retrieve property values for a property set and update property values for either the session’s current profile or for the anonymous user profile.

For more information on using the Property control and its properties, see the Javadoc.

Listing 5-4 shows how a user can use the setProperty action in the Property control to edit a Profile Wrapper. An example page flow (and associated JSP) that uses controls to offer a form for the user to set a favorite color is shown in the code sample. This example requires a Generalnfo.usr user profile property set file to exist in the \userprofiles folder of the data project, with a single-valued, restricted, text FavoriteColor property. For more information, see the help in Workshop for WebLogic.

<%@ page language="java" contentType="text/html;charset=UTF-8"%>
<%@ taglib uri="netui-tags-databinding.tld" prefix="netui-data"%>
<%@ taglib uri="netui-tags-html.tld" prefix="netui"%>
<%@ taglib uri="netui-tags-template.tld" prefix="netui-template"%>
<netui:html>
   <body>
      <netui:form action="setColor">
         <table>
            <tr valign="top">
               <td>Favorite Color:</td>
               <td>
               <netui:select dataSource="{actionForm.color}" 
                  defaultValue="{pageFlow.usersColor}"
                  optionsDataSource="{pageFlow.possibleColors}">
               </netui:select>
               </td>
            </tr>
         </table>
         <br/>&nbsp;
         <netui:button value="Set Color" type="submit"/>
     </netui:form>
   </body>
</netui.html>

Editing Properties and Values with the ProfileWrapper Object

Developers can change user profile property values by calling the ProfileWrapper object directly. For more information, see the Javadoc.

Retrieving User Profiles

You must specify which set of user or group properties the user should inherit by configuring a ProfileWrapper successor at runtime. A ProfileWrapper is a lightweight object that can access the correct ProfileManager session beans based on the profile identity with which it is initialized. The ProfileManager has a getAllProfileNames method and a listAllProfiles method. The listAllProfiles(int pageSize) method efficiently retrieves all user profiles or group profiles. See the Javadoc for more detail.

Deleting a Property Set and Properties

You can use Workshop for WebLogic to delete individual properties from a property set, or you can delete an entire property set.

This section includes the following topics:

Deleting a Property

To delete individual properties from a property set:

Deleting a Property Set

To delete a property set:

You can also use the <profile:removeProperty> JSP tag or the removeProperty action in the Property control in your page flows to remove existing properties or profiles for users. See the Javadoc for more information.

Using Properties from an External User Store

If you created a UUP to access external user or group properties, you can use those properties to define rules for personalization, delegated administration, or visitor entitlement.

After you create a UUP to access these properties in the external user store (for example, an openLDAP server) you can access those external properties only through WebLogic Portal's JSP tags, controls, or APIs. Those external properties are not yet accessible in the Administration Console.

You must surface those external properties in the Administration Console if you want to use those properties in defining rules for personalization, delegated administration, or visitor entitlement.

To use properties from an external user store: