Release 9.0.1
Part Number A87536-01
 Library |
 Solution Area |
 Contents |
| Oracle9iAS Personalization Recommendation Engine API Programmer's Guide Release 9.0.1 Part Number A87536-01 |
|
This chapter consists of an overview of the methods that are used to manage the recommendation engine proxy, to collect data, and to obtain recommendations, followed by the individual methods listed in alphabetical order. The supporting classes for these methods are described in Chapter 2.
For examples of how to uses these classes and methods, see Appendix A and the complete example in Appendix B.
All of these methods return results in real time. Usually they return recommendations for a single user.
All methods described in this chapter are public.
The recommendation proxy (REProxyRT) methods can be divided according to function, as follows:
To use the REProxyRT (and its exceptions), you must include the following statements in your Java program:
import oracle.dmt.op.re.reapi.rt.*; import oracle.dmt.op.re.reexception.*;
All of these classes reside on the system where Oracle9iAS is installed.
REProxyManager handles a pool of REProxyRT instances. Using multiple REProxyRT instances within a JServ provides the following benefits:
Multiple proxy instances can result in the following issues:
The REProxyManager class also includes a caching mechanism that supports data collection in the recommendation engine.
The REProxyRT class includes the DataCollection Cache, which supports data collection in the RE. Every time you create an REProxyRT object, the cache is built as a subcomponent of the proxy object. When data is collected using the REAPI calls addItem() and addItems(), the data is stored in the cache (in the memory) and is periodically flushed to RE schema. This "batch save" improves RE performance. The cache is created when a new REProxyRT object is created. The refresh rate is defined by an input parameter to REProxyManager.createProxy().
Currently, only item and user ID data in the classes DataItem and IdentificationData are cached, and they are cached as current session data.
REProxyManager is a singleton implementation, that is, only one instance of the REProxyManager class is created in a particular JVM instance, and the class is loaded automatically.
The REProxyManager class is used to create and manage the instances of REProxyRT. REProxyManager has only static public methods. REProxyManager does not have a public constructor and hence cannot be created by the user. REProxyManager maintains an REProxyRT pool and uses proxy names to reference to individual REProxyRT objects.
The following methods manage REProxyRT objects:
For examples of how to use the proxy manager, see Appendix A and the complete example in Appendix B.
The following methods manage sessions:
The following methods collect, preprocess, and store data in RE tables. The collected data can be persisted by setting appropriate configuration parameters:
The following methods obtain and manage recommendations:
Communicating the returned recommendations to the end user is the responsibility of the calling Web application. The calling Web application must also decide which recommendations to pass to the user. For example, the Web application may want to check that an item is in stock before recommending the item.
Ratings in OP are in "ascending order of goodness", that is, the higher the rating, the more the user prefers the item. Low rated items are items that the user does not prefer. OP algorithms use these assumptions, so it is important that ratings are in ascending order of goodness.
The meaning of the value returned for recommendation instances where ItemDetailData.attribute is equal to Enum.RecommendationAttribute.PREDICTION depends on the value of interestDimension as follows:
OP uses rule tables stored in the RE to generate the recommendations requested by the recommendation methods. The rule tables are created when a package is built and stored in the RE, that is, when the package is deployed. The specific rule table used depends upon the REAPI call made. In general, the antecedents of the rules are matched against the data in cache (both historical and current session data) and the probabilities of the various consequents are computed. These items are then ordered by probability, and numberOfItems (an API argument) items are returned.
The rest of this chapter contains detailed descriptions of the methods, which are listed in alphabetical order.
A data collection method that adds the specified item to the profile of the user or the session specified by idData. item specifies the data source type, item type, item ID, and value of the item.
addItem(IdentificationData idData, DataItem item)
Identifies a user or a session. item is added to this user's profile or this session.
Item, of type DataItem, to be added to the specified user's profile.
BufferIsFullException
Items are cached locally at the REAPI and synchronously written to the RE; the frequency of the writes is specified as a configuration parameter when OP is installed. It is important that the data synchronization interval is frequent enough to support the Web applications' requirements. For more information about data synchronization, see the administration guide.
When an application needs to add several items at a time, it can either use several addItem calls or one addItems call. When using addItems, the application must maintain the details of the items to be added until the call is made; in other words, the application needs to keep the state. It may be simpler to issue several addItem calls.
addItem and addItems are asynchronous, so the calling application does not need to wait until either call saves the data to the database.
A data collection method that adds one or more items to the profile of the user or the session specified by idData. item[i] specifies the data source type, item type, item ID, and value of the ith item. The items are stored in an array.
addItems(IdentificationData idData, DataItem[] items)
Identifies a user or a session. The items specified by items are added to this user's profile or this session.
The items, an array of type DataItem, to be added to the specified user's profile or the specified session.
BufferIsFullException
Items are cached locally first and synchronously written to the RE; the frequency of the writes is specified as a configuration parameter when OP is installed. It is important that the data synchronization interval is frequent enough to support the Web applications' requirements. For more information about data synchronization, see the administration guide.
When an application needs to add several items at a time, it can either use several addItem calls on one addItems call. When using addItems, the application must maintain the details of the items to be added until the call is made; in other words, the application needs to keep the state. It may be simpler to issue several addItem calls.
addItem and addItems are asynchronous, so the calling application does not need to wait until either call saves the data to the database.
Closes a session and marks the session as closed. Session data corresponding to closed sessions is either purged or archived by a data synchronization process that runs periodically. Archiving or purging and the frequency of synchronization are specified as configuration parameters of the recommendation engine schema (RE schema). For more information about data synchronization, see the administration guide.
If the calling Web application does not call this method explicitly, the session times out after a specified time interval. The time-out interval is specified as a configuration parameter of the RE schema.
The application can also configure the RE to not time out any sessions. In this case, the calling Web application must close all sessions explicitly using this method. If sessions are not closed (and do not time out), the RE tables may fill up rapidly. When the tables are large, recommendation performance is poor; furthermore, disk space may be exhausted.
See the administration guide for information about setting configuration parameters.
closeSession(IdentificationData idData);
Identifies the session to close.
REProxyInitException is raised if the session corresponding to the idData does not exist.
BadDBConnectionException
ConnectionPoolIsFullException
InvalidIDException
ErrorExecutingRE
This method is used by sessionful Web applications only.
Creates a new session for the specified customer (registered user). This method is used by sessionful applications that keep track of session state for existing customers.
OP maintains the mapping between appSessionID and customerID. In subsequent calls, the calling application uses appSessionID to identify the customer session.
createCustomerSession(String customerID, String appSessionID);
Type String, assigned by the calling Web application
Type String, session ID assigned by the calling Web application or null if unknown
Throws InvalidIDException if customerID or appSessionID is null.
BadDBConnectionException
ErrorExecutingRE
REProxyInitException
StringTooLargeException
ConnectionPoolIsFullException
createCustomerSession("100", "Session1");
This method is used by sessionful Web applications only.
The calling Web application must provide session IDs that are unique among currently active sessions. If this method is invoked with a session ID that is currently active at the RE, an exception is thrown. However, a session ID can be reused as long as that session ID is not already active at the RE. appSessionID is synchronized to the MTR by OP. (For more information about data synchronization, see the administration guide.) If the calling application requires session IDs to be unique, its the responsibility of the calling Web application to ensure that appSessionID values are also unique.
OP has no way to tell if customerID and appSessionID are valid values; it is the responsibility of the calling Web application to verify that these values are valid.
Creates an object of type REProxyRT. A proxy connects to a specific RE database and logs in to the database.
The proxy object includes a DataCollection Cache, which caches data collected by addItem() and addItems() methods; collected data is periodically written to the recommendation engine (RE) at the interval specified in the interval argument.
REProxyManager.createProxy(String proxyName,
String dbURL,
String userName,
String passWord,
int cacheSize,
int interval);
Type String, the unique name of the object being created
Type String, the JDBC database URL, in the format jdbcdriver:@hostname:portnumber:SID, where jdbcdriver is either jdbc:oracle:thin or jdbc:oracle:oci8; hostname is the name of the database host machine (as specified by the DBA); portnumber is the port number of the database instance (see your DBA for this); SID is the service ID of the database instance (see your DBA for this). For example, "jdbc:oralce:thin:@dbserver1.mycompany.com:1521:MYDB1"
Type String, the database login name
Type String, the database password
Integer specifying the cache size used by the recommendation engine, in kilobytes; see "Usage Notes" for information about how to determine an appropriate cache size.
Integer, specifying the cache archive interval, in milliseconds; if interval is set to 10000, data is archived every 10 seconds. See "Usage Notes" for information about how to determine an appropriate interval.
An REProxyRT object named proxyName or null, if the call fails
REProxyInitException
StringTooLargeException
There are several factors to consider when determining the cache size.
It takes experimentation to determine an optimum interval coupled with an appropriate cache size.
The interval determines how often the collected data is archived (flushed from the memory to RE schema). There are several factors to consider when determining the setting:
It takes experimentation to determine an optimum interval coupled with an appropriate cache size.
See Appendix A for examples of use.
Creates a new session for a visitor. A visitor is an end user unknown to this site or application (that is, a visitor is not a registered user of the site). The calling Web application may assign specific temporary IDs to these unregistered users in order to track them. This method is used by sessionful applications that keep track of session state for visitors. It is not required for sessionless Web applications.
OP maintains the mapping between appSessionID and visitorID. In subsequent calls, the calling application uses appSessionID to identify the visitor session.
createVisitorSession(String visitorID, String appSessionID)
Type String, the ID assigned by the calling Web application
Type String, the session ID assigned by the calling Web application
Throws an InvalidIDException if visitorID or appSessionID is null.
BadDBConnectionException
ErrorExecutingRE
REProxyInitException
StringTooLargeException
ConnectionPoolsIsFullException
createVisitorSession("101", "Session2");
OP has no way to tell if visitorID and appSessionID are valid values; it is the responsibility of the calling Web application to verify that these values are valid.
The calling Web application must provide session IDs that are unique among currently active sessions. If this method is invoked with a session ID that is currently active at the RE, an exception is thrown. However, a session ID can be reused as long as that session ID is not already active at the RE. appSessionID is synchronized to the MTR by OP. (For more information about data synchronization, see the administration guide.) If the calling application requires session IDs to be unique, it should check that they are unique at the MTR.
Returns cross-sell recommendations for a specified item from the items in the specified hot picks groups. It answers questions such as: Which N items from the specified hot picks groups are the user most likely to buy, assuming that the user buys the specified item?
crossSellForItemFromHotPicks (IdentificationData idData,
Item: item,
int numOfItems,
long[] hotPickGroups,
TuningSettings tunings,
FilteringSettings filters,
RecommendationContent recContent);
The item for which cross-sell recommendations are required
Type int, the number of items from the hot picks group to be returned. This number represents the maximum number of items to be returned; the actual number returned may be less.
Type long[], an array specifying the hot pick group IDs which identify the hot pick groups used to make recommendations
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use one of the following public methods to set these values: setItemFiltering(), setItemExclusion(), or setItemSubTreeFiltering(). For more information, see "FilteringSettings" in Chapter 2.
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The list of cross-sell recommendations (type RecommendationList).
Interpreting the recommendations depends on the value of personalization index:
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
BadDBConnectionException
ClassNotFoundException
ArrayTooLargeException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
Interest dimension must be the same as that of the data source type of the input item.
Data source type must be either navigational or purchasing. No other types are supported.
The following filtering setting cannot be used with this method:
Returns cross-sell recommendations for specified items from the items in a specified hot picks group. It answers questions such as: Which are the N items from the specified hot picks group is the user is likely to buy, assuming that the user buys at least one of the specified items?
crossSellForItemsFromHotPicks (IdentificationData idData,
Item:[] items,
int numOfItems,
long[] hotPickGroups,
TuningSettings tunings,
FilteringSettings filters,
RecommendationContent recContent);
The items for which cross-sell recommendations are required
Type int, the number of items from the hot picks group to be returned. This number represents the maximum number of items to be returned; the actual number returned may be less.
Type long[], an array specifying the hot pick groups from which to make recommendations
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use one of the following public methods to set these values: setItemFiltering(), setItemExclusion(), or setItemSubTreeFiltering(). For more information, see "FilteringSettings" in Chapter 2.
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The list of cross-sell recommendations (type RecommendationList).
Interpreting the recommendations depends on the value of personalization index:
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
ArrayTooLargeException
ConnectionPoolIsFullException
InvalidIDException
BadDBConnectionException
ClassNotFoundException
ErrorExecutingRE
ReProxyInitException
Interest dimension must be the same as that of the data source type of the input item.
Data source type must be either navigational or purchasing. No other types are supported.
The following filtering setting cannot be used with this method:
Destroy all REProxyRT objects in the pool of REProxyRT objects.
REProxyManager.destroyAllProxies();
None.
None.
None.
SeeAppendix A and the complete example in Appendix B for examples of use.
This method destroys all proxies in the pool. If you want to destroy one or more specific proxies, use destroyProxy().
Destroy the specified REProxyRT object in the pool of REProxyRT objects.
REProxyManager.destroyProxy(String proxyName);
Type String, the name of the REProxyRT object to be destroyed from the pool of REProxyRT objects
None.
None.
If you want to destroy all proxies in the pool, use destroyAllProxy().
Get an instance of the specified REProxyRT object.
REProxyManager.getProxy(String proxyName);
Type String, the name of the REProxyRT object instance
An instance of the named REProxyRT object or null if the specified object does not exist
REProxyInitException
See Appendix A and the complete example in Appendix B for examples of use.
Returns the degree of interest, computed along an interest dimension, for an item. The degree of interest could indicate, for example, the likelihood that customer X will buy item Y.
rateItem(IdentificationData idData,
Item item,
int taxonomyID,
TuningSettings tunings,
RecommendationContent recContent);
Type IdentificationData, identifies user or session
Type Item, identifies the item to be rated
Specifies settings to be applied when computing a recommendation; for details, see "TuningSettings" in Chapter 2
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The degree of interest (type Float).
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
Returns the degrees of interest, computed along an interest dimension, for an array of items. The ith degree of interest could indicate, for example, the likelihood that customer X will buy the ith item.
rateItems(IdentificationData idData,
Item[] items
int taxonomyID,
TuningSettings tunings,
RecommendationContent recContent);
Type IdentificationData, identifies user or session
The items to be rated, an array of Item
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The degrees of interest, an array of values of type Float.
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
ClassNotFoundException
Returns the degree of interest and other relevant item information for the numberOfItems items with the lowest degree of interest along the specified interest dimension. It answers questions such as: Which are the N items that person X is least likely to buy or like?
recommendBottomItems(IdentificationData idData,
int numberOfItems,
TuningSettings: tunings,
FilteringSettings: filters,
RecommendationContent recContent);
Type IdentificationData, identifies user or session.
Type int, the number of cross-sell recommendations to be returned. This number represents the maximum number of recommendations to be returned; the actual number returned may be less.
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use any of the "set" methods to set these values. For more information, see "FilteringSettings" in Chapter 2.
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
List of recommended items (type RecommendationList).
See "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
ClassNotFoundException
Returns the degree of interest and other relevant item information for the specified number of items most strongly associated with the target item in the argument list. It answers questions such as: Which are the N items a person is most likely to buy or be interested in, given that he bought or is interested in item Y?
recommendCrossSellForItem (IdentifactionData idData,
Item item,
int numberOfItems,,
TuningSettings tunings,
FilteringSettings filters,
RecommendationContent recContent);
Type IdentificationData, identifies user or session
The item for which cross-sell recommendations are required
Type int, the number of cross-sell recommendations to be returned. This number represents the maximum number of recommendations to be returned; the actual number returned may be less.
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use one of the following public methods to set these values: setItemFiltering(), setItemExclusion(), or setItemSubTreeFiltering(). For more information, see "FilteringSettings" in Chapter 2.
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The list of cross-sell recommendations (type RecommendationList ).
Interpreting the recommendations depends on the value of personalization index:
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
Interest dimension must be that same as that of the data source type.
Data source type must be either navigational or purchasing. No other types are supported.
The following filtering setting cannot be used with this method:
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
ClassNotFoundException
Returns the degree of interest and other relevant item information for the N items most strongly associated with the specified items. It answers questions such as: Which are the N items a person is most likely to buy or be interested in, given that he bought or is interested in items Y1, Y2,..., Yn?
recommendCrossSellForItems (IdentifactionData idData,
Item [] items,
int numberOfItems,,
TuningSettings tunings,
FilteringSettings filters,
RecommendationContent recContent);
Type IdentificationData, identifies user or session
The array of items for which cross-sell recommendations are required
The number of cross-sell recommendations to be returned. This number represents the maximum number of recommendations to be returned; the actual number returned may be less
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use one of the following public methods to set these values: setItemFiltering(), setItemExclusion(), or setItemSubTreeFiltering(). For more information, see "FilteringSettings" in Chapter 2.
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The list of cross-sell recommendations (type RecommendationList).
Interpreting the recommendations depends on the value of personalization index:
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ArrayTooLargeException
ReProxyInitException
ClassNotFoundException
Interest dimension must be that same as that of the data source type.
Data source type must be either navigational or purchasing. No other types are supported.
The following filtering setting cannot be used with this method:
Returns the degree of interest and other relevant item information for the N items with the highest degree of interest along the specified interest dimension. Items are selected from the hot picks table. It answers questions such as: Which are the N items from a particular set of Hot Picks group is the specified user most likely to buy or like?
recommendFromHotPicks(IdentificationData idData,
int numberOfItems,
long[} hotPickGroups,
TuningSettings: tunings,
FilteringSettings filters,
RecommendationContent recContent);
Type IdentificationData, identifies user or session
Type int, the number of items to be returned. This number represents the maximum number of items to be returned; the actual number returned may be less
Type long[], an array of hot pick group ID specifying the hot pick groups from which to make recommendations
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use one of the following public methods to set these values: setItemFiltering(), setItemExclusion(), or setItemSubTreeFiltering(). For more information, see "FilteringSettings" in Chapter 2.
Specifies the type of information that a recommendation request should return; for details, see "RecommendationContent" in Chapter 2
The list of recommended items (type RecommendationList).
Interpreting the recommendations depends on the value of personalization index:
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
ClassNotFoundException
Returns the degree of interest and other relevant item information for the numberOfItems items with the highest degree of interest along the specified interest dimension. It answers questions such as: Which are the N items that person X is most likely to buy/like?
recommendTopItems(IdentificationData, idData
int numberOfItems,
TuningSettings: tunings,
FilteringSettings: filters,
RecommendationContent recContent);
Type IdentificationData, identifies user or session
Type int, the number of items to be returned. This number represents the maximum number of items to be returned; the actual number returned may be less
Specifies tuning parameters for recommendation, including data source type, personalization index, profile data balance, and interest dimension. Note that interest dimension must be the same as the data source type of the input item. For more information, see "TuningSettings" in Chapter 2.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use any of the "set" methods to specify the values. For more information, see "FilteringSettings" in Chapter 2.
Specifies the type of information that a recommendation request should return; for details, see RecommendationContent in Chapter 2
The list of recommended items (type RecommendationList).
Interpreting the recommendations depends on the value of personalization index:
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
ClassNotFoundException
StringTooLargeException
Removes the item from the specified session or from the profile of the specified user. This method removes an item that has not been written to the MTR (permanent storage). Data is written to the MTR after the session is closed or times out.
removeItem(IdentificationData idData, DataItem item);
Identifies a user or a session; the specified item is removed from this user's profile or from this session
The item to be removed, of type DataItem
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
This method cannot be used to remove items from a user profile that has been written to permanent storage.
If a specified item is not in the user's profile, OP does nothing.
Removes the items from the specified session or from the profile of the specified user. This method removes items that have not been written to the MTR (permanent storage). Data is written to the MTR after the session is closed or times out.
removeItems(IdentificationData idData, DataItem[] items);
Identifies a user or session; the items specified by items are removed from this session or from this user's profile
The items to be removed, an array of type DataItem.
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
This method cannot be used to remove items from a user profile that has been written to permanent storage.
If a specified item is not in the user's profile, OP does nothing.
See Appendix A and the complete example in Appendix B for examples of use.
Selects the specified number of items from a specified set of hot picks group.
selectFromHotPicks (IdentificationData idData,
int numberOfItems ,
long[] hotPickGroups,
TuningSettings tunings,
FilteringSettings filters,
RecommendationContent recContent);
Identifies a user or session; the items specified by items are removed from this session or from this user's profile
Type int, the number of items to be returned. This number represents the maximum number of items to be returned; the actual number returned may be less
Type long[], an array specifying the hot pick groups from which to make recommendations
For release 1 of OP, an empty object must be passed here.
Specifies filtering parameters for the recommendations, including taxonomy ID, category filtering, category list (optional) and category membership. You can use of You can use any the "set" methods to set these values. For more information, see "FilteringSettings" in Chapter 2.
Specifies recommendation attributes and sorting; for details, see "RecommendationContent" in Chapter 2.
The list of selected items (type RecommendationList).
For more information, see "Meaning of Returned Value for Recommendations", earlier in this chapter.
NullParameterException
InvalidIDException
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
ClassNotFoundException
ArrayTooLargeException
Changes a visitor to a customer. This method is called when a visitor (unregistered user) registers during a session. This call associates the user ID with the customer ID generated by the Web application when the visitor becomes a registered customer. OP creates a new internal session for the customer. The session data for the visitor is transferred to the customer session. The historical data for the customer is also loaded to the customer session RE cache from permanent storage (MTR).
setVisitorToCustomer (IdentificationData idData, String customerID);
Identifies the visitor or the session
The string that the calling Web application uses to identify the registered user; this is the ID created when the visitor registers with the Web application
BadDBConnectionException
ConnectionPoolIsFullException
ErrorExecutingRE
ReProxyInitException
idData and customerID cannot be null.
|
 Copyright © 2001 Oracle Corporation. All Rights Reserved. |
|