Method and apparatus for an improved security system mechanism in a business applications management system platform

[00002] This application claims the benefit of U.S. Provisional Application No. 60/176,153 filed Jan. 14, 2000. This application is also related to the following utility applications which are filed on the same day as this application:

• • [00003] Ser. No. 09/760,068 Filed Jan. 12, 2001, titled “A method apparatus for a business applications management system platform;”
  • [00004] Ser. No. 09/759,856 Filed Jan. 12, 2001, titled “A method and apparatus for a web content platform;”
  • [00005] Ser. No. 09/759,497 Filed Jan. 12, 2001, titled “Method and apparatus for a Business Server;”
  • [00006] Ser. No. 09/760,432 Filed Jan. 12, 2001, titled “Method and apparatus for an information server;” and
  • [00007] Ser. No. 09/759,678 Filed Jan. 12, 2001, titled “A method and apparatus for Managing Information Exchange Among Systems in a Network.”

[00008] A portion of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

[00009] The present invention relates to the general field of computers, telecommunications, and computer and Internet related systems. More specifically, the invention relates to a computer security management system for managing security on a business application management platform.

[00010] Today software system developers are providing more efficient automated systems for managing the processing of information from multiple, inter-related applications, wherein the applications may be housed on disparate computer hardware platforms, in diverse locations, and have multiple domains. One concern in processing information from multiple, inter-related applications is security and data integrity.

[00011] Many computer hardware systems, including enhanced security versions of UNIX, permit access to files, etc to be controlled by associating with each file a list of the users (and/or groups of users) who are allowed to access the file, with the types of access permitted to each. This list is an example of a security list. For example, a file might have associated with it a security list indicating whether a user is permitted to read, write, or execute the file.

[00012] Similarly, computer systems running object-oriented software utilize a security list having an access control list that grants one or more privileges to one or more users on one or more objects. The security list also has a means for confirming that the particular active user has access rights to a particular object before permitting the user to access the object. However, the privilege granted by the security list only pertains to an object located in a particular domain. In order for a user to have the same privilege granted in a different domain, the user must be added to the security list within that domain. Thus prior art security systems require redundant inputs rendering them inefficient and difficult to mange by a global administrator.

[00013] Accordingly, there is a need in the art for an improved computer security management system for managing the applications housed on disparate hardware platforms in diverse locations. More specifically, there is a need for a computer security management system having a decentralized approach for managing security that allows a global administrator to define complex privileges containing a set of (privilege, object) pairs that are domain independent. The current invention provides these facilities in various new and novel ways as more fully described below.

[00014] The present invention presents an improved method and apparatus for an improved security system mechanism in a business applications management system platform that defines sets of allowed operations that groups of users can perform across multiple domains, thus minimizing user input effort. The security management system partitions a number of business objects into a number of hierarchical domains. A security list is then created and configured to grant a member the right to perform a security operation on the business object located within the hierarchical domain. The security list is created by adding the security operation to the security list, applying the security operation to one of the multiple domains, and adding members to the security list.

[00015] In one embodiment of the invention, a member is an individual user, associated with a generic role, and/or associated with an automated process.

[00016] In another embodiment of the invention, the right to perform said security operation is shared by more than one member.

[00017] In another embodiment of the invention, the security list is a global security list configured to apply across multiple hierarchical domains.

[00018] The present invention presents a computer security management system for managing security on a business application management platform. The security system includes a partitioning mechanism configured to partition multiple business objects into multiple hierarchical domains. The security system also includes a security list mechanism configured to create a security list. The security list mechanism includes a security operation which applies within a hierarchical domain. The security list mechanism also includes a member. The security list grants the member the right to perform the security operation within a hierarchical domain.

[00019] The present invention presents a computer-readable storage medium containing computer executable code for implementing a security management system for managing security on a business application management platform. The executable code instructs a computer to partition multiple business objects into multiple hierarchical domains. The executable code then instructs the computer to create a security list by adding the security operation to the security list, applying the security list to a hierarchical domain, and adding the member to the security list. The security list is configured to grant a member the right to perform the security operation within a hierarchical domain.

[00040] The present invention provides a solution to the needs described above through a system and method for integrating the disparate applications, and managing the applications processes in a hardware resource and user effort efficient manner. The automated system of the present invention uses a business systems platform architecture comprised of several unique servers in a base platform (the “Platform”) to efficiently manage multiple applications which may themselves generally be distributed across a network. The platform makes use of a collection of Core Services which provide additional security, internationalization services, and reporting services which are applicable to all applications. The Core Services are made available to a multitude of common business objects, which themselves are made available to various applications.

[00041] The present invention is a Business Applications Management System Platform Architecture (the “Platform” or alternatively the “SABA architecture”) which is designed to maintain and use a set of unique servers and common objects to generate the set of tasks required to be performed to complete a designated business transaction in a concrete, and useful way. In the preferred embodiment, the platform permits application developers to work on the business aspects of the application without having to focus on transaction management, security, persistence of data or life cycle management of the object itself. The servers and other aspects of the Platform are described in more detail below. However, a general overview of a preferred embodiment of the invention is first described.

[00042] (1) General Overview

[00043] The technology used as part of the system currently is, and will be, able to interface with many other industry standard software programs to make the exchange and flow of data easy and accurate.

[00044] The system is predominantly web-enabled, which extends its use to all industry professionals connected to the Internet. The Platform provides a unified set of interfaces, an application Framework, that encompass Business Object development, Web-application development, external connectivity development, and information distribution development.

[00045] The system is predominantly based on object-oriented programming principles as described in “Object-Oriented Software Construction” by Bertrand Meyer, Prentiss-Hall, 1988, ISBN 0-13-629049-3 and the Sun Microsystems™ developed JAVA™ systems described in the following publications:

• • [00046] Enterprise JavaBeans Specification, v1.1 (can be found at //java.sun.com/products/ejb/docs.html)
  • [00047] Enterprise JavaBeans, Richard Monson-Haefel, O'Reilly.
  • [00048] Enterprise JavaBeans: Developing Component-Based Distributed Applications, Tom Valesky, Addison-Wesley.
  • [00049] Enterprise JavaBeans Developer's Guide (Beta Version) at
  • [00050] //developerjava.sun.com/developer/earlyAccess/j2sdkee/doc-beta/guides/ejb/html/TOC.html
  • [00051] J2EE Application Programming Model (Beta Release), at //developerjava.sun.com/developer/earlyAccess/j2sdkee/download-docs.html

[00052] all of which are incorporated fully herein by reference. The system makes use of some third party modules which are described in more detail below also. The terminology as used and described in these references for object, class, inheritance, component, container, bean, JavaBean, EJB, etc., are well known in these arts and are used herein generally without definition except where a specific meaning is assigned to a term herein.

[00053] Overview of the Platform Architecture

[00054] The following describes an overview of the preferred embodiment of the SABA architecture, and includes:

• • [00055] A discussion of the system-level architecture and the modules that comprise the SABA system. This includes a high-level overview of each module, and lists the principle interfaces and functionality defined by each module.
  • [00056] A discussion of the application-level architecture, covering both the application-level architecture as exposed to different categories of users and some of the core business objects and their relationships.

[00057] Referring now to FIG. 5, in the preferred embodiment, Saba's architecture consists of four layers of APIs:

• • [00058] 1. The Platform layer 501 provides underlying infrastructure for enterprise applications, including standards-based functionality for persistence and distributed logic, application integration, content generation, and metadata queries.
  • [00059] 2. The Core Services layer 503 is a module that provides a set of common functionality for enterprise application. It includes services such as security, internationalization, and reporting.
  • [00060] 3. The Common Business Objects layer 505 is a module that defines a set of business objects shared across all SABA applications. It includes objects such as Party and Plan. Vertical applications may each also contribute a set of common business objects.
  • [00061] 4. The Applications layer 507 provides objects and services particular to a given application. There are multiple modules contained within the Applications layer, including modules for Learning 525, Content 527, Performance 529, and Sales & Marketing 531. The specific applications modules indicated are shown by way of example.

[00062] In the preferred embodiment, applicants have standardized their APIs around Session Bean Managers, interfaces that expose a common set of functionality. Each module therefore consists of several Session Bean interfaces. Thus, while SABA implements its managers using Entity Beans corresponding to persistent database objects, the interface as exposed to clients is solely that of the Managers.

[00063] This architecture also helps avoid circular dependencies by requiring that all dependencies be directed downwards. That is, a vertical application 507 may have dependencies on one or more sets of common business objects 505, but not on other applications. Similarly, common business objects 505 may depend on core services 503, and on other common business objects 505, but not on applications 507.

[00064] The Platform model 501 defines applicants' application platform, on top of which all additional business logic and functionality are implemented. Platform 501 provides the full set of standards-based services required for building modem enterprise applications.

[00065] Platform 501 consists of the following services:

• • [00066] BDK (Business Development Kit) Business applications server 519 is Saba's EJB compatibility layer. It extends the standard Java business component model with SABA-specific enhancements, such as improved security and caching, as well as providing an abstraction layer to improve portability between EJB servers. The BDK 519 defines the following base interfaces:
    • [00067] ISabaEntityBean—The abstraction of a persistent object
    • [00068] ISabaSessionBean—The abstraction of a transactional service
  • [00069] WDK (Web Development Kit) server 523 is Saba's web content generation engine. Using web standards for XML and XSL, it provides a customizable framework for decoupling data from presentation, and generating web content in a variety of formats, from standard HTML to WML. The WDK 523 provides the following base interfaces:
    • [00070] IWDKObject—An object capable of serializing itself as XML
  • [00071] Interconnect is Saba's application integration platform. Using XML and open standards for ERP integration, it provides a scalable and reliable solution for batch and period import, export, and monitoring. Interconnect defines the following base interfaces:
    • [00072] IAccessor—Service for exporting objects from SABA
    • [00073] IImporter—Service for importing objects into SABA
    • [00074] IMonitor—Service for monitoring object changes
  • [00075] Information Distributor Server 521 is applicants' query and delivery mechanism. Based on XML and RDF metadata standards, it defines a high-level query language and a set of agents for implementing information services. Interconnect provides the following services:
    • [00076] MetadataRepository—A datastore for querying metadata
    • [00077] ImportAgent—An agent for generating metadata
    • [00078] MatchAgent—An agent for locating metadata-based matches
    • [00079] DeliveryAgent—An agent for delivering match results

[00080] The Core Services module 503 provides the common business services needed by applicants' system. These services are not specific to any industry, such as learning; instead, they provide the support and functionality required by applicants to meet generic enterprise requirements.

[00081] Core Services consist of the following Session Managers:

• • [00082] AuditManager—Tracks changes to objects in the system. Can return a complete history of changes, including date, username, and reason.
  • [00083] BusinessRuleManager—Manage system business rules, that is, company policies defining the system's behavior in given situations.
  • [00084] ComponentManager—Manage installed business objects for naming and instantiation.
  • [00085] CurrencyManager—Manage currencies and exchange rates.
  • [00086] DataDictionaryManager—Manage metadata about business objects. This metadata is used to generate user interfaces, specify constraints, and define object behavior.
  • [00087] DomainManager—Manage domains. Domains are hierarchical groupings of business objects that can be used for a variety of purposes.
  • [00088] FinderManager—Create and invoke Finders. Finders provide a flexible mechanism for defining and executing database queries.
  • [00089] HandleManager—Centralize access to managers available to all business objects.
  • [00090] i18nManager—Manage internationalization. Track information about locales, languages, timezones, and display formats associated with business objects.
  • [00091] LicenseManager—Manage software licensing. Track installed modules, license keys, and version numbers.
  • [00092] LOVManager—Define lists of values.
  • [00093] NLevelHierarchyManager—Support for nested folders.
    • [00094] FolderManager
    • [00095] FolderElementManager
  • [00096] NoteManager—Define notes (long text attachments).
  • [00097] PreferenceManager—Set user preferences.
  • [00098] SecurityManager—Manage user privileges. Assign permitted operations on objects to users and groups.
  • [00099] ServiceHolderManager—Enable and disable common services (discussion, chat, etc.)
  • [00100] ReportManager—Create and execute reports. Reporting engines currently supported include Brio and Crystal Reports 7.
    • [00101] LetterManager—Generate form letters.
  • [00102] TaxManager—Calculate sales taxes.
  • [00103] NotificationManager—Manage notifications. Associate actions, such as sending an email or executing a Java method, with predefined system and periodic events.
  • [00104] ActionManager
    • [00105] AttachmentManager
    • [00106] EventManager
    • [00107] ParamManager
    • [00108] RecepientManager
    • [00109] TextBlockManager
  • [00110] UserManager—Manage user preferences and allow users to switch between roles.

[00111] The Common Business Objects module 505 defines the set of business abstractions that are shared across more than one vertical application. These objects may be either generic business concepts, such as a Party, or shared concepts specific to Saba's application domain, such as Calendar.

[00112] Common Business Objects 505 comprise the following Session Managers:

• • [00113] AccountabilityManager—Used to manage a variety of relationships, such as reporting and organization membership, between entities in the system
  • [00114] CalendarManager—Manage calendars and schedules.
    • [00115] CorporateCalendarManager
    • [00116] PersonalCalendarManager
    • [00117] SfaCalendarManager
    • [00118] SfaCalendarOwnerManager
    • [00119] CheckListItemManager
  • [00120] PartyManager—Manage entities within a business. Includes employees, clients, companies, departments, and business units.
  • [00121] LocationManager—Manage locations, including addresses and contact information.
  • [00122] RoleManager—Manage a function/job type within the value chain.
  • [00123] PlanManager—Manage plans, that is, proposed course of actions.
  • [00124] ProfileManager—Manage profiles, that is, comprehensive histories, goals, and plans for entities within a business.
  • [00125] ValueChainManager—Manage value chain relationships between entities in an extended organization.

[00126] The exemplary Learning module 525 within the Applications layer 507 defines the services used to build learning management systems. It provides APIs for defining learning offerings, which include classes, courses, on-line learning, and physical inventory, registering for and consuming learning, and tracking transcripts, certifications, and other results of learning.

[00127] The following Learning Session Managers are delivered as part of Common Business Objects 505:

• • [00128] CatalogManager—Browse a learning catalog.
  • [00129] OfferingTemplateManager—The core abstraction of a learning intervention.

[00130] The following Learning Session Managers are only available with the Learning application:

• • [00131] CertificationManager—Track certifications.
    • [00132] CertificationActionManager
    • [00133] CertificationCompetencyManager
    • [00134] HeldCertificationManager
  • [00135] LearningManager—Manage learning offerings. Extends the concept of offering templates to include managing delivery types and delivery modes, offering instances, audience types, and offering modes.
    • [00136] AudienceTypeManager
    • [00137] DeliveryManager
    • [00138] DeliveryModeManager
    • [00139] EquivalentManager—Defines equivalent offering templates.
    • [00140] OfferingActionManager
    • [00141] OfferingManager
    • [00142] OfferingPolicyManager
    • [00143] OfferingTemplateDeliveryManager
    • [00144] ProductGroupManager
    • [00145] RosterManager
    • [00146] PrerequisiteManager
  • [00147] LearningResourceManager—Manage resources used by classes, such as classrooms, faculty, and equipment.
    • [00148] InventoryManager
    • [00149] QualifiedInstructorManager
  • [00150] RegistrarManager—Request and order a learning resource. Includes shipping and registration information.
    • [00151] CourseRequestManager
    • [00152] PackageOrderManager
    • [00153] PricingManager
  • [00154] RegistrationManager—Track completion and grading of learning offerings

[00155] The Content module 527 within the Applications layer 507 defines the services used for all forms on on-line learning. It includes creating and launching WBT and VOD courseware, virtual classrooms, testing and assessment, community services, and analysis and tracking.

[00156] The following Content Session Manager is delivered as part of Common Business Objects:

• • [00157] ContentHolderManager—Allows any business object to be a content holder
  • [00158] CourseContentManager—Associate content such as attachments and exams with learning offerings.

[00159] The following Content Session Managers are only available with the Content application:

• • [00160] ContentManager—Manage learning content.
    • [00161] TestManager
  • [00162] AnalysisManager—Analyze test results.
  • [00163] CommunityManager—Create and manage learning communities.

[00164] The Performance module 529 within the Applications layer 507 defines the services available for managing human performance. It includes competencies and goals.

[00165] The following Performance Session Managers are delivered as part of Common Business Objects:

• • [00166] CompetencyManager—Assign competencies to roles, entities, and learning resources. Includes
    • [00167] CompetencyHolderManager
    • [00168] CompetencyProviderManager
  • [00169] OfferingCompetencyManager—Associate competencies with offering templates and find learning interventions that provide competencies.

[00170] The following Performance Session Managers are only available with the Performance application:

• • [00171] Advanced competency definition, manipulation, and analysis, including:
    • [00172] CompetencyAnalysisManager
    • [00173] CompetencyGroupManager
    • [00174] CompetencyMethodManager
    • [00175] CompetencyModelManager
  • [00176] GoalManager—Manage and track goals. Includes assigning goals and observations on goals.
    • [00177] GoalLibraryManager
    • [00178] GoalObservationManager
    • [00179] GoalStateManager

[00180] The Sales and Marketing module 531 within the Applications layer 507 defines the services available for the running the finances and logistics of a learning content provider. It includes the purchase of learning resources and tools for managing sales and marketing campaigns.

[00181] The following Sales and Marketing Session Managers are delivered as part of Common Business Objects:

• • [00182] OrderManager—Generate orders. Includes invoicing and shipping options.
  • [00183] PurchaseManager—Track the pricing of learning resources. Includes getting and setting prices and managing price lists.

[00184] The following Sales and Marketing Session Managers are only available with the Sales and Marketing application:

• • [00185] AccountManager—Manage client accounts.
  • [00186] Advanced order management, including:
    • [00187] TrainingUnitManager
    • [00188] PurchaseOrderManager
  • [00189] MarketingManager—Manage marketing campaigns.
    • [00190] RoyaltyInfoManager
    • [00191] ShipperManager
  • [00192] SalesMktManager—Order a learning resource. Similar functionality to RegistrarManager, but designed for use in a call center to fulfill external orders.
  • [00193] TargetMarketManager—Manage target markets and associate them with offering templates.
  • [00194] TerritoryManager—Manage territories.

[00195] Applications Architecture

[00196] An exemplary version of an application architecture which can make use of applicants' invention could consist of four distinct applications that interoperate to provide a complete Human Capital Development and Management solution. Each of these applications is based around a core set of metadata; the applicants' architecture's value lies in the effective management of this metadata. The diagram in FIG. 6 describes this core metadata and how it is employed by different types of users in this exemplary implementation of this architecture. Those skilled in the art will recognize that this architecture can be used with various other kinds of applications systems, such as: financial product sales & marketing systems; retail store management systems; various kinds of maintenance & repair management & dispatch systems; etc.

[00197] Referring now to FIG. 6, SABA Learning manages Catalog Metadata 609 that describes a set of available learning interventions and Profile Metadata 611 that describes a learner in the system, including learning history and enrollments.

[00198] SABA Performance manages Profile Metadata 611 that describes individual and group goals, competencies, and development plans. Together, the Profile Metadata 611 in Learning 607 and Performance 605 provide a complete description of the human capital in an extended organization.

[00199] SABA Information 603 and SABA Content 601 manage metadata about a variety of on-line resources. SABA Information 603 uses this metadata to construct information services targeted to individual's information needs, whereas SABA Content 601 uses this metadata to manage learning content throughout its lifecycle and construct intelligent, reusable Learning Objects.

[00200] Users work with this metadata as follows:

• • [00201] Individual learners 619 query Learning Metadata (that is, the learning catalog) 609 to locate appropriate learning interventions. The system uses Learning Object Metadata 613 to deliver and track learning interventions and updates the Profile Metadata 611 as appropriate.
  • [00202] Team managers 621 work with Profile Metadata 611 to define, update, and track progress towards goals. They can analyze the metadata to identify problem areas and generate plans for meeting their goals.
  • [00203] Learning providers 617 use import and administration tools to create and update Catalog 609 and Learning Object Metadata 613.

[00204] One of the principal tasks users perform in such a system is finding performance interventions—resources and services that can be applied to improve human capital performance. The diagram in FIG. 7 details the business objects that support this process and their relationships.

[00205] There are multiple, complementary mechanisms for identifying interventions.

[00206] Competency gap analysis can be applied to either an individual's goals 713 or roles 715. The analysis compares the required competencies for reaching a goal 713 or filling a role 715 (either held or targeted) to actual held competencies and generates a competency gap 721. Learning interventions (offerings 723) that fill the competency gap 721 are the identified. A variety of other intervention types are planned, including information 733 and community services 735.

[00207] Certification gap 719 analysis compares a role's certification requirements associated to the actual learning profile of the individual in the role. It then identifies the quickest certification track to completion and recommends appropriate learning offerings 723 from the catalog.

[00208] Having described an exemplary application we now describe the invention in additional context.

[00209] In a preferred embodiment, the Platform can support both Application and Business component development, as well as integration with development tools, connectivity to external systems (import/export/exchange), and information delivery. The architecture of the present invention adopts a three-tier model and is shown in the diagram in FIG. 3. In FIG. 3 a tier 1 web user 301 is connected electronically to a tier 2 web server 305 which is connected to a tier 3 applications server 307. Also in Tier 1 a dedicated user 311 may be directly connected to a tier 3 applications server 307. And the tier 3 applications server 307 may be connected to a database management system 309.

[00210] Referring now to FIG. 4, the tier 3 applications server 307 is expanded in FIG. 4 to illustrate the Business Applications Platform 415 of the present invention. In FIG. 4, the Platform contains an Interface Server 417, an Information Server 419, an Interconnect Server 423 and a Business Server 421. All of these Servers 417, 419, 421 and 423 may physically reside on the same hardware platform (such as a UNIX box or a Microsoft™ NT™ platform), or each server may reside on a separate hardware box, or any combination of servers and hardware boxes. Each of the servers may have included a JAVA Virtual Machine™ and the related runtime support. The electronic communications between these servers may use the XML protocol (409, 425, 427) with each server having services for translating XML into the particular Applications Programming Interface (API) language required by the server and for translating its internal language into XML prior to transmission to another server. In a preferred embodiment, all of these servers are contained in a single tier 3 platform, and may communicate with each other directly without the necessity of changing the interfacing protocol format. The Interface Server 417 (also alternatively designated herein as the WDK), communicates through a web server 405 via the internet 403 to web clients 401 via the HTML protocol. The Interface Server 417, also may communicate to a directly connected client 407 via other protocols such as XSL/XSLT etc., and may communicate to Personal Data Assistants 411 such as cell phones or Palm Pilots™ or other such wireless devices using wireless protocols such as WAP/WML, etc. The Interface Server 417, contains mechanisms to manipulate various kinds of display style sheets, to generate and execute web links, to manage dynamic content generation and dynamic generation of Javascript, all of which is described in more detail below in the section on the Interface Server/WDK 417.

[00211] These servers and related facilities and others are described in more detail below.

[00212] The environment in which the present invention is used encompasses the use of general purpose computers as client or input machines for use by business users of various kinds, including clerks, managers, teachers, and/or systems administrators. Such client or input machines may be coupled to the Internet (sometimes referred to as the “Web”) through telecommunications channels which may include wireless devices and systems as well.

[00213] Some of the elements of a typical Internet network configuration are shown in FIG. 1, wherein a number of client machines 105 possibly in a branch office of a large enterprise, a manufacturer, a financial enterprise, etc., are shown connected to a Gateway/hub/tunnel-server/etc. 106 which is itself connected to the internet 107 via some internet service provider (ISP) connection 108. Also shown are other possible clients 101, 103 possibly used by other application systems users, or interested parties, similarly connected to the internet 107 via an ISP connection 104, with these units communicating to possibly a home office via an ISP connection 109 to a gateway/tunnel-server 110 which is connected 111 to various enterprise application servers 112, 113, 114 which could be connected through another hub/router 115 to various local clients 116, 117, 118. Any of these servers 112, 113, 114 could function as a server of the present invention, as more fully described below. Any user situated at any of these client machines would normally have to be an authorized user of the system as described more fully below.

[00214] An embodiment of the Business Applications Platform System of the present invention can operate on a general purpose computer unit which typically includes generally the elements shown in FIG. 2. The general purpose system 201 includes a motherboard 203 having thereon an input/output (“I/O”) section 205, one or more central processing units (“CPU”) 207, and a memory section 209 which may or may not have a flash memory card 211 related to it. The I/O section 205 is connected to a keyboard 226, other similar general purpose computer units 225, 215, a disk storage unit 223 and a CD-ROM drive unit 217. The CD-ROM drive unit 217 can read a CD-ROM medium 219 which typically contains programs 221 and other data. Such programmed computers may also be connected electronically to database systems such as those available from Oracle™, Sybase™, Informix™, SQLServer from Microsoft™ and the like. Logic circuits or other components of these programmed computers will perform series of specifically identified operations dictated by computer programs as described more fully below.

[00215] Detailed System Description

[00216] The Platform system of the present invention is now described in more detail. In general a preferred embodiment with a presently known best mode for making and using the system is described. Alternative embodiments are similarly described for various parts of the Platform system.

[00217] Business Applications Server/BDK

[00218] Preferred Embodiment

[00219] The following description of the BDK Business application server covers the presently preferred embodiment and the presently known best mode for making and using it. This section is followed by a further description of an alternative embodiment which may include features in addition to or in place of those in the preferred embodiment.

[00220] 1. Overview

[00221] The Business Development Kit applications server (BDK) component of the Platform provides a supporting framework for business objects. A business object is a Java object with persistent state that represents some entity in a business application, such as an employee or company.

[00222] Specifically, the BDK provides a persistence framework for saving and restoring object state and a set of core services for performing a variety of useful operations on business objects.

[00223] 2. Persistence Framework

[00224] The persistence framework defines a common code path used to create new objects, restore and update existing objects, delete objects, and find objects. The code path consists of a set of Java code and database stored procedures to construct and verify object data and SQL commands to save and restore information using a relational database.

[00225] The persistence framework is highly flexible because it is metadata-driven. For each class of object, the system provides a set of metadata—data about data—that defines the class' properties and behavior. This means that the data used to determine the behavior and characteristics of specific classes and instances of business objects is stored as distinct, editable information, rather than being hard-coded into the logic of the system. The persistence code itself is part of the metadata, that is, the SQL commands for save, restore, etc. are stored as metadata, not in source code. As an example benefit, it makes applications much easier to port between databases because only the metadata for the SQL needs to be changed; no source code needs to be changed and recompiled.

[00226] Use of metadata allows the system to be configured and otherwise modified by different clients for different deployments, resulting in unique runtime behavior of the system. Object properties that can be customized range from the labels used to display object information, to the type of data validation performed, to the amount of custom information associated with each object.

[00227] A unique feature of the persistence framework is its support for an arbitrary amount of custom information, stored in what is known as “custom fields.” Experience has shown that predefined business objects typically do not express the full set of data a given customer may wish to track, and that this data varies from customer to customer. Custom fields provide a way for different customers to uniquely extend the data stored with a class of business objects. In the current implementation, customers are provided with a set of five “custom fields” that can be searched, and an unlimited number of “extended custom fields” that cannot be searched, but provide additional data validation for date and numeric values. Again, the code to save and restore custom fields is all driven off metadata.

[00228] As an example of the persistence framework's operation, a user of the system may attempt to create a new employee by specifying the employee's first and last name, social security number, starting salary, and date of birth. The persistence framework performs the following operations to save this data as a new “SabaPerson” business object:

• • [00229] Uses metadata settings about the “first name”, “last name”, “ssn”, and “birth date” properties of a “SabaPerson” to determine the data validation to perform. In this case, the metadata settings may instruct the framework to verify that values are provided for first name, last name, and ssn, that starting salary is greater than a fixed numeric minimum wage value, and that birth date is a valid date.
  • [00230] Uses metadata to obtain and execute a database stored procedure named “tpp_person_ins” that takes values for first name, last name, ssn, salary, and birth date as parameters and inserts these values into a database table named “tpt_person.”

[00231] 2a. The Meta-Data Store

[00232] In the preferred embodiment the meta-data store contains the definition of each type of object in the system, its attributes, and some basic properties of those attributes. Further, for each type of object, it contains a reference to the methods to invoke, to insert, update, delete or fetch a given instance of that object from the persistent store.

[00233] The Metadata store consists of the following tables:

[00002]

	1. fgt_dd_class

[00234] Every business object in the system is registered in this table. This table also describes basic properties of objects.

[00235] fgt_dd_class has the following columns:

[00002]

Column Name	Type	Rq?	Description
Id	Char (20)	The identifier of the object.
Ui_name	Varchar2 (255)	This is the display name of
		the object and generally
		used to paint UI as well.
Description	Varchar2 (255)	Meaningful description of
		the object and its function.
Enumber	int	Unique number for each
		object.
Insert_spid	Int	Method call for inserting a
		new instance of the object.
		Foreign key to mesg_id
		column of fgt_mesg_table.
Update_spid	Int	Method call for updating an
		existing instance of the
		object. Foreign key to
		mesg_id column of
		fgt_mesg_table.
Delete_spid	Int	Method call for deleting an
		instance of the object.
		Foreign key to mesg_id
		column of fgt_mesg_table.
Sel_det_spid	Int	Method call for retrieving
		an instance of the object
		based on its id. Foreign key
		to mesg_id column of
		fgt_mesg_table.
Finder_id	Int	Finder Id for invoking a
		default finder associated
		with the object.
Fixed_attr_ct	Int	Total count of the fixed
		attributes for the object.
Attr_ct	Int	Total count of the attributes
		for the object. This number
		is sum of all fixed and all
		custom attributes.
Flags	Char (10)	Ten bit string describes the
		behavior of the object.
		1st bit = Object can be
		displayed in the security
		screen for granting privs.
		2nd bit = This 2bit mask is
		set to see if reports or
		letters or both can be
		attached.
		3rd bit = Obsolete.
		4th bit = Obsolete.
		5th bit = If the object is
		owned in nature and cannot
		exist without its owner.
		6th bit = Obsolete
		7th bit = If object can be
		customized bu end user.
		8th bit = If Object can have
		Extensible attributes of its
		own.
next_attr_enum	Int	Enumber to use for the next
		custom attribute that will be
		added to the object. The
		install time value for this
		attribute is 10,000.
Prefix	char (5)	This 5letter long string is
		used in generating Ids for
		the object. This string is
		prepended to the number
		generated by the sequence.
Table_name	Varchar2 (25)	This is the name where the
		object is stored. The
		sequence, methods are also
		named based on this.
Domain_enum	Int	This is denormalized data
		and shows the enumber of
		the Domain attribute.
Java_class_name	Varchar2 (255)	The java class name of the
		object.
Hlevel	Int	The level of the object in
		the object hierarchy.
Parent_id	Char (20)	In case of hierarchical
		object's it stores the parent
		object's id

[00236] As an example, the following are the values for a class of business object representing domains:

[00002]

id	ui_name	description	enumber	insert_spid
ddcls000000	Domain	Hierarchal	195	10560
000001095		Domain
update_spid	delete_spid	sel_det_spid	finder_id	fixed_attr_ct
10562	10561	10563	15710	14
attr_ct	flags	next_attr_enu	prefix	table_name
		m
14	1100001100	100000	domin	fgt_domain
	domain_enum	java_class_name	hlevel	parent_id
		com.saba.busobj.Sa	1
		baDomain

[00237] 2. fgt_dd_attr

[00238] The attributes of each class of business object is stored in this table. This table also describes basic properties of each attribute.

[00239] fgt_dd_attr has the following columns:

[00002]

Colunn Name	Type	Rq?	Description
Id	Char (20)	Y	Unique identifier for an
			attribute.
Cid	OBJECTID	Y	The object id, this
			attribute belongs to
Enumber	Int	Y	Required to be unique within
			a class. The code should use
			these numbers to refer to
			attributes rather than using
			the ID. Fixed enumbers are
			assigned in the range 1000-
			9999. Extensible attributes
			are allocated from 10,000
			onwards. The next_attr_enum
			in the corresponding object
			record stores the next
			enumber available for this
			class.
Col_name	Varchar (255)	Y	The column name in which the
			value of this attribute is
			stored.
Ui_name	Varchar (255)	Y	The name of the attribute,
			which is used for painting
			the UI.
description	Varchar (255)	N	Description of the
			attribute.
Attr_type	Int	Y	The number corresponds to
			the data type of the
			attribute.
list_of_vals	OBJECTID	N	If the attribute val. is
			selected from a list of
			values, then the id of the
			list is stored here.
min_val	Int	N	If its a numeric column,
			then the min allowable value
			if any.
max_val	Int	N	If its a numeric column,
			then the max allowable value
			if any.
default_val	STR	N	Default value to use for the
			attribute when an instance
			of the object is created.
str_1	STR	N	This generation formula for
			those attributes whose
			values have to be generated
			on the creation of the
			object. The generation is
			driven by the generation bit
			in the flag.
Flags	varchar (15)	Y	1st bit => The required
			bit.
			2nd bit => Reference bit is
			set if attribute points to
			another object.
			3rd bit => LOV bit is set
			if its values must come from
			fixed list of values.
			4th bit => This two bit
			mask describes the type of
			the attribute.
			5th bit => Id bit is set if
			its an Id column.
			6th bit => Generation bit
			is set if the value need to
			be generated during the
			creation of an object.
			7th bit => Customization
			bit. This 4bit mask says if
			label, required or
			generation can be customized
			by end user.
			8th bit => Audit bit.
			9thbit => Obsolete
			10th bit => Obsolete
			11th bit => This bit
			describes the type of the
			custom attribute.
			12th bit => Domain bit is set
			if the attribute is domain
			id.
			13th bit => set if Default
			value can be changed by
			user.
			14th bit => set if Minimum
			value can be changed by
			user.
			15th bit => set if Maximum
			value can be changed by
			user.

[00240] As an example, the following are some of the attributes defined for the domain business object:

[00002]

id	cid	enumber	col_name	ui_name	attr_type	flags
ddatr000	ddcls0	1000	id	ID	8	100011000
0000000	00000					000000
02991	00000
	1095
ddatr000	ddcls0	1001	time—	Time	4	100000000
0000000	00000		stamp	Stamp		000000
02992	00000
	1095
ddatr000	ddcls0	1002	name	Domain	4	100000100
0000000	00000			Name		000100
02993	00000
	1095
ddatr000	ddcls0	1003	description	Description	7	000000300
0000000	00000					000100
02994	00000
	1095
ddatr000	ddcls0	1004	custom0	custom0	7	000100300
0000000	00000					010100
02995	00000
	1095

[00241] 3. fgt_mesg_table

[00242] This table stores the actual SQL code used for object persistence. In the case of insert, update, and delete methods, typically these are calls to stored procedures containing additional business logic in addition to database calls. Long SQL statements are stored in multiple rows, which are then reconstructed on-the-fly by the persistence layer.

[00243] fgt_mesg_table has the following columns:

[00002]

Column Name	Type	Rq?	Description
Mesg_id	Int	Y	This is the message id for
			the SQL statement group.
Mesg_seq	Int	Y	Since the SQL statements can
			be greater than 255 chars
			which is the length of the
			mesg_text columns. This
			column tells the sequence of
			this SQL statement in the
			group.
Mesg_text	Varchar (255)	Y	The text of message.

[00244] As an example, the following are persistence calls for the domain business object. Note from the sample data above that 10563 is the code for retrieving an object, 10560 for inserting an object, and 10562 for updating an object.

[00002]

mesg_id	mesg_seq	mesg_text
10563	1	select d.id id, d.time_stamp ts, d.name
		dname, d.description descr, d.custom0 c0,
		d.custom1 c1, d.custom2 c2, d.custom3 c3,
		d.custom4 c4, d.created_on cron, d.created_by
		crby, d.updated_on upon, d.upd
10563	2	ated_by upby, d.parent_id pid, parent.name
		parent from fgt_domain d, fgt_domain parent
		where d.id = @001 and d.parent_id =
		parent.id(+)
10560	1	begin fgp_domain_ins (@001, @002, @003,
		@004, @005, @006, @007, @008, @009,
		@010, @011, @012, @013, @014, @015); end;
10562	1	begin fgp_domain_upd (@001, @002, @003,
		@004, @005, @006, @007, @008, @009,
		@010, @011, @012, @013, @014, @015); end;

[00245] Notice that the SQL references the actual table used to store domain data, fgt_domain (described in detail in the section on security).

[00002]

	The fgp_domain_ins stored procedure is PL/SQL code defined as:
	create or replace procedure fgp_domain_ins
	(
	xid	char,
	xtime_stamp	varchar2,
	xname	varchar2,
	xdescription	varchar2,
	xcustom0	varchar2,
	xcustom1	varchar2,
	xcustom2	varchar2,
	xcustom3	varchar2,
	xcustom4	varchar2,
	xcreated_on	date,
	xcreated_by	varchar2,
	xupdated_on	date,
	xupdated_by	varchar2,
	xparent_id	char,
	xnewts	varchar2
	)
	as
	begin
/* validating that the parent of a node is not
itself */
if (xid = xparent_id) then
raise_application_error(−20698, ′ ′);
return;
end if;
/* parent_id cannot be null except for the root */
if (xid <> ′domin000000000000001′ and xparent_id is
null) then
raise_application_error(−20699, ′ ′);
return;
end if;
insert into fgt_domain (
id, time_stamp, name, ci_name, description,
custom0, custom1,
custom2, custom3, custom4, created_on,
created_by, updated_on,
updated_by, parent_id)
values (
xid, xnewts, xname, lower(xname),
xdescription, xcustom0, xcustom1,
xcustom2, xcustom3, xcustom4, sysdate,
xcreated_by, sysdate,
xupdated_by, xparent_id);
/* update the denormalized flat tree table */
tpp_flat_tree_relation(195, xid, null, null, 0);
/* inherit a snapshot of the custom fields for all
objects */
insert into fgt_dd_domain_to_attr
(ID, TIME_STAMP, DOMAIN_ID, ATTR_ID,
FLAGS, LOCAL_FLAGS, UI_NAME, MIN_VAL,
MAX_VAL, DEFAULT_VAL, LIST_OF_VALS,
GEN_MASK)
select ‘ddoat’ | |
lpad(ltrim(rtrim(to_char(fgt_dd_domain_to_attr_seq.nextval))), 15,
‘0’),
xnewts, xid, ATTR_ID, FLAGS, LOCAL_FLAGS,
UI_NAME, MIN_VAL,
MAX_VAL, DEFAULT_VAL,
LIST_OF_VALS, GEN_MASK
from	fgt_dd_domain_to_attr
where	domain_id = xparent_id;
end;

[00246] 2b. Persistence Algorithms

[00247] In a preferred embodiment all business objects that Saba's Application server manipulates are derived from a single base class called SabaObject. The SabaObject class provides save, restore, and delete capabilities by implementing the persistence layer architecture. All subclasses of SabaObject then inherit this behavior and rarely if ever override it.

• • [00248] Every SabaObject is expected to know which class it belongs to, and how that class is registered in the meta-data store. Thus each subclass of SabaObject stores a class identifier so that it can tell the system which entry in the meta-data store it corresponds to.
  • [00249] Every SabaObject also stores a state flag that determines whether this is a new object, or it is an object that already exists in the data store. This state then determines whether the object invokes an insert method or an update method during a save( ) invocation.
  • [00250] Every SabaObject has an unchangeable, unique identifier that identifies that particular object in the persistence store. The uniqueness of this identifier is guaranteed across the entire persistence store regardless of the type of object.
    The algorithm for save is then as follows:
  • [00252] Look up the entry for the class of the object in the meta-data store.
  • [00253] If the class is not found, raise an error “Unknown Class”.
  • [00254] If (State=new)
  • [00255] M=look up the method to call for inserting the object.

[00256] Else/*State=update*/

• • [00257] M=look up the method to call for updating the object
  • [00258] Marshall all the attributes of the SabaObject into the appropriate data structure.
  • [00259] Check each of the attributes against the rules set for its nullity, constraints. If any of the constraints are violated, throw an error.
  • [00260] Lead the default values wherever necessary.
  • [00261] Invoke M with that data structure. (1)

[00262] For deletion, the basic process is identical, except that the invocation of the delete method only requires the unique identifier of the SabaObject to be passed in as its only argument.

[00263] For restore, the algorithm is just slightly different and is as follows:

• • [00264] Look up the entry for the class of the object in the meta-data store.
  • [00265] If the class is not found, raise an error “Unknown Class”.
  • [00266] M=look up the method to call for fetching the object.
  • [00267] Invoke M(unique ID of SabaObject)
  • [00268] Unmarshall all the attributes returned by M. (2)

[00269] In the presently preferred embodiment, the method invocation currently only supports invocation of database stored procedures although in alternative embodiments this will be extended to other types of persistence mechanisms.

[00270] These stored procedures provide the actual intelligence of taking the marshaled arguments that come in, and storing them in specific fields in the database, and vice versa. Thus a combination of the meta-data store and the stored procedures create an abstraction layer that allows the base SabaObject to store all objects through a simple, uniform algorithm.

[00271] The persistence mechanism thus created allows the transfer of various kinds of objects to database storage as shown below.

[00272] Individual messages are retrieved using a SQL command of the form:

[00002]

select mesg_id, mesg_seq, mesg_text from fgt_mesg_table
where mesg_id = ? order by mesg_id, mesg_seq

[00273] Query results are transformed into actual SQL code using the following method:

[00002]

	private static String processMessage(ResultSet rSet)
	throws Exception, SabaException
	{
	StringBuffer buf;
	String str;
	buf = new StringBuffer(rSet.getString(kMsgTextCol));
	while (rSet.next( ) != false)
	{
	String temp = rSet.getString(kMsgTextCol);
	buf.append(temp);
	}
	str = buf.toString( );
	return str;
	}
	}

[00274] Retrieved messages are also stored in a local cache for improved performance.

[00275] 2c. Configurable Custom Fields

[00276] In the preferred embodiment, the Saba persistence mechanism provides built-in support for configurable, runtime definable, custom fields for any object.

[00277] The basic mechanism is extremely simple. An administrative user interface is provided by which the meta-data definition of a given class can be extended by adding (or removing) custom attributes as needed. For each custom attribute, the user only needs to provide some very basic information about the type of the field, whether or not it is required, constraining minimum and maximum values for numeric fields, and a constraining list if the field is to be validated against a list of possible values.

[00278] The SabaObject implementation then simply picks up these fields during its normal marshalling and unmarshalling of arguments. Further, the SabaObject also performs the basic checks for nullity as it would normally do.

[00279] To save and restore the custom fields, the actual algorithms are extended from the ones shown earlier. In the case of insert or update the following additional lines are called after the line marked (1) in the algorithm shown earlier:

• • [00280] After invoking the basic method M
  • [00281] Marshall all custom field data into the appropriate data structure
  • [00282] Invoke the insert/update method for storing the custom data structure.

[00283] In the case of restore, the following lines are added to the original algorithm after the line marked (2):

• • [00284] Invoke the custom field fetch
  • [00285] Unmarshall all custom field data and update the relevant fields in the SabaObject.

[00286] The actual storage where the custom field data for any given instance is stored, consists of a single table as defined below. All the custom field data is stored as tag-value pairs in typed columns.

[00287] Fgt_dd_custom

[00288] This common table provides the storage area for all data stored in the extended custom fields for a given object.

[00002]

Column Name	Type	Rq?	Description
Id	OBJECTID	Y
owner_id	OBJECTID	Y	Which object this custom
			field is for.
attr_id	OBJECTID	Y	Refer to the attribute
			for which value is
			stored.
attr_type	INT	Y	Type of the custom field.
			This matches the attr_type in
			the fgt_dd_attr table and is
			a denormalization of the
			same.
Num_value	Number	N	Value is stored here if it is
			Numeric type
Str_value	Varchar (255)	N	Value is stored here if
			it is String type
Date_value	Date	N	Value is stored here if it is
			Date type

[00289] 3 Core Services

[00290] BDK also provides a set of core services to perform useful operations on business objects. Some of these services include:

• • [00291] Security. BDK provides extremely fine-grained security control to control whether specific users have privileges to perform operations such as creating or viewing a particular class of business object. The system is unique in that it provides a flexible model of security roles and security lists to assign a set of privileges to distinct groups of users, and it employs a scalable notion of domains to differentiate among sets of business objects. The security model is explained in detail in a separate section below.
  • [00292] Auditing. BDK provides the ability to track the history of all changes to an object, including the date of a change, the identity of the user making the change, and a justification for the change.
  • [00293] Internationalization (i18n). BDK provides utilities for allowing business objects to be internationalized. Internationalization is a standardized process wherein message content, money amounts, dates and various other culture specific data are kept in separate files in order to permit an easy change from one countries language and cultural rules to another. This comprises both storing values of business objects in multiple languages and supporting multiple formats for date, currency, and other data types that vary among countries.
  • [00294] Concurrency. BDK provides concurrency services for controlling overlapping write operations on multiple instances of an object, while permitting multiple reads at the same time. This is achieved via comparison of an instance-specific timestamp when committing of an object's state to the persistent store is requested. The timestamp is updated whenever the state of an object is altered and the object is successfully committed to persistent storage.
  • [00295] Transaction Management. BDK provides two types of transactional services: procedural and declarative. In the former case, a developer explicitly marks the beginning and end of a unit-of-work using BDK's API. In the latter case, a developer can associate a transactional attribute with a method, and the BDK's Transaction Monitor keeps track of initiating and terminating transactions, as well as executing a method within the scope of an on-going transaction, based on run-time context.
  • [00296] Logging. BDK provides logging functionality that can be used for capturing system state and operations in one or more logs.
  • [00297] Notification. BDK provides the ability to send notifications, such as emails or faxes, to predefined categories of users when the state of identified business objects changes. For example, everyone subscribed to a class may receive a page if the class is cancelled.
  • [00298] Business Rules. In a preferred embodiment, for example, Saba's learning application provides a set of pre-defined business rules that affect the workflow and behavior of various business objects in the system. The BDK provides a mechanism to enable and disable these business rules. For example, a customer can configure whether a manager's approval is required to register for a class. Similar business rules can be handled for other types of applications.
  • [00299] Notes. BDK provides the ability to associate arbitrary, free-form text, or “notes,” with any business object in the system.

[00300] 4 Application Programming Interfaces

[00301] In the preferred embodiment, the BDK exposes Application Programming Interfaces (APIs) for use in programming the system. A variety of APIs with equivalent functionality are supported on top of the persistence framework. The system supports both propriety and industry-standard forms of Java API, as well as XML-based APIs.

[00302] a. SabaObject API

[00303] One Java API is a proprietary “SabaObject” interface to a business object. A SabaObject is a Java class defining a set of operations common to all business objects, including the ability to get and set properties using a variety of data types and the ability to save and restore an object's state. Specific business object classes can subclass SabaObject to add functionality and business logic appropriate to that class.

[00304] The Java interface for SabaObject is the following:

[00002]

	public class SabaObject {
	/**
	* SabaObject Constructor
	* Creates a new empty Saba object in the context of the
	given session.
	*/
	public SabaObject(String sessionKey);
	/* methods to set attribute values as different datatypes
	*/
	public void setAttrVal(String attrName, Boolean attrVal);
	public void setAttrVal(String attrName, Timestamp
	attrVal);
	public void setAttrVal(String attrName, Integer attrVal);
	public void setAttrVal(String attrName, BigDecimal
	attrVal);
	public void setAttrVal(String attrName, String attrVal);
	public void setAttrVal(String attrName, Object attrVal);
	/* methods to restore attribute values as different
	datatypes */
	public String getAttrVal(String attrName);
	public String getStringAttrVal(String attrName);
	public Integer getIntegerAttrVal(String attrName);
	public Timestamp getTimestampAttrVal(String attrName);
	public BigDecimal getBigDecimalAttrVal(String attrName);
	public Boolean getBooleanAttrVal(String attrName);
	/**
	* Gets a hashtable of the attribute values.
	*/
	public Hashtable getAttributeValues( );
	/**
	* Returns the display label for the named attribute
	*/
	public String getAttributeLabel(String attrName);
	/* save, restore, and delete methods */
	public void save( );
	public void save(SabaTransaction tr);
	public void restore( );
	public void restore(SabaTransaction tr);
	public void delete( );
	}

[00305] In the preferred embodiment, as part of a business object's creation, the business object author provides four SQL statements corresponding to selection, deletion, insertion, and updating of the object. Pointers to these statements are provided as part of the metadata for the object as stored in fgt_dd_class. The first two (selection and deletion) types of statements take a single bind variable, namely, the id of the object. The other two take the id as well as all other attribute values in the order declared in the metadata for that object's attributes in the table fgt_dd_attr. The order of retrieval of attributes in the selection statement must also match such order.

[00306] Upon receiving a request to create an in-memory representation of an object through the “restore( )” method, BDK retrieves the selection statement for that class of objects, binds the variable to the id of the object that is desired to be restored, executes the statement, and fills in an instance-specific hashtable of attribute-value pairs with the values so retrieved. In addition, a standard SQL statement is executed to retrieve the value of extended custom attributes, and the results are again inserted in the aforementioned hashtable. For the “restore(SabaTransaction tr)” variant of this operation, the execution of these SQL statements is done using the database connection contained in tr, the transaction argument. When executing the “delete( )” method, the object is marked for deletion. Upon a subsequent call to “save( )” or “save(SabaTransaction tr),” BDK checks for the state of the object. If it is an object that has been marked for deletion, the deletion SQL statement as supplied by the business object author is executed after binding the id, using the database connection in the transaction argument for the “save(SabaTransaction tr)” case. Other possibilities upon execution of the save operation are that the object instance is new, or it is an altered state of an existing object. In these cases, the statements corresponding to insertion and updating are executed, respectively, after the replacing the bind variables with attribute values from the hashtable in the order specified in metadata. In the case of insertion, BDK automatically generates a unique id for the object that is reflected both in the persistent storage and the in-memory representation.

[00307] Implementation of the setAttrVal( ) and get<type>AttrVal( ) involve setting and accessing values in the hashtable, respectively, using the provided attribute name as the key. getAttributeValues( ) returns a copy of the object's hashtable whereas getAttributeLabel( ) looks up the attributes' metadata and returns the label corresponding to the chosen attribute.

[00308] 4b. SabaEntityBean API

[00309] Another Java API is based on the industry-standard Enterprise JavaBean (EJB) model. This model has a notion of “entity beans” that provide the interface to specific business objects. Accordingly, the persistence framework provides a EJB-based abstract class, “SabaEntityBean” that implements the javax.ejb.EntityBean interface. The SabaEntityBean class provides default implementations of the following methods: ejbActivate( ), ejbPassivate( ), ejbRemove( ), setEntityContext( ), ejbCreate( ), ejbLoad( ), ejbStore( ), and unsetEntityContext( ). Implementations of the ejbLoad( ), ejbStore( ), ejbCreate, and ejbRemove( ) methods rely on the selection, update, insertion, and deletion statements declared as part of metadata (please refer to the discussion of the implementation of SabaObject's API). Other methods are implemented as empty stubs that can be overridden by a developer if desired.

[00310] In addition to defining the bean class, to implement an EJB one also needs to define a corresponding remote interface, a home interface, and, for entity beans, a primary key class. The remote interface is the external world's view of the bean and is comprised of the business methods that the bean wishes to expose. The getters and setters for the bean's attributes are also exposed through the remote interface. The home interface declares the life-cycle methods, such as those for creating, removing, or finding beans.

[00311] In the preferred embodiment, the BDK provides two interfaces, ISabaRemote and ISabaHome, which a bean can extend for defining remote and home interfaces, respectively. The ISabaRemote interface extends the standard EJB interface EJBObject and provides the following sets of methods:

• • [00312] void setCustomAttrVal(String attr, <type> value), and
  • [00313] <type> getCustomAttrVal(String attr)

[00314] for Boolean, Timestamp, String, Integer, Float, and Double data types. The ISabaHome interface provides a layer of abstraction over the standard EJB interface EJBHome. The BDK also defines a class SabaPrimaryKey (a thin wrapper around the String class) which can be used by entity beans for defining primary keys.

[00315] 4c. Session Manager APIs

[00316] The EJB model also has a notion of “session beans,” higher-level interfaces that represent business processes. In the preferred embodiment, the BDK has standardized on the use of session bean-based interfaces as its public API; these interfaces are known as “session bean managers,” and are implemented using the lower-level entity bean APIs provided by the persistence layer. The BDK provides a SabaSessionBean base class that defines common session bean manager functionality, and a framework for several categories of “helper classes”—additional interfaces used in conjunction with specific session bean managers:

• • [00317] Detail—represent immutable detail information about a specific business object
  • [00318] Handle—represent opaque references to a business object
  • [00319] Primitive—represent commonly used data structures, such as addresses and full names

[00320] 4d. XML Interfaces

[00321] In the preferred embodiment, the BDK also provides XML-based interfaces for saving and retrieving business objects; these interfaces provide the communication layer with the other Platform servers and components.

[00322] One XML format is known as “Saba Canonical Format” (SCF). It is an XML serialization of the data in a SabaObject. The Interconnect server system reads and writes SCF to implement the AccessorReader and ImporterWriter for the native Saba system; refer to the Interconnect server section for more details.

[00323] An example fragment of an SCF document, representing a business object defining a specific currency, is:

[00002]

	<SabaObject type=“com.saba.busobj.SabaCurrency”
	id=“crncy000000000000001” status=“existing”>
	<name dt:type=“string”>US Dollars</name>
	<time_stamp
	dt:type=“string”>199812161647032900</time_stamp>
	<short_name dt:type=“string” >USD</short_name>
	<flags dt:type=“string”>1100000000</flags>
	</SabaObject>

[00324] In the preferred embodiment, another XML interface is the “IXMLObject” interface. An IXMLObject is a Java object capable of serializing itself into an XML representation. The detail, handle, and primitive helper objects used by session bean managers all implement this interface. The WDK server system uses these objects to generate dynamic web content by invoking the session bean manager APIs, then serializing the resulting objects into XML; refer to the WDK section for more details.

[00325] The IXMLObject interface conforms to the “Visitor” design pattern, and is defined as follows:

[00002]

public interface IXMLObject {
/**
* Accept a visitor. An implementation should ask the
Visitor to visit each of its public elements (i.e., fields or
properties).
*
* @param visitor The XML Visitor object
*/
public void acceptXMLVisitor(IXMLVisitor visitor) throws
XMLVisitorException;
/**
* Get the preferred tag name for this object.
* @return the tag name to identify
*/
public String getTagName( );
}

[00326] Note: a “visitor” object is one which has processes which represent an operation to be performed on the elements of an object structure. A visitor lets one define a new operation without changing the classes of the elements on which it operates. Visitor objects and their operation and use are described in more detail at pages 331-344 of Design Patterns, by Gamma, Helm, Johnson, & Vlissides, Addison-Wesley 1995, ISBN 0-201-63361-2 which are hereby fully incorporated herein by reference. Those skilled in these arts will recognize that various other implementations of these algorithms and concepts may be developed without departing from the spirit and functionality of this invention. Additional background information can be found in

[00327] Enterprise JavaBeans Specification, v1.1 (can be found at url=java.sun.com/products/ejb/docs.html), and in other sections of the book titled

[00328] Design Patterns, by Gamma, Helm, Johnson, & Vlissides, Addison-Wesley 1995, ISBN 0-201-63361-2 which are hereby fully incorporated herein by reference.

[00329] Alternative Embodiment

[00330] An alternative embodiment of the BDK business applications server may be described as follows, using the context of how a developer and user would use this portion of the system. In an alternative embodiment, the developer's use is outlined in the context of a BDK development kit which would be provided by Applicants for use in developing applications which can run on the Platform and by way of indicating some details unique to the Platform through a description of a use of the Business Development Kit.

[00331] In the alternative embodiment, the Business Server embodies a development kit framework which provides a set of interfaces and classes in the form of Java packages, identifies certain services that developers can rely on, and defines an application development model. The framework relies extensively on the server-side component model espoused by Java, namely Enterprise JavaBeans (EJB) components. Selection of EJBs as the server-side component model is driven in part by the requirements of reliance on open standards and backward compatibility. Using EJBs also enables integration with other Java 2 Enterprise Edition (J2EE) technologies such as Java ServerPages (JSP) and servlets that one would intend to use for web applications development. Furthermore, a number of EJB-enabled application servers available in the marketplace could be used to deploy the components so developed.

[00332] In the alternative embodiment, the development kit classes and interfaces, the services, and the application development model are discussed in greater detail in the next three subsections.

[00333] Classes and Interfaces

[00334] The BDK interfaces and classes address the following needs.

• [00335] 1. Provide an additional layer of abstraction (by writing wrappers around base Java classes) to provide a richer level of functionality needed by SABA applications and to allow future modifications with minimal impact on the client application code.
• [00336] 2. Expedite component development by providing default implementations (that can be overridden) of certain required interfaces in EJB.
• [00337] 3. Define certain interfaces that must be implemented by classes used for specific purposes (an example is that a class must implement a certain interface if its instances are used in a JSP page).
• [00338] 4. Define certain classes that are necessary to provide basic services, such as data partitioning and logging, as well as utility classes for expedited application development.
• [00339] 5. To the extent possible, eliminate application server dependencies in areas where the EJB Specification is currently not vendor independent.

[00340] In the alternative embodiment, the following discussion of is background for a discussion of the usage and types of EJBs within the context of the development kit described in more detail below.

[00341] Metadata Support

[00342] In the alternative embodiment, one of the facilities provided by the development framework is that characteristics of business objects can be varied across deployment. For example, for an attribute, one can optionally specify whether it has a required attribute, the list of values (LOVs) that the attribute can assume, its default value, and its minimum and maximum values. The values can be different across installations, as different customers have different requirements. To achieve this flexibility, metadata about the business objects and their attributes is captured in the system.

[00343] In the alternative embodiment, some of the metadata that is currently captured about a class or an attribute could be dynamically determined using the Java reflection API. Examples include the parent ID and attribute count for business objects and attribute type for an attribute. The Java reflection API provides classes Class and Field that can be used to retrieve such information. Furthermore, instead of building a hashtable-based infrastructure for storing and retrieving attribute values, one can use methods like set and get in the Field class to operate directly on the attributes, which are declared as member variables of the class.

[00344] The classes Class and Field by themselves, however, may not provide the rich functionality needed by certain applications. For instance, there is no way to indicate minimum and maximum values of an attribute in the Field class. Thus, what is needed is to create new classes that provide wrappers around Class and Field and capture the additional information. In the interest of consistency with previously used names while avoiding conflicts at the same time, two new classes may be used: SabaPlatformClass (inherits from Class) and SabaPlatformAttribute (inherits from Field). In addition to the functionality provided by Class (e.g., for getting parent class), SabaPlatformClass provides for such additional functionality as domain-based attributes and getting fixed vs. extended custom attribute counts. Similarly, SabaPlatformAttribute provides functionality for LOVs, default value, and minimum and maximum values. (As we will discuss later, the classes SabaPlatformClass and SabaPlatformAttribute themselves are beans—or, entity beans to be more specific—in this alternative embodiment system.)

[00345] The classes SabaPlatformClass and SabaPlatformAttribute will not be used directly by users of business components (though developers of such components will use them). Typically, the user of these classes will be a class SabaPlatformObject. In some instances, SabaPlatformObject will make use of the functionality provided by these classes as part of an operation (e.g., when setting the value of an attribute, SabaPlatformObject will use SabaPlatformAttribute to determine the minimum and maximum value constraints). In other cases, SabaPlatformObject will delegate an operation directly to one of these classes (an example would be retrieving the superclass of an object). SabaPlatformObject implements a set of methods for getting and setting attribute values that provide a centralized point for capturing the logic for such things as auditing and constraint checking, and are used by subclasses of SabaPlatformObject.

[00346] In this alternative embodiment, a component user will not interact directly with even SabaPlatformObject. Instead, the component user will deal with a specialization of either a SabaEntityBean or a SabaSessionBean, which are discussed in the next subsection.

[00347] Beans

[00348] In the alternative embodiment, components based on Enterprise JavaBeans (EJBs) will be a basic building block for developing applications using the BDK. Below we provide a brief overview of EJBs. Those skilled in these arts will understand that various books and documents on the “java.sun.com” web site provide additional details on this subject. There are two types of EJBs:

• • [00349] 1. Entity Beans, and
  • [00350] 2. Session Beans.

[00351] Entity beans are used for modeling business data and behavior whereas session beans are used for modeling business processes. Examples of entity beans could be SabaClass (a training class, not a Java class), SabaPerson, and SabaRegistration. Entity beans typically would map to objects (tables) in the persistent data store. Behaviors associated with an entity bean typically would relate to changing the data in the bean.

[00352] An example of a session bean could be SabaRegistrar, which uses the entity beans mentioned above and encapsulates the business logic associated with certain tasks, such as registering for a class. Session beans are not persistent, though changes in data of certain entity beans or their creation or removal could result from the actions of a session bean. A session bean can be stateful or stateless. A stateful session bean maintains state information specific to the client using it, such that results of invocation of a method may depend upon the methods invoked earlier on the bean. (An example of a stateful session bean would be SabaShoppingCart, which would keep track of items in an order as they are being added, to be followed by either placement of the order or clearing of the cart.) This is typically done by storing client-specific data in instance variables of a bean, which are then used by the methods to accomplish their task. A stateless session bean does not maintain any state specific to a client. An example of a stateless session bean would be SabaTaxCalculator, which provides methods for computation of sales and other taxes.

[00353] In the alternative embodiment the development kit would provide two abstract base classes: SabaEntityBean and SabaSessionBean. (Whether a session bean is stateful or stateless is indicated in something called a deployment descriptor.) These classes implement the javax.ejb.EntityBean and javax.ejb.SessionBean interfaces, respectively. The intent is to provide a default implementation of certain required methods to enable rapid development of components, yet allow a component to override the default implementation of the methods it chooses. The SabaEntityBean class provides default implementations of the following methods: ejbActivate( ), ejbPassivate( ), ejbRemove( ), setEntityContext( ), ejbCreate( ), ejbLoad( ), ejbStore( ), and unsetEntityContext( ). Implementation of the ejbRemove( ) and ejbCreate( ) are discussed in the next subsection. The other methods in the list by default have an empty implementation. The SabaSessionBean class provides default (empty) implementations of the first four methods in the preceding list. SabaEntityBean inherits from SabaPlatformObject and provides attributes common to all the entity beans, (such as namespace) and has a method toXML( ) that ensures that all entity beans will provide an implementation for serializing their data to an XML representation. In other words, SabaEntityBean implements an interface ISabaXMLRenderable (explained later) and provides two convenience methods: findUsingRQL (String rql) and findUsingRQLURI (String URI) to locate specific entity beans using RQL.

[00354] In addition to defining the bean class, to implement an EJB one also needs to define a corresponding remote interface, a home interface, and, for entity beans, a primary key class. The remote interface is the external world's view of the bean and is comprised of the business methods that the bean wishes to expose. The getters and setters for the bean's attributes are also exposed through the remote interface. A developer must implement these methods by calling the getAttrVal( ) and setAttrVal( ) methods available in SabaPlatformObject to take advantage of services like constraint checking and auditing. The home interface declares the life-cycle methods, such as those for creating, removing, or finding beans.

[00355] The development kit provides two interfaces ISabaRemote and ISabaHome, which a bean can extend for defining remote and home interfaces, respectively. The ISabaRemote interface extends the standard EJB interface EJBObject and provides the following sets of methods:

[00002]

	●	void setCustomAttrVal(String attr, <type>
		value), and
	●	<type> getCustomAttrVal(String attr)

[00356] for Boolean, Timestamp, String, Integer, Float, and Double data types. The ISabaHome interface provides a layer of abstraction over the standard EJB interface EJBHome. The BDK also defines a class SabaPrimaryKey (a thin wrapper around the String class) which can be used by entity beans for defining primary keys.

[00357] One final interface defined in the BDK for EJBs is ISabaXMLRenderable. This interface extends the java.io.Serializable interface and defines a single method, toXML( ). Only classes that implement this interface are eligible to act as return types of methods that are going to be invoked from a Java ServerPage.

[00358] In the alternative embodiment the BDK would come with a few prepackaged beans. One is a stateless session bean named SabaPlatformLogin that can be used to authenticate a user. Another is an entity bean named SabaNameSpace, which encapsulates characteristics of a namespace, including its place in the hierarchy and the list of users who have access to entity beans in that namespace. The namespace is used for data partitioning and security purposes.

[00359] Relationships

[00360] Another area in which the BDK provides support is relationships amongst entity beans. In an object model, relationships between different classes are arranged in four categories: inheritance, association, composition, and aggregation. During implementation, the inheritance relationship is captured by extending a subclass from a superclass. The other three types of relationships entail constraints between the classes being related. For instance, a composition relationship implies commonality of life span (i.e., destroying the “whole” should result in destruction of the “components”) and an association relationship implies referential integrity constraints (i.e., creating an instance of a class which refers to a non-existent interface of another class is not permitted). In an alternative embodiment, such relationships can be captured through constraints in the database.

[00361] In the alternative embodiment, the BDK will provide a SabaRelationship class, that has attributes for the name of relationship, the type of relationship, the source class and attribute, and the destination class and attribute. The SabaRelationship class will encapsulate lifetime management constraints implicit in each of the different types of relationships. Thus, if an object is being removed and it is declared to have compositional relationship with some other objects, the SabaRelationship class will ensure the removal of the related objects. Similarly, when creating an object, the SabaRelationship class will ensure that referential integrity constraints are being satisfied. The SabaEntityBean class will delegate calls to the SabaRelationship class within its ejbRemove( ) and ejbCreate( ) methods. Any implementation that a component developer provides for these methods for a specific bean would have to call super. ejbRemove( ) or super.ejbCreate( ) as appropriate.

[00362] In the alternative embodiment, an attribute capturing the list of relationships (where each item in the list is of type SabaRelationship) will be defined in the SabaEntityBean class. By default (i.e., at SabaEntityBean level), the list will be defined to be empty. When component developers create an entity bean by extending SabaEntityBean, they will be able to declaratively specify relationships between the bean being created and the other beans in the system. Additional relationships may be added to existing beans too when a new bean is created.

[00363] In the alternative embodiment, besides lifetime management, the declared relationships could also be used for navigational purposes within the object model. As an example, consider a situation where the SabaRegistration bean is related to the SabaClass bean, which in turn is related to the SabaLocation bean. One would like to be able to retrieve attributes of the location (say, the map) of the class, given a registration. A new class, SabaCompositeRelationship will allow one to compose navigational paths in terms of basic SabaRelationship objects. Then, given a source object and the name (or id) of a composite relationship, the SabaCompositeRelationship class will be able to fetch the destination object(s).

[00364] Vendor-Specific Wrappers

[00365] In the alternative embodiment, when some areas within the J2EE specifications are still not standardized and are left up to individual vendors for implementation, additional facilities will be needed. To prevent vendor-specific implementation details from migrating into SABA code, the BDK would provide a class SabaJ2EEVendor that provides a wrapper around vendor-specific implementations. SabaJ2EEVendor provides static methods that can be used to perform activities in a vendor-neutral fashion in SABA code. An example method in SabaJ2EEVendor is getInitialContext( ), which encapsulates the logic for getting an initial context (at present, the mechanism for this is vendor-dependent). To use a particular vendor's implementation of J2EE specifications, one will have to provide implementations of the methods in this class. By default, the BDK will provide implementations of this class for a few selected J2EE servers.

[00366] Miscellaneous Classes

[00367] In an alternative embodiment, in addition to the foregoing, the BDK also provides the following utility classes that can be useful for developing components: SabaProperties, DateUtil, FormatUtil, LocaleUtil, SystemUtil, and Timer. Also, the following exception classes are supported: SabaException, SabaSecurityException, SabaFatal-Exception, AttributeNotFoundException, and SabaRelationshipViolationException. For logging purposes, the BDK provides a SabaLog class and for debugging purposes, the BDK provides a SabaDebug class. The functionality provided by the foregoing classes is similar to that available currently.

[00368] The use of the various classes and interfaces discussed in this section is described in the “Application Development Model” section.

[00369] Services

[00370] A number of services are required by application developers to develop robust, flexible, and scalable systems. A number of these services are provided by the commercially available application servers that host the EJB components. In the following paragraphs we discuss the various services that an application developer can rely on and how these services might be used.

[00371] Distributed Components

[00372] One of the key ingredients for building scalable systems is the ability to distribute components. In the EJB model, different beans can be deployed on different computers transparently. Separation of interfaces from the implementation enables automated generation of stubs and skeletons that hide the details of network communications. A client application (or a bean that relies on another bean) (Subsequent references to a client application should be interpreted to be inclusive of beans that rely on other beans) uses a naming service to first locate the bean and then interact with it, thus making no assumptions about location of any given component.

[00373] Naming

[00374] As alluded to in the previous paragraph, before using a bean, it must first be located. All EJB application servers are required to provide Java Naming and Directory Service (JNDI) access for bean users. To use JNDI, a client application would typically first get an “initial context” (driven by properties such as where to find the EJB server, somewhat analogous to the JDBC connect string for locating a database), and then using the context, look up the home interface of the bean by its name. Using the home interface, the client can find a specific instance of a bean, create a new instance, or remove an instance. The naming service would be used and the interaction would be the same even if the bean instance is present locally (i.e., exists in the same Java Virtual Machine) instead of being deployed on a remote machine.

[00375] The JNDI naming mechanism also obviates the need for the SabaClassRegistry mechanism that is used at present. The client application looks for a bean by a name (say, Authentication). Any bean class that provides the implementation of the remote and home interfaces can be deployed against that name in the application server. Thus, at one installation, the default bean class SabaPlatformLogin can be deployed with a name of Authentication, whereas at some other installation, the bean class SabaLDAPLogin can be deployed with the same external name to use a different authentication logic.

[00376] Persistence

[00377] One of the benefits of using EJBs is that component developers do not have to worry about persistence of data, as the container hosting the (entity) beans can manage such persistence. Automatic persistence service provided by the application server enhances the productivity of bean developers, is more efficient at runtime, and allows the bean's definition to be independent of the type of data store used for persistence (e.g., a relational database or an object-oriented database). A component developer will be responsible for declaring part or all of the attributes of an entity bean as persistent in its deployment descriptor, and then mapping them to fields in a database at deployment time. The interface and mechanism of such mapping would depend upon the application server being used.

[00378] The bean is automatically saved to the persistent store when it is created by a client application using the create( ) method, and when the container decides to synchronize the bean's state with the database if the bean's data has been changed by the client application. The container's decision is based on such factors as transactions, concurrency, and resource management. The container will remove the data from persistent store when the remove( ) method is called by a client on an entity bean.

[00379] Concurrency

[00380] A component developer does not have to worry about concurrent access to an entity bean from multiple transactions (such as from several client applications). It is the responsibility of the container hosting the bean to ensure synchronization for entity objects. Indeed, use of the keyword synchronized is prohibited by the EJB Specification. Concurrent access for session beans is not meaningful, since by definition an instance of a stateful session bean can be used by only one client and stateless session beans do not maintain any data that needs to be shared.

[00381] Transactions

[00382] For transactions, an application developer has two options: 1) to explicitly demarcate the boundaries of a transaction, or 2) to use declarative transactional management available with EJBs. Use of declarative transactional management is cleaner and is strongly recommended. In this case, the level of granularity for managing transactions corresponds to methods in a bean. Instead of interleaving transaction boundaries within business logic, transactional attributes are separately declared in the bean's deployment descriptor (for a specific method, or as the bean's default) as one of the following six options: TX_NOT_SUPPORTED, TX_SUPPORTS, TX_REQUIRED, TX_REQUIRES_NEW, TX_MANDATORY, TX_BEAN_MANAGED. Details of these can be found in books on EJB.

[00383] Security

[00384] As discussed earlier, application developers can use a stateless session bean, SabaPlatformLogin, to authenticate a user. In the deployment descriptor for every bean, access control entries are defined which list the identities (users or roles) that are allowed to invoke a specific method (alternatively, an access control list can act as the default for all the methods in a bean). According to EJB Specification, each client application accessing an EJB object must have an associated java.security.Identity object (generally associated at login time). The general Security system used in the present invention was discussed in more detail above.

[00385] Read/Write/Arbitrary Privileges

[00386] Search

[00387] To locate an instance of an entity bean, each entity bean provides a method findByPrimaryKey( ) in its home interface. In addition, other finder methods (which must be named in accordance with the pattern find<criterion>) can also be provided. With container-managed persistence, the container generates the implementations of such methods automatically at deployment time. The mapping of finder methods to the database is vendor-dependent at present, though a standardized syntax for the same is a goal of EJB 2.0 Specification effort. In the meantime, a developer can implement the finder methods in terms of findUsingRQL( ) and findUsingRQLURI( ) methods available in SabaEntityBean.

[00388] Logging & Debugging

[00389] A component may be used by multiple applications in an interleaving fashion.

[00390] An application could have components distributed over multiple computers—how to assemble a unified log—use a “log server” bean—heavy performance price, impacts debugging class too.

[00391] Turning on and off debugging on a component basis. Mechanics of how to do it without having runtime checks every time a method in Debug is called. What if one app wants a component to turn debugging on whereas another wants to turn it off.

[00392] Application Development Model

[00393] In the alternative embodiment, to develop an application using the BDK, an object model of the application domain should be first developed, retaining a separation between objects that represent business processes and those that represent business data. The two types of objects, obviously, map to session beans and entity beans in EJB parlance. A controller object, for instance, would indicate a session bean whereas an object that persists its data would indicate an entity bean. An application would typically also include UI components (such as JSP pages or servlets) which would use such business components. Thus, there are two primary roles from an application development standpoint:

• • [00394] 1. component developer, and
  • [00395] 2. component user.

[00396] It is possible that an individual may play both the roles. Indeed, a component developer may need to rely on another component, and thus be a user as well as a developer. We will first look at the role of a component developer in the next subsection, and then look at the responsibilities of the component user. Finally, we will look at how an application can be packaged in this alternative embodiment.

[00397] Component Developer

[00398] To create a component, a developer needs to perform the following steps.

• • [00399] 1. Define the remote interface of the component.
  • [00400] 2. Define the home interface of the component.
  • [00401] 3. Define the bean class.
  • [00402] 4. Create the deployment descriptor of the component.

[00403] As an example, one will build a simple SabaPerson component. SabaPerson is a container-managed entity bean useful for explaining some basic concepts in EJBs and the BDK framework. One then illustrates issues surrounding business logic coding, transactions, and persistence in a question-answer format. Note that for simplicity's sake, package, import, try/catch/finally, etc., statements are not included in the following code segments.

[00404] The Remote Interface

[00002]

public interface SabaPerson extends ISabaRemote {
public String getFullName( ) throws RMIException;
public String getFirstName( ) throws RMIException;
public String getLastName( ) throws RMIException;
public void setFirstName(String name) throws
RMIException;
public void setLastName(String name) throws RMIException;
}

[00405] The remote interface provides the business methods or the world's view of the component. In our case, we have a single method that a client can use to get the person's full name. Also recall that ISabaRemote already declares setAttrVal( ) and getAttrVal( ) methods for manipulating the attribute values (such as fName and lName declared in the bean class), so they don't need to be declared again.

[00406] The Home Interface

[00002]

public interface SabaPersonHome extends ISabaHome {
public SabaPersonEJB findByPrimaryKey(SabaPrimaryKey id)
throws FinderException, RMIException;
public Collection findByName(String fName, String lName)
throws FinderException, RMIException;
public SabaPersonEJB create(String fName, String lName)
throws CreateException, RMIException;
}

[00407] For container-managed beans, the container automatically provides an implementation of the findByPrimaryKey( ) method and generates the code for other finders (such as findByName( )) from an external description, which pending EJB 2.0 Specification, is vendor-specific.

[00408] The Bean Class

[00002]

	public class SabaPersonEJB extends SabaEntityBean {
	public  String id;
	public String fName;
	public String lName;
	public String getFullName( ) throws RMIException
	{
	return (fName + lName);
	}
	public String getFirstName( ) throws RMIException
	{
	return (String) getAttrVal (“fName”);
	}
	public void setFirstName(String name) throws RMIException
	{
	setAttrVal (“fName”, name);
	}
	. . .
	public void ejbCreate(String fName, String lName)
	{
	this.id = IDGenerator.getNewID( );
	this.fName = fName;
	this.lName = lName;
	}
	public void ejbPostCreate(String fName, String lName)
	{
	// No action needs to be taken.
	}
	}

[00409] The bean class provides implementations for the business methods declared in the remote interface. Note that the fields in the bean class are declared to be public. The EJB Specification require this for container-managed persistent fields. Furthermore, this is also required by the setAttrVal( ) and getAttrVal( ) methods for fields that should be accessible via this methods (the methods use reflection to locate the fields). The consequences of such visibility are limited, however, because the user of a bean only interact with the bean through the home and remote interfaces. It is not possible for a client to directly assign values to or retrieve values from such public fields without going through the accessor and mutator methods defined in the remote interface.

[00410] For each different signature of create( ) method in the home interface, corresponding ejbCreate( ) and ejbPostCreate( ) methods need to be defined in the bean class. The code for the bean class is consistent with this requirement.

[00411] The Deployment Descriptor

[00412] In EJB Specification v1.1 (which can be found at the java.sun.com web site), the deployment descriptor is an XML file that declares such things as container-managed persistent fields and security and transactional characteristics of the bean and its methods. The following example shows part of a deployment descriptor.

[00002]

	<entity>
	<description>
	This is part of the deployment descriptor of the
	SabaPerson entity
	bean.
	</description>
	<ejb-name>SabaPerson</ejb-name>
	<home>com.saba.examples.SabaPersonHome</home>
	<remote> . . . </remote>
	<ejb-class> . . . </ ejb-class >
	<prim-key-class> . . . </ prim-key-class >
	<persistence-type>Container</persistence-type>
	<cmp-field>id</cmp-field>
	<cmp-field>fName</cmp-field>
	<cmp-field>lName</cmp-field>
	.
	.
	.
	<container-transaction>
	<method>
	<ejb-name>SabaPerson</ejb-name>
	<method-name>*</method-name>
	</method>
	<trans-attribute>Supported</trans-attribute>
	</container-transaction>
	</entity>

[00413] In EJB Specification 1.0, the deployment descriptor is a text file with a somewhat different format. The deployment descriptor is generally created using a GUI tool, generally supplied by EJB Server vendors. Additional information on deployment descriptors can be obtained from EJB literature and tool manuals.

[00414] Depending upon the kind of business logic, there are different ways of encoding business logic in EJBs. Of course, implementation of the methods declared in the remote interface of a session bean or an entity bean encodes business logic. In addition, EJB provides “hooks” or callback methods for implementing additional types of business logic. We have already seen the ejbCreate( ) and ejbPostCreate( ) methods that one can use in a manner analogous to insert triggers in a relational database. Similarly, the method ejbRemove( ) (implemented with an empty body in SabaEntityBean and SabaSessionBean) can be overridden to encode logic related to deletion of a bean. For example, if we wish to encode the logic that if a person is removed, all the class registrations for that person should also be removed, we can override the ejbRemove( ) method within SabaPerson in the following manner. The ejbRemove( ) method is called just prior to actual removal of the data from the persistent store.

[00002]

	public void ejbRemove( )
	{
	/* Locate the home interface (regnHome) for the
	** SabaRegistration bean (code not shown)
	*/
	Collection regns = (Collection)
	regnHome.findByPersonID(this.id);
	Iterator iter = regns.iterator( );
	while (iter.hasNext( )) {
	SabaRegistrationEJB registrn =
	(SabaRegistrationEJB)
	iter.next( );
	registrn.remove( );
	}
	}
	Other callback methods are ejbLoad( ), ejbStore( ),
	ejbActivate( ), and ejbPassivate( ).

[00415] In the alternative embodiment, transactional integrity can be maintained as follows. Consider a session bean which, as part of its remote interface, has declared a method cancelClass( ) that encapsulates the business process of canceling a class. As part of class cancellation, we also wish to, say, remove the registration records of the persons registered for the class. The registration information is maintained by SabaRegistration entity beans. Hence, within the implementation of cancelClass( ), besides updating some attribute of the SabaClass entity bean to indicate cancellation, we would also encode logic for finding the SabaRegistration entity beans corresponding to that class and then removing them. However, either all these activities must succeed atomically, or no change to persistent store should be made (i.e., the activities constitute a transaction). This would be accomplished by declaring a transactional attribute of TX_REQUIRED for the method cancelClass( ) in the bean's deployment descriptor. If the calling client or bean already has a transaction started, the method will then be executed within the scope of that transaction; otherwise, a new transaction will automatically be started for this method.

[00416] How Can

[00417] In an alternative embodiment, complex data types can be persisted for container-managed entity beans as follows. Suppose there is an entity bean with an attribute that has an array of strings as a data type. Since relational databases do not support such a data type, one cannot directly map the attribute to some column in a database. However, at save time, one can potentially convert the array into a single String by concatenating the elements within the array and using a marker character to delineate various entries. Then, at retrieval time, one can look for the marker character and reconstitute the array. Entity beans provide two callback methods, ejbStore( ) and ejbLoad( ) that can be used for such a purpose. SabaEntityBean by default provides empty implementations of such methods. An application developer can override these methods within the definition of a bean and thus persist complex data types.

[00418] In the alternative embodiment, every class in an application does not have to be a bean. Indeed, with the overhead of locating a bean through a naming service and going through the home and remote interfaces of a bean to perform useful work would negatively impact performance (though some servers will optimize the process for beans located within the same virtual machine). The application developers can implement selected classes as helper classes and not as beans. Sun Microsystems' J2EE Application Programming Model identifies certain instances where helper classes are applicable. One such example is dependent classes that can only be accessed indirectly through other classes (beans). Sun's J2EE APM offers CreditCard and Address classes as examples of a dependent classes.

[00419] EJBs are packaged as EJB jar files that are comprised of the class files for the bean class, the home interface, the remote interface, the primary key class (if applicable), in addition to the deployment descriptor and a manifest. The jar file can be created using the jar application supplied with JDK, or by using some GUI front-end utility provided by the J2EE server being used. The deployment mechanism varies with the servers. For Weblogic server, an entry can be made in the weblogic.properties file; for Sun's reference implementation, the deploytool utility can be used to achieve this in an interactive manner.

[00420] At present, the EJB Specification does not provide a mechanism for declaring such constraints, and this would have to be achieved programmatically in the create( ) and mutator method(s) of the entity beans.

[00421] Component User

[00422] As described above, in the alternative embodiment, a partial example of usage of a component was described in the context of business logic encoding. This section provides a fuller picture of how a component is used in an alternative embodiment, by either another bean or a client application. The primary steps in both the cases are the same:

• • [00423] 1. locate the home interface of the bean;
  • [00424] 2. using the home interface, create a new instance or find one or more existing instances of the bean; and
  • [00425] 3. invoke the bean's methods to accomplish tasks.

[00426] To locate the bean, JNDI is used. There are some variations in how JNDI calls are used with different EJB servers. Here we use the getInitialContext( ) method in the SabaJ2EEVendor class for locating

[00002]

the SabaRegistration bean.
InitialContext ctxt =
SabaJ2EEVendor.getInitialContext( );
Object objref = ctxt.lookup(“SabaRegistration”);
SabaRegistrationHome regnHome = (SabaRegistrationHome)
PortableRemoteObject.narrow(objref,
SabaRegistrationHome.class);

[00427] Once the home interface of the bean is so located, we can use it to create new instances of the bean or find existing ones. In an earlier example, we had used the home interface for finding instances of a bean. Another example, this time for creating an instance, is presented below.

[00002]

	SabaRegistration regstrn = regnHome.create(personID,
	classID);

[00428] Subsequently, we can invoke business methods of the bean simply as follows.

[00002]

	regstrn.setAttrVal(feePaid, true);

[00429] In addition to the foregoing, additional methods (implemented by the bean container) are available for getting a bean's metadata (from which its primary key class, remote interface class, etc. can be obtained), comparing two beans for identity, etc. Many of these methods are used in building tools, such as those for deployment purposes. If additional information about these methods is needed, please consult the available EJB literature.

[00430] Those skilled in these arts will understand that various other alternative embodiments of a business application server system and related development kit for developers, may be designed around these basic concepts without deviating from the unique features provided by applicants in this invention.

[00431] Security System

[00432] In a preferred embodiment of the present invention, the Platform's BDK 519 provides an extremely powerful model for assigning security; that is, defining the sets of allowed operations that groups of users can perform. It supports both extremely sophisticated definitions of an allowed operation and a scalable model for assigning and partitioning security. Specifically, the following features are provided:

• [00433] Security operations can be specified according to either the general class of business object or to specific, individual business objects.
• [00434] Support for both shared security operations (view, update, delete, etc) and business-object specific security operations.
• [00435] Security operations can be assigned based on a customizable partitioning of business objects into domains.
• [00436] Security operations can be assigned based on either universal or domain-specific user groupings.
  Definitions

[00438] The following concepts are central to the Platform's Security Model. A Security List Member is any entity that can be assigned privileges in the system. Members can be can be individual users of the system (employees or customers); they can also be associated with generic roles, such as a system administrator, or even an automated process, such as an Interconnect ChangeManager.

[00439] A Privilege is a set of one or more possible security operations. There are several types of privileges as shown below in Table 1:

[00002]

TABLE 1
Category	Description	Example
Atomic Privilege	The most fine-grained form	Create, Delete
	of privilege. Defines a
	single type of security
	operation.
Component Privilege	An Atomic Privilege	Create Class,
	applies to a specific	View Registrations,
	category of business object	Confirm Internal
		Order
Instance Privilege	An Atomic Privilege	View the “Monthly
	applied to a specific	Cancellations”
	business object	Report
Complex Privilege	A grouping of one or more	Create, modify, and
	privileges	delete classes

[00440] The Platform 501 supports several pre-defined atomic privileges that apply to all business objects. The pre-defined atomic privileges are shown below in Table 2.

[00002]

	TABLE 2
	Privilege	Description
	New	Create a new instance of this business
		object
	View	View summary or detail information about
		an existing business object
	Edit	Change information about an existing
		business object
	Delete	Delete an existing business object
	Change Domain	Set the domain of an existing business
		object

[00441] Specific categories of business objects can also define additional privileges specific to that category. For example, the following component privileges only apply to the “Purchase Order” business object:

• • [00442] Change Expiry Date
  • [00443] Change Initial Credit
  • [00444] Change Status
  • [00445] Change Terms

[00446] Domains are the Platform's 501 partitioning mechanism for business objects. Domains allow users to define a hierarchical structure that models their organization or business, for example, based on geography or division. For example, the following simple example shows a three-domain organization, with a root “World” domain and two child “US” and “Europe” domains.

[00447] All business objects are assigned a specific domain and belong to that domain. In turn, security privileges are assigned on specific domains. The domain hierarchy is automatically enforced during security checks. This means that users who have access to a domain can access objects in that domain, and that users who have access to ancestors of a given domain also have access to objects in that domain.

[00448] Extensions to the basic domain model may include the ability to define multiple, independent domain axes. For example, one domain hierarchy might be based on geography, another on business function.

[heading-00449] Security Lists are the mechanism by which members are matched with privileges. A Security List defines a set of domain-specific privileges and a set of list members. Security Lists are created in a two-step process as follows:

[none]

• • [00450] First, a set of privileges are added to a security list, where each privilege is applied to a specific domain. A privilege within a security list—that is, a privilege applied to a specific domain—is known as a “granted privilege.”
  • [00451] Second, a set of members are added to a security list.

[00452] Privileges are calculated at runtime based on all the security lists a user belongs to. At least one of the lists must contain a required privilege in the appropriate domain. This combined use of privileges and security lists supports two paradigms for administering security across domains:

• • [00453] 1. A centralized approach wherein global administrators define security lists that contain a set of (privilege, object, domain) triples, that is, one security list can apply across different domains. The same global administrators assign members to security lists.
  • [00454] 2. A decentralized approach wherein global administrators define complex privileges that contain a set of (privilege, object) pairs with no domain information. These serve as “security roles”, effectively, global security lists that are domains-independent. Administrators for individual domains then define domain-specific security lists containing these privileges. The domain administrators assign members in their domain to security lists.

[00455] The following example shows how privileges work in practice. Two security lists are shown below in Table 3 and Table 4 containing the following granted privileges:

[00002]

TABLE 3
“Customer” Security List
	Privilege	Business Object Category	Domain
	View	Class	World
	Create	Order	US

[00002]

	TABLE 4
	“US Instructor” Security List
	Privilege	Business Object Category	Domain
	View	Class	World
	Create	Class	US
	Delete	Class	US
	Create	Conference Room	US
	View	Conference Room	World
	Schedule	Projector	US

[00456] For purposes of this example, also assume that the instances of business objects shown below in Table 5 exist:

[00002]

	TABLE 5
	Business Object Category	Business Object	Domain
	Class	English 101	US
	Class	Spanish 101	Europe
	Conference Room	Purple Room	World
	Conference Room	Lavender Room	US
	Projector	Projector 1520	Europe
	Projector	Projector 1120	US

[00457] If User1 only belongs to “Customer” security list, User1 can perform the following operations:

• • [00458] View Class “English 101”
  • [00459] View Class “Spanish 101”
  • [00460] Create a new Order for Class “English 101”

[00461] However, User 1 is not permitted to perform the following operations:

• • [00462] Order the class “Spanish 101” to be taken in Europe [because this would require a Order with a domain of “Europe”]
  • [00463] View the Purple Room
  • [00464] View the Lavender Room

[00465] If User2 belongs to both the “Customer” and “US Instructor” security lists, then User2 can peform the following operations:

• • [00466] View Class “English 101”
  • [00467] Create a class “English 101” in the “US” domain
  • [00468] View the Lavender Room
  • [00469] View the Purple Room
  • [00470] Schedule Projector 1120

[00471] However, User2 is not permitted to perform the following operations:

• • [00472] Create a new Order for Class “Spanish 101” to be taken in Europe
  • [00473] Create a class “French 101” in the “Europe” domain
  • [00474] Schedule Projector 1520

[00475] The Persistence Layer of the BDK 519 automatically takes account of the predefined atomic privileges (new, view, etc) in its behavior. Thus, search results using standard finders will only return objects for which a user has view privileges, and update operations for which a user does not have privileges will automatically throw a Security exception. In addition, the BDK 519 provides the ability to explicitly query the security model using the API described below.

[heading-00476] Security System API

[00477] The BDK 519 provides a Java-based API for managing security. As described in the BDK section, this API uses an EJB-style session manager named “SabaSessionManager” and a set of helper classes.

[00478] The API includes:

[00002]

1. A set of interfaces representing the basic concepts in the security model.
// IPrivilege - The base class of privilege. A Privilege is
anything that can be added to a Security List.
public interface IPrivilege;
// IAtomicPrivilege - A single allowable operation
public interface IAtomicPrivilege extends IPrivilege;
// IComponentPrivilege - A single allowable operation on a specific
object class.
public interface IComponentPrivilege extends IAtomicPrivilege;
// IInstancePrivilege - A single allowable operation on a specific
object instance.
public interface IInstancePrivilege extends IComponentPrivilege;
// IComplexPrivilege - A structured privilege, capable of grouping
other
atomic or complex privileges.
public interface IComplexPrivilege extends IPrivilege, IHandle;
// Domain - A business object representing an entry in the Domain
hierarchy
public interface Domain extends IHandle;
// ISecurityListMember is any interface that can be a member of a
security list, including IRole, IParty (IPerson or IOrganization),
or IGroup
public interface ISecurityListMember extends IHandle;
// ISecurityList matches granted privileges to a set of members
public interface ISecurityList extends IHandle;
2. A set of concrete classes capturing the available privileges in the
system. These classes are application-dependent; i.e. there are one set of
classes associated with the Learning application built on Platform, another
set associated with the Performance application, etc.
For example:
public class InstancePrivileges implements
IInstancePrivilege {
/* Define the set of common atomic privileges that
apply to all objects in the system. */
public static final int kEdit = 2;
public static final int kDelete = 3;
public static final int kView = 6;
}
public class ComponentPrivileges implements
IComponentPrivilege {
/* Define the set of common atomic privileges that
apply to all components in the system. Notice that
this class includes all atomic privileges that apply
to instances */
public static final int kNew = 1;
public static final int kEdit = 2;
public static final int kDelete = 3;
public static final int kView = 6;
}
public class PurchaseOrderPrivileges extends ComponentPrivileges
{
// Privileges specific to the Purchase Order business
object
public static final int kChangeDomain = 7;
public static final int kChangeStatus = 11;
public static final int kChangeTerms = 12;
public static final int kChangeInitialCredit = 13;
public static final int kChangeExpiryDate = 14;
public static final int kChangeCurrency = 15;
}
2. The interface of the manager used to create and manage security lists.
public interface SabaSecurityManager extends ISabaRemote {
/* methods for creating and updating security lists */
public ISecurityList createSecurityList(SecurityDetail detail);
public SecurityDetail getDetail(ISecurityList theSecurityList);
public void update(ISecurityList theSecurityList,
SecurityDetail detail);
public void remove(ISecurityList theSecurityList);
/* methods for adding & removing privileges to security lists
*/
public void addPrivilege(ISecurityList theList, IPrivilege
thePrivilege, Domain theDomain);
public void removePrivilege(ISecurityList theList, IPrivilege
thePrivilege, Domain theDomain);
/* methods for adding & removing members from security lists */
public void addMember(ISecurityList theList,
ISecurityListMember theMember);
public void removeMember(ISecurityList theList,
ISecurityListMember theMember);
/* methods to check privileges */
public boolean isMember(ISecurityList theList,
ISecurityListMember theMember);
public boolean hasPrivilege(ISecurityListMember theMember,
IAtomicPrivilege thePrivilege, Domain theDomain);
public Collection getPrivileges(ISecurityListMember theMember,
IComponent theComponent, Domain theDomain);
/* standard finder */
public ISecurityList findSecurityListByKey(String id);
public Collection findSecurityListByName(String name);
public Collection findAllSecurityLists( );
} /* SabaSecurityManager */
The following code fragment demonstrates how the Security API can be
used to create a new security list, assign users to that security list, and
check privileges for that user. Note that this code example uses several
other session bean managers, such as a DomainManager and
PartyManager, provided as part of Platform.
/* Step 1: create a security list */
String privName = “Guest”;
String privDescription = “Guest login and access”;
Domain domain =
theDomainManager.findDomainByKey(“domin0000000000010
00”);
String domainID = domain.getId( );
SecurityDetail theDetail =
new SecurityDetail(privName, privDescription,
domainID);
ISecurityList securityList =
theSecurityManager.createSecurityList(theDetail);
/* Step 2: grant privileges by adding them to the list */
IComponent classesComponent =
theComponentManager.getComponent(“Classes”);
/* create atomic privileges and add them */
IPrivilege viewClasses = (IPrivilege)
new ComponentPrivileges(ComponentPrivileges.kView,
classesComponent);
theSecurityManager.addPrivilege(securityList,
viewClasses, domain);
IComponent groupComponent =
theComponentManager.getComponent(“Product Group”);
IPrivilege viewGroups = (IPrivilege)
new ComponentPrivileges(ComponentPrivileges.kView,
classesComponent);
theSecurityManager.addPrivilege(securityList, viewGroups,
domain);
/* Step 3: assign a member to the security list */
ISecurityListMember member = (ISecurityListMember)
thePartyManager.findEmployeeByKey(“emplo0000000000010
00”);
theSecurityManager.addMember(securityList, member);
/* Step 4: check a user's privileges */
IPrivilege editClassPriv = (IPrivilege) new
ComponentPrivileges(ComponentPrivileges.kEdit,
classesComponent);
boolean canEditClasses =
theSecurityManager.hasPrivilege(member,
editClassPriv, domain);

Best Mode

[00480] In a preferred embodiment, the Platform's BDK security API focuses on the database structures and SQL used to store and query security information. It also touches on the algorithms used in implementing the Java API.

[00481] Information related to security is stored database tables as shown below. The Platform's BDK Security System uses Java code to read and write values to these database tables.

[00482] fgt_domain stores all domains as shown below in Table 6.

[00002]

TABLE 6
Column Name	type	Required?	Description
id	OBJECTID	y
description	varchar (255)	n	Long descriptive string
			for the domain.
name	varchar (25)	y	Name of the domain
Parent_id	OBJECTID	N	ID of the parent domain

[00483] fgt_ss_privs stores all atomic privileges as shown below in Table 7a.

[00002]

TABLE 7a
Column Name	Type	Required?	Description
id	OBJECTID	y
object_type	OBJECTID	Y	object id (data dictionary
			class id) to which the
			privilege applies.
priv_name	varchar (80)	Y	a description string for
			the privilege.
priv_seq	INT	y	a number which identifies
			the type of privilege.
			1 => New
			2 => Edit
			3 => Delete
			4 => Save
			etc.
			Note: 1-5 common to all
			classes 11 onwards --
			class specific.

[00484] For example, in Table 7b below, the following data captures the available privileges for the Purchase Order business object. Notice that the values in the priv_seq column directly correspond to the constants defined by PurchaseOrderPrivileges class defined in the Java API.

[00002]

TABLE 7b
		priv—
id	object_type	name	priv_seq
ssprv000000000001008	pycat000000000001036	New	1
ssprv000000000002008	pycat000000000001036	Edit	2
ssprv000000000003009	pycat000000000001036	Delete	3
ssprv000000000010175	pycat000000000001036	View	6
ssprv000000000010224	pycat000000000001036	Change	7
		Domain
ssprv000000000007120	pycat000000000001036	Change	11
		Status
ssprv000000000007121	pycat000000000001036	Change	12
		Terms
ssprv000000000007122	pycat000000000001036	Change	13
		Initial
		Credit
ssprv000000000007123	pycat000000000001036	Change	14
		Expiry
		Date

[00485] fgt_list stores all security lists as shown below in Table 8a.

[00002]

TABLE 8a
Column Name	Type	Rq?	Description
id	OBJECTID	Y
description	varchar (255)	N	Description of this list
name	varchar (25)	Y	Name of the list
owner_id	OBJECTID	N	The owning object of this list if
			any.
security	BOOLEAN	Y	0 = Not a security list,
			1 = Security List.

[00486] For example, in Table 8b below, the following data defines a security list to capture generic user privilges:

[00002]

TABLE 8b
id	name	description	security
lista000000000002003	User	A generic low-privileged user	1

[00487] fgt_list_entry stores all members of a security list as shown below in Table 9.

[00002]

TABLE 9
Column Name	Type	Rq?	Description
id	OBJECTID	Y
list_id	OBJECTID	Y	Foreign key to a security list
person_id	OBJECTID	Y	Foreign key to a list member. The
			object ID may be a person, role,
			or group.

[00488] fgt_ss_grants stores all granted privileges as shown below in Table 10.

[00002]

Column Name	Type	Rq?	Description
id	OBJECTID	y
granted_on_id	OBJECTID	y	Foreign key to the business
			object class or instance on
			which this privilege is granted.
granted_to_id	OBJECTID	y	Foreign key to the security list
			on which this privilege is
			granted.
privs	varchar (50)	y	50 character bitmap containing
			the granted privileges.
domain_id	OBJECTID	N	Foreign key to the domain on
			which this privilege is granted.

[00489] Notice that this schema shown in Table 10 stores all atomic privileges on a (object, domain, list) triple in a single row by appending the integer keys of the atomic privilges into a single string. Notice also that the schema shown in Table 10 can capture both:

• • [00490] 1) privileges on business object classes, by storing the data dictionary primary key of the class in the granted_on_id column.
  • [00491] 2) privileges on business object instances, by storing the object id of the instance in the granted_on_id column.

[00492] For example, the following row from Table 10 describes a grant that allows members of the “Users” security list to create and view orders, but not edit or delete them. The “ddcls” prefix (for “data dictionary class”) on the granted_on_id value indicates that this OBJECTID refers to a business object class. The 1^st and 6^th bits of the privs flag are on, providing create and view privileges only.

[00002]

	id	granted_on_id	granted_to_id
	ssgrn000000000001264	ddcls000000000001055	lista000000000002003
privs	domain_id
10000100000000000000000000000000000000000000000000	domin000000000000001

[00493] The following row from Table 10 describes a grant that allows the same list to execute a specific report. The “reprt” (for “report”) prefix on the granted_on_id value indicates that this OBJECTID refers to a specific instance of the Report business object. The 11^th bit of the privs flag is on, meaning the grant gives Execute privileges only.

[00002]

id	granted_on_id	granted_to_id
ssgrn000000000202056	reprt000000000001000	lista000000000002003
privs	domain_id
00000000001000000000000000000000000000000000000000	domin000000000000001

[00494] The Platform's BDK Security System also utilizes an addPrivilege( ) method. The addPrivilege( ) method has different logic depending on whether a row already exists in fgt_ss_grants for the combination of security list, business object, and domain. If a row exists, it retrieves the existing row, sets the additional bits defined by the IPrivilege parameter, then updates the row. If no row exists, it creates a empty privilege bitmap, sets the bits defined by the IPrivilege parameter, then inserts a row. The Platform's BDK Security System also utilizes an hasPrivilege( ) method. The addPrivilege( ) method executes a SQL query to return all privilege bitmaps for each security list the user belongs to that match the target object and domain parameters. It iterates through each bitmap and returns true if the privilege has been set in any one. The SQL query that is executed is:

[00002]

	/* select all of a user's grants on an class in a given domain.
	parameter 1 = person id
	parameter 2 = class id
	parameter 3 = domain id */
	select g.id, g.privs from fgt_ss_grants g, fgt_list 1,
	fgt_list_entry e where e.person_id = @@001 and e.list_id = l.id
	and l.security = 1 and
	g.granted_to_id = l.id and g.granted_on_id = @@002 and
	g.domain_id = @@003

[00495] The BDK Persistence layer also contains code that directly accesses these database tables to check security privileges. A utility class, SabaPrivileges, contains a hasPrivs( ) method that is called at predefined points by the SabaObject and SabaEntityBean implementations, including whenever objects are saved and restored. This method has the following signature:

[00002]

	public boolean hasPrivs(String objectID, String classID, String
	domainID, int privToCheck, boolean anyDomain)

[00496] SabaPrivileges contains a Java hashtable that caches privilege for each business object in the system. The hasPrivs( ) method iterates through these privileges to look for a match, using logic similar to the SabaSecurityManager.hasPrivilege( ) method.

[00497] If the cache is empty, SabaPrivileges queries the database to load the appropriate privileges. The SQL used is the following:

[00002]

select s.granted_on_id granted_on, substr(
to_char(decode(sum(to_number(substr(s.privs, 1, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 2, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 3, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 4, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 5, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 6, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 7, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 8, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs, 9, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,10, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,11, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,12, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,13, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,14, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,15, 1))),0.0,1))
| | to_char(decode(sum(to_number(substr(s.privs,16, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,17, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,18, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,19, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,20, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,21, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,22, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,23, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,24, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,25, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,26, 1))),0.0,1))
| | to_char(decode(sum(to_number(substr(s.privs,27, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,28, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,29, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,30, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,31, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,32, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,33, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,34, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,35, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,36, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,37, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,38, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,39, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs.40, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,41, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,42, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,43, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,44, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,45, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,46, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,47, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,48, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,49, 1))),0,0,1))
| | to_char(decode(sum(to_number(substr(s.privs,50, 1))),0,0,1))
,1,50) privs, t.node_id domain_id from fgt_ss_grants s, fgt_list_entry
1, tpt_dummy_flat_tree t where l.person_id = @001 and
s.granted_on_id = @003 and l.list_id = s.granted_to_id and
s.domain_id = t.related_to and (l.group_label is null or
l.group_label = @002) group by s.granted_on_id, t.node_id

[00498] The SQL used in this query has two unique features:

• • [00499] It uses a table called tpt_dummy_flat_tree that stores the parent/child relationships for all domains in the system. This allows it to include a join that obtains privileges for both the specified domain and all its parents.
  • [00500] It checks the value of the privs field bit by bit, and concatenates the results together to form a new bitmap that is the union of the bitmap fields for the specified domain and all its ancestors.

[00501] The following example data in tpt_dummy_flat_tree shown in Table 11 defines the relationships between three domains, where domin000000000000001 is the top-level parent, domin000000000001000 is its child, and domin000000000001001 is its grandchild.

[00002]

TABLE 11
NODE_ID	RELATED_TO	R	REL_LEVEL
domin000000000000001	domin000000000000001	I	1
domin000000000001000	domin000000000000001	A	2
domin000000000001000	domin000000000001000	I	1
domin000000000001001	domin000000000000001	A	3
domin000000000001001	domin000000000001000	A	2
domin000000000001001	domin000000000001001	I	1

[00502] WDK Server

[00503] The Web Content Server 800 enables the present invention to interact with users regardless of the users hardware platforms, locations, and software systems. The Web Content Server 800 allows the present invention to overcome the difficulties of prior art systems associated with having an infrastructure which is tightly coupled to application products, specific hardware platforms and specific Operating systems and related services.

[00504] The Web Content Server 800 can allow the present invention to interface with many other industry standard software programs to make the exchange and flow of data easy and accurate, and enables interconnection with external systems, special networks, like SabaNet, and the Internet.

[00505] The Web Content Server 800 is web-enabled and provides a unified set of interfaces for interacting with web based users as well as other users.

[00506] The Web Content Server 800 can also allow vendors/developers to develop applications on the Platform, make use of core technology for information matching and distribution, and provide standardized access to connectivity with other systems and platforms in a users network.

[00507] As shown in FIG. 8A, one embodiment of an Web Content Server 800 provides an interface between users 802, 804, and 806 and the Platform. The Web Content Server 800 preferably includes an engine 808, style sheet control system 810 for various user display protocols, a JAVA Virtual Machine 812 and the related runtime support.

[00508] The Style Sheet Control System 810 contains mechanisms to manipulate various kinds of display style sheets, to generate and execute web links, to manage dynamic content generation and dynamic generation of Javascript. The Style Sheet Control System 810 also can allow vendors/developers to modify, add, or delete the mechanisms in the Style Sheet Control System 810. Thus, vendors/developers can customize the presentation of data to the users.

[heading-00509] User Generation of Web Content

[00510] Web Content Server 800 can also provide the platform's web content generation engine for use by users to create, render, and present web content while improving the dynamic acquisition of data from a variety of sources followed by its reformatting and display via style sheets. Using web standards for XML and XSL, Web Content Server 800 provides a user with a customizable framework for decoupling data from presentation, and generating web content in a variety of formats, from standard HTML to WML.

[00511] The Web Content Server 800 provides a “page engine” 808 which allows users (such as developers, consultants and customers) to build web content using a separation between Model, Widget, and View instructions. The engine 808 separates data production, interaction elements and display information, and maintains these aspect of page production in different files.

[00512] The engine 808 supports three components: (a) Widgets, which are reusable interactive components such as buttons and data entry fields; (b) Models, which encompass the data and user operations used by the application (Data can be simple Strings or complex objects); and (c) Views, which use style sheets to define and control the presentation of output to the user.

[00513] Using the system 808 provides, among other things, the following advantages for a user:

• • [00514] Improve maintainability of web content.
  • [00515] Partition web content development between users (such as component developers, Java developers, and UI developers).
  • [00516] Provide easy and extensive customizability by users.
  • [00517] Improve productivity of building web content.
  • [00518] Provide improved authoring and debugging support.
  • [00519] Provide the infrastructure for targeting alternate deployment platforms (ie palmtops).

[00520] In one embodiment, the engine 808 uses XML, XSLT (extensible Stylesheet Language Transformations), and RDF (Resource Description Framework), built round a publishing framework called Cocoon to enable the functionality of Web Content Server 800.

[00521] The engine 808, in conjunction with a set of tools, utilities, APIs, and predefined widgets and views, acts as a platform and provides the user with a set of tools, tag and widget libraries, Java classes, and XSL style sheets. Tools included with the platform 808 help users perform the following activities: (a) Authoring—users need to create and maintain control files, model files, widget files, and view files; (b) Debugging—the process starting with obtaining data and ending with viewing is involved so having tools or methods for debugging problems is essential; and (c) Customization—customizing the final product can certainly be accomplished with the tools used for authoring and debugging, but additional tools can radically simplify tasks like product upgrades or performing simple customizations.

[00522] The platform 808 allows content, logic and style to be separated out into different XML files, and uses XSL transformation capabilities to merge them resulting in the automatic creation of HTML through the processing of statically or dynamically generated XML files. The platform 808 can also generate other, non-HTML based forms of XML content, such as XSL:FO rendering to PDF files, client-dependent transformations such as WML-formatting for WAP-enabled devices, or direct XML serving to XML and XSL aware clients.

[00523] The platform 808 divides the development of web content into three separate levels: (a) XML creation—The XML file is created by the content owners. They do not require specific knowledge on how the XML content is further processed—they only need to know about the particular chosen “DTD” or tagset for their stage in the process. This layer can be performed by users directly, through normal teeditors or XML-aware tools/editors; (b) XML processing—The requested XML file is processed and the logic contained in its logicsheet is applied. Unlike other dynamic content generators, the logic is separated from the content file; and (c) XSL rendering—The created document is then rendered by applying an XSL stylesheet to it and formatting it to the specified resource type (HTML, PDF, XML, WML, XHTML, etc.).

[heading-00524] Dynamic Web Content Development Using Web Content Server 800

[00525] The Web Content Server 800 can be based on XML, XSLT and Java technologies. Using these technologies, the Web Content Server 800 allows for easier user interface customization, more flexibility in page functionality, easier page maintenance and the creation of more easily reusable code. It encourages the separation of data production, interaction elements and display information by separating different aspect of page production in different files.

[00526] Using platform 808, developing a web page (web content) requires the development of the following components: (a) a control file; (b) a model file; (c) a view file; and (d) Command Managers and Commands.

[00527] The Model contains all the data and interactivity for a given page. Users are responsible for generating an XML page containing the raw data they wish to display, independent of the appearance of that data or any additional presentation information.

[00528] The Model can be implemented using a dynamic page engine (JSPs or XSPs). In addition, API 808 provides a variety of helper tagsets to automate common scripting operations, minimizing the amount of custom scripting required by a user.

[00529] Model Developers are typically Java programmers, since the bulk of development effort is implementing a companion Java Bean that invokes the appropriate SABA Manager API. They then use the dynamic features of the engine (tag libraries and Java scripts) to place data from the bean onto the page.

[00530] The View contains all style and presentation for a given page. Users are responsible for implementing an XSLT stylesheet that transforms the model into a specific presentation environment. View developers are typically UI designers, since the bulk of authoring effort is crafting the HTML for a static page, then adding in the set of XSLT tags to create a stylesheet for the associated model page.

[00531] Widgets are a set of predefined UI components and presentation elements common to web applications. Widgets can have user interactivity (fields, links) or be presentation only (images). Widgets can be implemented as XSLT stylesheets. The platform 808 includes a predefined set of common widgets that can be used by both model and view developers. Note also that developers have the option of overriding the default widgets to provide enhanced or custom functionality if required.

[00532] The important distinction between tag libraries and widgets is that tag libraries are used in the model and are an aid to dynamic content generation, whereas widgets are used in the transform step and are an aid to end-content generation. Tag libraries can be implemented in Java, whereas widgets are preferably implemented as stylesheets.

[00533] FIG. 8B shows how the engine 808 processes/uses these files to produce dynamic web content.

[00534] The process of creating the HTML to send to the browser begins with reading the control file, 860. The control file 862 is simply a file that identifies the model file 864, the view file 866 and the widget library 868 to use to produce the final HTML result 870. The control file 862 also contains link transformation information that is used to transform links used in the model file 864. This link transformation is used to map model-file hyperlink references contained in the model file 864 to appropriate control file names.

[00535] The model file 864 is loaded and preprocessed based on the information contained in the control file 862. The preprocessed model file is executed in three steps. In 872, any tags from the tag library are processed. The tag library includes tags for internationalization, command invocation and widget management. In 874, the resulting XML file is then further processed to generate a Java class. In 876, the Java class is executed to produce the model instance 878. The model instance 878 contains all data and other information needed for display. For example, the model instance 878 will contain the XML form of the data retrieved by the Commands invoked in the model page and it will contain all internationalized labels and widgets. In 880, the model instance 878 is first transformed using the widget library 868. In 882, the result of the widget transformation is then further transformed using the view transformation file 866 to produce the final result 870.

[00536] The process outlined above also highlights how the different aspects of developing dynamic web content are separated. The design of a particular web page is the result of answering the following questions: (a) What do I do with parameters sent from the browser and what data is needed to display the page? How do I perform these tasks? (b) How will the user interact with the page? What buttons, entry fields etc. will the user have? and (c) How are the data and the interaction elements displayed on the page?

[00537] The answer to question (a) results in the model page and the Command objects used by the model page. The model page invokes all needed Commands to perform the tasks of the page and to produce the data needed for display. The answer to question (b) produces a listing of all widgets and their linkages to the data being displayed. Although this list is part of the model page, the list of widgets and their linkages are all declared in a clearly identifiable part of the page. Finally, the answer to question (c) produces the view transformation page.

[heading-00538] Page Development Process

[00539] Typically the page development process starts with an HTML mockup of the page. The Web Content Server 800 development process can start with the HTML mockup as well. However, users do not modify this mockup to include code. Instead the process illustrated in FIG. 8C is followed.

[00540] As illustrated in FIG. 8C, using the HTML mockup 884, the user develops three specifications. The data model specification 886 is developed to meet three basic criteria. First, the data model needs to contain enough information to drive the interface. For example, if the interface needs to display the name of an object, then the data model must contain the object name in some form. Second, the data model specification should maximize reuse of command objects. For example, if a command object already exists that can retrieve a needed object in a serialized XML format, then the data model of the command object should be reused instead of reinventing a new XML representation of the same object. Finally, the data model specification should be generic so other pages can reuse the model generation components (Commands). How general the data model should be is determined by balancing the trade-off between performance (since producing more data may incur performance penalty) and reusability. If producing a more general data model causes high performance penalty, then a less general solution may be better. On the other hand, if adding a few not needed items comes at no or little performance cost, then the more general data model is preferred. For example, objects implementing the IXMLObject interface will typically provide more than enough information about themselves. The data model specification 886 should essentially be a sample of the data returned by the Command objects and the specification XML should be wrapped in tags.

[00541] The widget specification 888 is a list of widgets needed by the page. These widgets include input fields of all types (textboxes, radio button collections, check box collections, dropdown lists, hyperlink buttons, etc.). Besides declaring what widgets the page needs, the specification 888 can also include how these widgets relate to the data model. For example, the page may require an edit button widget for every object it displays. The widget specification 888 can therefore indicate that the edit button is “attached to” those objects. The widget specification 888 can be very incomplete, because users (such as view developers) will typically only need the name of the widget for layout purposes. The widget library will take care of rendering the widget itself.

[00542] The third specification is the specification of internationalized items 890 (labels, graphics). The specification 890 includes a list of all labels and images used on the page. The specification 890 contains just the name of the label and some sample text for the label.

[00543] Once the specifications 886, 888, and 890 are complete, the user or a tool, produces a sample model instance 892. The user can use the model instance 892 to test the view stylesheet (by using any standard XSLT tool). The user develops the view stylesheet by converting the original HTML mockup to an XSLT stylesheet to retrieve dynamic data, widgets and internationalized labels from the model instance. This conversion process can mostly be done in an HTML editor.

[heading-00544] Customizing/Modifying a Page

[00545] One of the benefits of using the platform 808 for page development is in the ease of page customization and page modification. Often the look and feel of pages needs to be modified after the initial design. Using conventional systems this process was very painful: individual pages had to be revisited by software engineers and tweaked to confirm to the new requirements. These new requirements often meant changed look of textual/graphical information (e.g., justification of text, font, color), changing the layout (e.g., adding another Save button to the bottom of the page, moving buttons and table columns around), or adding/removing information content (e.g., display the price of an offering but don't display the description of the offering). Also, often changes are required across pages: e.g., we want every link button to use “Helvetica” instead of “Verdana” for its label, and the alt label for the link image should be the same as the label of the link itself. Sometimes page changes include adding new interaction components, e.g. adding a “Cancel” button to the page, or adding an edit button next to each displayed object. Such changes are much simpler to perform using Web Content Server 800.

[heading-00546] Modifying Text/Graphics Look and Feel

[00547] To change the look and feel of textual and graphical information, the user can edit the view page in an HTML tool. The user can add <span>, <div> etc. tags around the components needed modification, and define the “style” attribute to reflect the desired look and feel changes. If the user needs to develop for browsers with limited CSS support (e.g., Netscape 4.x), the user can wrap the components in <u>, <b>, <font>, etc. tags as needed.

[heading-00548] Layout Changes

[00549] The cut/copy/paste commands of the HTML editor can be used to perform most layout changes requiring the repositioning of different components. Dreamweaver, for example, gives users powerful HTML/XML element selection capabilities that make it easier to move and copy whole HTML/XML document fragments.

[heading-00550] Adding/Removing Information Content

[00551] Often the model specification will result in the production of more content than needed by a particular view. For example, the model for a page that needs to display the parents of a particular security domain only may also produce other information about the security domain (e.g., the description of the domain). This is especially likely when the model page reuses other, already existing command objects. In such cases displaying additional content can simply be done at the view page level: the user needs to place the newly required information somewhere on the view page. Removing information items is also very simple, since users can simply delete a particular HTML/XML fragment if viewing that piece of the model is not needed.

[heading-00552] Changing Look and Feel of Widgets Globally

[00553] The use of widget libraries make it very simple to change the look and feel of widgets across pages. Either the widget transformation of the used widget library can be changed or an alternative widget library can be developed. In the latter case control pages must be updated to point to the new instead of the original widget library.

[heading-00554] Adding New Interaction Components

[00555] If the guidelines for model page design are followed then adding new interaction components (e.g., buttons) is a very simple task. Adding a new widget (e.g., Cancel button) means adding a new widget to the widget section of the model page AND changing the view page to include the new widget. Since the widget section is a separate section of the model page, software engineers (and perhaps UI engineers) can make the required change without disturbing/interfering with any other part of the model page.

[heading-00556] Components of the Platform 808

[00557] The control page associates a particular model page, view page and widget library.

[00558] The model page produces the data needed for displaying the page and it also defines the widgets (interaction elements, such as links, buttons, input fields, etc.) and internationalized resources (labels, graphics) used by the view page. The model page has a well defined structure. Model pages can produce XML representation of data using command managers and command objects. A model page can invoke a command using a tag. After the model page is executed, the tag will be replaced with the XML data produced by the selected Command.

[00559] The model instance is the XML document produced by executing the model page.

[00560] The view page displays the data and widgets contained in the model instance (i.e. the XML document produced by executing the model page). If the control page declares a widget library to use, then the view transformation takes place after the widgets have already been transformed to the appropriate format (e.g. HTML).

[00561] The widget library contains the display transformation for widget components. After the model page executes the produced widgets are transformed to the appropriate output format (e.g., HTML). The resulting HTML markup is wrapped in tags so the view transformation page can easily identify and place each widget.

[00562] The tag library contains tags users can use in their model pages to access common code functionality. This common functionality includes accessing resource bundles, retrieving page parameters, executing commands, declaring widgets, etc.

[00563] Control Page

[00564] The entry point into any platform 808 page is an XML document that serves as a controller. This page is simply an XML document that points to the model, view, and widget documents. This convention creates a clean decoupling between the three constituent pages. As an example of the benefit of this approach, web content administrators may substitute a different control page in a deployment environment; this allows them to use the same model while modifying just the view.

[00565] Coding Guidelines

[00566] Pages built using the platform 808 employ certain conventions and coding guidelines to ensure consistent operation and simplify some processing steps. These coding guidelines include the following:

[00567] a. Head Element

[00568] All model pages must contain a head page element that defines some information specific to the model. It is used to capture the following:

• • [00569] required metadata about input and pass-through parameters
  • [00570] values of i18n labels. The convention is that all i18n values are obtained via the i18n utility tag in the model page; this information is then passed on to the stylesheet in a predetermined location within the wdk:head element
  • [00571] page title and other useful information about the page.

[00572] b. Widget Stylesheet

[00573] The widget stylesheet is simply a list of xsl:includes of the widgets used on this page. The widgets can be from the set of predefined widgets or can be customized widgets.

[heading-00574] One Example of a Preferred Embodiment

[00575] In one preferred embodiment, the Web Content Server 800 is a dynamic content generation framework based on the apache Cocoon project. Like other approaches, such as JSP, ASP, ColdFusion etc., the Web Content Server 800 would allow developers to create web pages to display data derived dynamically through some business logic. Unlike other dynamic content generation frameworks, the Web Content Server 800 separates the content from its presentation. This separation makes it easier to customize pages, to provide different versions of pages to different user agents (desktop browsers, handheld devices, etc.).

[00576] Content production and presentation separation is achieved by following a Model-View-Widget (MVW) paradigm. In this paradigm three distinct components are responsible for generating the final output sent to the client (desktop browser, WAP phone, handheld device). The model page is responsible for producing the content as well as the user interaction components (widgets). Widget look and behaviors are added during the widget transformation. Finally the View transformation provides the look and layout for the content and widgets produced by the model page.

[heading-00577] File Loading Algorithm

[00578] When the Cocoon engine processes the HTTP request, it invokes the getDocument( ) method of the file producer registered with Cocoon. Web Content Server 800 uses a specific file producer (SabaProducerFromFile) to load the requested file. This file producer uses SabaSite properties to determine the location of the requested file. To register the Web Content Server 800 specific file producer, the following line is added to cocoon.properties:

[00002]

	producer.type.file =
	com.saba.web.engine.SabaProducerFromFile

SabaSite

[00580] SabaSite is an object containing a set of properties relevant to a particular saba application. These properties include, but are not limited to:

• • [00581] File system location of application pages
  • [00582] File system location of images
  • [00583] Name of the site
  • [00584] Name of the servlet driving this application
  • [00585] Etc.

[00586] Using the SabaSite object and the associated property file the configuration of a given Saba application can be changed with ease.

[heading-00587] The Algorithm

[00588] The SabaProducerFromFile uses the request URL to identify the file requested. The getDocument method of this class performs the following steps:

• • [00589] 1. Determines the SabaSite based on the request. The SabaSite is identified as follows:
    • [00590] a. Extract the servlet path information from the request object using the HttpServletRequest API (getServletPath( )).
    • [00591] b. If the servlet path ends with a Web Content Server 800 specific string suffix, then the associated SabaSite name is determined by stripping of that suffix.
    • [00592] c. If the servlet path does not end with the Web Content Server 800 specific string suffix, then the system default SabaSite name is retrieved using the SabaSite API.
    • [00593] d. The SabaSite is retrieved using the SabaSite API
    • [00594] e. Finally the SabaSite is initialized using the request object
  • [00595] 2. Uses the SabaSite object to determine the location of all web documents by getting the document root property of the site.
    • [00596] a. Uses the SabaSite API to retrieve the document root (getDocumentRoot( )).
  • [00597] 3. Determines the relative pathname of the requested document from the request object.
    • [00598] a. Uses the HttpServletRequest getPathInfo( ) API.
  • [00599] 4. Computes the absolute path of the document by combining the document root with the relative pathname.
    • [00600] a. Appends the value of the document root and the relative pathname.
    • [00601] b. Replaces all “\” characters with “/” to make sure the absolute pathname has the correct syntax.
  • [00602] 5. Parses the file identified by the pathname and returns the resulting document object model (DOM).
    ControlFile Processing Algorithm

[00604] When a client sends a request to a Web Content Server 800 application, the above-described process is used to identify and parse the control file. The control file is an RDF document that ties the above-mentioned three components of the Model-View-Widget paradigm together.

[heading-00605] Control File Example

[00002]

1	<?xml version=“1.0” encoding=“UTF-8”?>
2	<?cocoon-process type=“wdk”?>
3	<!DOCTYPE rdf:RDF SYSTEM “../control10.dtd”>
4	<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#”
	xmlns:wdk=“http://www.saba.com/XML/WDK”>
5	<rdf:Description id=“searchPerson”>
6	<rdf:type
	resource=“http://www.saba.com/XML/WDK/Control”/>
7	<wdk:version>1.0</wdk:version>
8	<wdk:model rdf:resource=“searchPerson.xml”/>
9	<wdk:view rdf:resource=“searchPerson.xsl”/>
10	<wdk:widgets
	rdf:resource=“../xsl/widget/wdk_widgets.xsl”/>
11	<wdk:links>
12	<wdk:link
	model=“searchPerson.xml”
	control=“searchPerson.rdf”/>
13	</wdk:links>
14	</rdf:Description>
15	</rdf:RDF>

[00606] The control file contains a Cocoon processing instruction (line 2) that is parsed by the Cocoon engine. The cocoon engine uses the processing instruction to look-up the processor it needs to use to process the document. The Web Content Server 800 installation contains the following entry in the cocoon.properties file:

[00002]

	processor.type.wdk =
	com.saba.web.engine.ControlFileProcessor

[00607] This line tells the cocoon engine that the com.saba.web.engine.ControlFileProcessor java class is responsible for processing all documents that contain a cocoon processing instruction of type=“wdk”.

[00608] The control file processor performs the following steps:

• • [00609] 1. Identifies the model, view and widget files.
  • [00610] 2. Parses the model file and creates a DOM representation of the XML document.
  • [00611] 3. Inserts in the model file DOM:
    • [00612] Cocoon processing instruction to invoke the Web Content Server 800 transformer after the model page is executed. The Web Content Server 800 transformer is responsible for transforming the result of the model page using the widget and then the view XSL stylesheets.
    • [00613] XSLT processing instructions to declare where the widget and view transformation stylesheets are located. This information was extracted from the control file in step 1.
  • [00614] 4. Updates hyperlinks in the model file based link mapping information found in the control file.

[00615] The control file processor returns the document object model containing all these updates, and the Web Content Server 800 engine then processes this DOM.

[heading-00616] Identifying Model, View and Widget File

[00617] The control file contains the following three properties for encoding the three files:

• • [00618] wdk:model: the rdf:resource attribute of this property is the path to the model file. (See line 8 in the example above.)
  • [00619] wdk:view: the rdf:resource attribute of this property is the path to the view file. (See line 9 in the example above.)
  • [00620] wdk:widget: the rdf:resource attribute of this property is the path to the widget file. (See line 10 in the example above.)
    Creating the DOM for the Model Document

[00622] Given the path information in the rdf:resource attribute of the wdk:model property, the actual path is computed based on saba site information. The process of computing the path is almost identical to the process described under the File Loading Algorithm section. The only difference is that if the value of rdf:resource does not begin with the path delimiter character (“/”) then the processor interprets the path as a relative path from the control file. Once the path is computed, the model file is parsed and a DOM representation is generated.

[heading-00623] Updating the Model DOM

[00624] Before the model page (its DOM representation) can be further processed by the wdk engine, a cocoon processing instruction <?cocoon-process type=“xsp”?> is inserted. This processing instruction instructs the engine to first process the model page using the xsp processor (see section below on Custom XSP Processor). The control file processor inserts another processing instruction: <?cocoon-process type=“wdk_xsl”?>. This processing instruction directs the Cocoon engine to use the Web Content Server 800 specific XSLT transformer for the transforming steps (see section below on custom XSLT processor). Furthermore, two <?xml:stylesheet . . . ?> processing instructions are also inserted in the document object model following the above processing instruction. The “href” data component of these instructions identifies the widget and view stylesheets in that order. The Web Content Server 800 specific XSLT transformer will process these two processing instructions to perform the XSL transformations.

[00625] The following Java code shows how the processing instructions are inserted into the DOM:

• • [00626] private void insertNextPI(Document doc, ProcessingInstruction pi) throws ProcessorException

[00002]

{
try {
NodeList nodeList = doc.getChildNodes( );
Node theNode=null;
Node lastPI=null;
// find last PI
for (int i=nodeList.getLength( )−1 ; i >= 0 ; i−−) {
theNode = nodeList.item(i);
if (theNode.getNodeType( ) ==
Node.PROCESSING_INSTRUCTION_NODE){
lastPI=theNode;
break;
}
}
if (lastPI==null) {
// cound not find a PI so just get the first node
theNode=nodeList.item(0);
} else {
//going to do an insertBefore, so we want to move to the next
//node so that this new PI gets inserted AFTER the last PI
theNode=lastPI.getNextSibling( );
if (theNode==null) {
//should always have at least a root node after a PI
throw new ProcessorException(“Error processing control file:
need a root node after a processing instruction”);
}
} // if lastPI==null
doc.insertBefore((Node) pi, theNode);
} catch (DOMException e) {
throw new ProcessorException(“Unexpected error processing
control file: ” + e.toString( ));
}
} /* insertNextPI */

Updating Link Information

[00628] Model pages typically contain links that allow the model page to invoke another page. In order to make model pages reusable with different view pages, page references in a model page always refer to other model pages. This way different control files can reuse the same model page but use two different view pages. However, links pointing to model pages have to be transformed to control page hyperlinks before the final document is produced, since the request URL has to contain information about the control file and not the model file. In order to perform this transformation, the control file contains information about how to map a model page reference to a control page reference. The control file contains a single wdk:links element, which contains a number of wdk:link elements. Each wdk:link element has two attributes: model and control. The model attribute is the hyperlink name of a model file, while the value of the control attribute is the hyperlink name of the control file.

[00629] The control file processor locates the wdk:link and wdk:links elements in the control file DOM using the standard DOM API. Once all wdk:links elements are located, the control file processor inserts a wdk:linkMap element in the wdk:head element of the model DOM, and then inserts one wdk:linkMapEntry for each wdk:link found in the control file using the DOM API. The wdk:linkMapEntry element has the same attributes as the corresponding wdk:link in the control file. This way the mapping information is made available in the model page, and can be used by either the model page itself or the subsequent widget and view transformations. For example, the wdk:link widget makes use of this information to transform model page references to control page URLs.

[heading-00630] Example: The Model DOM Before and After the ControlFileProcessor

[00631] The following code sample shows the XML serialized version of a model file before the ControlFileProcessor updated the DOM.

[00002]

<?xml version=“1.0”?>
<xsp:page language=“java” xmlns:xsp=“http://www.apache.org/1999/XSP/Core”
xmlns:wdktags=“http://www.saba.com/XML/WDK/taglib”>
	<xsp:structure>
	<xsp:include>com.saba.exception.*</xsp:include>
	. . .
	</xsp:structure>
	<wdk:page xmlns:wdk=“http://www.saba.com/XML/WDK”>
	<wdk:head>
	<wdktags:in>
	<wdktags:param name=“sessionKey”/>
	<wdktags:param name=“actionKey” required=“false” type=“String” default=“”/>
	<wdktags:param name=“personSearch”/>
	</wdktags:in>
	<wdktags:out>
	<wdk:param name=“sessionKey” type=“String” required=“true”/>
	<wdk:param name=“actionKey” type=“String” required=“false”/>
	<wdk:param name=“personSearch” type=“String” required=“true”/>
	</wdktags:out>
	<xsp:logic>
	Session sabaSession = SessionManager.getSession(sessionKey);
	String desiredLang = (String)sabaSession.getBlob(“selectedLanguage”);
	</xsp:logic>
	<wdktags:i18n.load resource=“party_labels”>
	<language><xsp:expr>desiredLang</xsp:expr></language>
	</wdktags:i18n.load>
	<wdk:title><wdktags:i18n.label name=“kl18n6000SearchForPeopleLabel”/>
	</wdk:title>
	<wdk:labels>
	<wdk:label name=“busUnitLabel”><wdktags:i18n.label
name=“kl18n6008BusinessUnitLabel”/></wdk:label>
	<wdk:label name=“locLabel”><wdktags:i18n.label
name=“kl18n6000LocationLabel”/></wdk:label>
	<wdk:label name=“firstNameLabel”><wdktags:i18n.label
name=“kl18n6000RegularFirstNameLabel”/></wdk:label>
	<wdk:label name=“lastNameLabel”><wdktags:i18n.label
name=“kl18n6000RegularLastNameLabel”/></wdk:label>
	<wdk:label name=“locationLabel”><wdktags:i18n.label
name=“kl18n6000RegularLocationLabel”/></wdk:label>
	</wdk:labels>
	</wdk:head>
	<wdk:form method=“GET”>
	<wdk:hidden_field>
	<name>sessionKey</name>
	<value><xsp:expr>sessionKey</xsp:expr></value>
	</wdk:hidden_field>
	<wdk:hidden_field>
	<name>actionKey</name>
	<value>search</value>
	</wdk:hidden_field>
	<wdk:model>
	<xsp:logic>
	if (actionKey.equals(“search”))
	{
	<people>
	<wdktags:execute
manager=“com.saba.client.party.beans.PersonCommandManager” command=“searchForPeople”
argument=“personSearch”/>
	</people>
	} /* if actionKey.equals(“search”)*/
	</xsp:logic>
	</wdk:model>
	</wdk:form>
	<wdk:widgets>
	<wdk:input name=“lastNameField”>
	<label><wdktags:i18n.label name=“kl18n6000LastNameLabel”/></label>
	<id>personSearch</id>
	<value><xsp:expr>personSearch</xsp:expr></value>
	</wdk:input>
	<wdk:link name=“go”>
	<id>GO</id>
	<href>searchPerson.xml</href>
	<type>button</type>
	<label><wdktags:i18n.label name=“kl18n6XXXXXGO”/></label>
	<prompt><wdktags:i18n.label name=“kl18n6XXXXXGO”/></prompt>
	</wdk:link>
	</wdk:widgets>
	</wdk:page>
</xsp:page>

[00632] The following code sample shows the same model file after the ControlFileProcessor updated the model file. The changes are shown in bold face:

[00002]

<?xml version=“1.0”?>
<?cocoon-process type=“xsp”?>
<?cocoon-process type=“wdk_xsl”?>
<?xml:stylesheet href=“../xsl/widget/wdk_widgets.xsl”?>
<?xml:stylesheet href=“searchPerson.xsl”?>
<xsp:page language=“java” xmlns:xsp=“http://www.apache.org/1999/XSP/Core”
xmlns:wdktags=“http://www.saba.com/XML/WDK/taglib“>
	<xsp:structure>
	<xsp:include>com.saba.exception.*</xsp:include>
	. . .
	</xsp:structure>
	<wdk:page xmlns:wdk=“http://www.saba.com/XML/WDK”>
	<wdk:head>
	<wdktags:in>
	<wdktags:param name=“sessionKey”/>
	<wdktags:param name=“actionKey” required=“false” type=“String” default=“”/>
	<wdktags:param name=“personSearch”/>
	</wdktags:in>
	<wdktags:out>
	<wdk:param name=“sessionKey” type=“String” required=“true”/>
	<wdk:param name=“actionKey” type=“String” required=“false”/>
	<wdk:param name=“personSearch” type=“String” required=“true”/>
	</wdktags:out>
	<xsp:logic>
	Session sabaSession = SessionManager.getSession(sessionKey);
	String desiredLang = (String)sabaSession.getBlob(“selectedLanguage”);
	</xsp:logic>
	<wdktags:i18n.load resource=“party_labels”>
	<language><xsp:expr>desiredLang</xsp:expr></language>
	</wdktags:i18n.load>
	<wdk:title><wdktags:i18n.label name=“kl18n6000SearchForPeopleLabel”/>
	</wdk:title>
	<wdk:labels>
	<wdk:label name=“busUnitLabel”><wdktags:i18n.label
name=“kl18n6008BusinessUnitLabel”/></wdk:label>
	<wdk:label name=“locLabel”><wdktags:i18n.label
name=“kl18n6000LocationLabel”/></wdk:label>
	<wdk:label name=“firstNameLabel”><wdktags:i18n.label
name=“kl18n6000RegularFirstNameLabel”/></wdk:label>
	<wdk:label name=“lastNameLabel”><wdktags:i18n.label
name=“kl18n6000RegularLastNameLabel”/></wdk:label>
	<wdk:label name=“locationLabel”><wdktags:i18n.label
name=“kl18n6000RegularLocationLabel”/></wdk:label>
	</wdk:labels>
	<wdk:linkMap>
	<wdk:linkMapEntry model=“searchPerson.xml” control=“searchPerson.rdf”/>
	</wdk:linkMap>
	</wdk:head>
	<wdk:form method=“GET”>
	<wdk:hidden_field>
	<name>sessionKey</name>
	<value><xsp:expr>sessionKey</xsp:expr></value>
	</wdk:hidden_field>
	<wdk:hidden_field>
	<name>actionKey</name>
	<value>search</value>
	</wdk:hidden_field>
	<wdk:model>
	<xsp:logic>
	if (actionKey.equals(“search”))
	{
	<people>
	<wdktags:execute
manager=“com.saba.client.party.beans.PersonCommandManager” command=“searchForPeople”
argument=“personSearch”/>
	</people>
	} /* if actionKey.equals(“search”)*/
	</xsp:logic>
	</wdk:model>
	</wdk:form>
	<wdk:widgets>
	<wdk:input name=“lastNameField”>
	<label><wdktags:i18n.label name=“kl18n6000LastNameLabel”/></label>
	<id>personSearch</id>
	<value><xsp:expr>personSearch</xsp:expr></value>
	</wdk:input>
	<wdk:link name=“go”>
	<id>GO</id>
	<href>searchPerson.xml</href>
	<type>button</type>
	<label><wdktags:i18n.label name=“kl18n6XXXXXGO”/></label>
	<prompt><wdktags:i18n.label name=“kl18n6XXXXXGO”/></prompt>
	</wdk:link>
	</wdk:widgets>
	</wdk:page>
</xsp:page>

Custom XSP Processor

[00634] Instead of using the XSP processor of Cocoon, Web Content Server 800 uses a custom XSP processor. To make this happen, the following line is added to the cocoon.properties file:

• • [00635] processor.type.xsp=com.saba.web.engine.SabaXSPProcessor

[00636] This processor adds the following capabilities:

• • [00637] Debugging: The Web Content Server 800 XSP processor can produce intermediate files representing the documents as the model page is transformed from its original form to the java code that is executed and the actual data that is produced by the java code. These intermediate files can be inspected to locate the source of a problem more easily.
  • [00638] Cache control: For debugging purposes it is important to know that the code that executes is the code that the developer has just edited. However, the cocoon engine contains a number of caching mechanisms that make this assumption incorrect sometimes (ie. The code that's executed is code that is in the cache instead of code that the developer has just changed). The Web Content Server 800 XSP processor allows control over caching.
    Producing Intermediate Files for Debugging Purposes

[00640] The SabaXSPProcessor can produce intermediate files as the model file goes through the different transformation steps. The helper classes XSPDebugger and DebuggerConfig are used to control which if any intermediate files should be produced. The following properties are introduced in cocoon.properties for controlling debugging behavior:

• • [00641] wdkdebugoutput
  • [00642] wdkdisablecache
  • [00643] wdkdebug

[00644] The wdkdebug property can have the following values:

• • [00645] off: No debugging information is produced
  • [00646] full: Every intermediate file is produced
  • [00647] wdktags: Only the result of the wdk tag library transformation is output
  • [00648] wdk: Only the result of the widget library transformation is output
  • [00649] xsp: Only the result of the xsp transformation is output.
  • [00650] model: Outputs the result of executing the java code produced from the model page.

[00651] The wdkdebugoutput property can have the following values:

• • [00652] sourcedir: The output files are placed in the same directory where the source documents are read from.
  • [00653] browser: The output files are sent to the browser
  • [00654] repository: The output files are placed in the cocoon repository directory.

[00655] The wdkdisablecache can either be “true” or “false”. If true the cocoon cache is not used.

[00656] The init method of the SabaXSPProcessor creates an instance of the DebuggerConfig class, and the process method creates an instance of XSPDebugger. The XSPDebugger is a subclass of Debugger and it uses the DebuggerConfig object to read the debugger configuration from the cocoon.properties file.

[heading-00657] The Debugger and XSPDebugger Classes

[none]

• • [00658] The Debugger has the following API:
  • [00659] public void readParameters(Dictionary parameters, DebuggerConfig config);

[00660] This method initializes the Debugger with the current debugging property values.

[heading-00661] protected boolean debugThis(String rule);

[00662] The method returns true if the wdkdebug property is either “full” or matches the rule parameter.

[heading-00663] protected boolean browserOnly( );

[00664] The method returns true if the wdkoutput property is set to “browser”.

[heading-00665] public boolean cacheDisabled( );

[00666] Returns true if the wdkdisablecache is true.

[heading-00667] The XSPDebugger introduces the following methods:

[heading-00668] public boolean debugLogicsheet(String rule, Document document);

[00669] Returns true if Debugger.debugThis(rule) is true AND if Debugger.browserOnly( ) is true. If only Debugger.debugThis(rule)is true, then first saves the intermediate result before returning false. public void debugFinalXSP(Document document)

[00670] If the the wdkdebug property is full or set to model then the result of executing the code produced from the model file is output.

[heading-00671] Custom XSLT Processor

[00672] The default XSLT processor that comes with Cocoon performs a single XSLT transformation only. However, Web Content Server 800 requires two XSL transformations after the java code produces the data. The first transformation replaces the widgets with their HTML representation (the widget transformation) while the second transformation renders the data (the view transformation). To make the engine aware of the Web Content Server 800 XSLT processor, the following line is added to the cocoon.properties file:

[00002]

	processor.type.wdk_xsl =
	com.saba.web.engine.WDK_XSLTProcessor

[00673] The Web Content Server 800 XSLT processor takes as input the document object model produced by executing the XSP page. The processor extracts the xml:stylesheet processing instructions from the DOM, and executes XSL transformations using the stylesheet documents referred to by the “href” data element in the processing instructions. (The xml:stylesheet processing instructions were inserted in the source document by the control file processor—see the ControlFileProcessor algorithm section for details). After each transformation step, if the debugger flags are set, the DOM is serialized and saved to a text file.

[00674] The following code snippet shows how the widget and view transformations are performed:

[00002]

	try {
	/* get all stylesheets referred to by this document */
	Vector resources = getResources(document, request, context);
	/* apply each stylesheet in turn */
	Enumeration e = resources.elements( );
	while (e.hasMoreElements( )) {
	Object resource = e.nextElement( );
	this.logger.log(this, “Processing stylesheet ” +
	resource.toString( ), Logger.DEBUG);
	Document stylesheet = getStylesheet(resource, request,
	!xsltDebugger.cacheDisabled( ));
	Document result = this.parser.createEmptyDocument( );
	document = transformer.transform(document, null, stylesheet,
	resource.toString( ), result, params);
	if (xsltDebugger.debugStylesheet(document, resource)) {
	// requested debug output to browser, so done now
	return document;
	}
	}
	return document;
	} catch (PINotFoundException e) {
	return document;
	}

Custom XSP Page Class

[00676] Each XSP page (model page) is transformed to a java object (source code generated, compiled and the class is loaded). In Web Content Server 800 the generated java objects are instances of the SabaXSPPage class, which is a subclass of the XSPPage class. (The XSPPage class is the default class provided by Cocoon.) In order to change the class from XSPPage to SabaXSPPage, the following changes had to be made:

• • [00677] 1. Create a new xsp-java.xsl taglibrary stylesheet based on the default stylesheet that comes with Cocoon:
    • [00678] a. Change the class declaration line to extend SabaXSPPage instead of XSPPage as follows:
    • [00679] public class <xsl:value-of select=“@name”/> extends SabaXSPPage{
    • [00680] b. Invoke the initialization method specific to SabaXSPPage in the populateDocument method:
    • [00681] initializeOnRequest(request, response);

[00682] This method initializes protected site and logger variables. (See below)

• • [00683] 2. Change the cocoon.properties file by adding the following line: processor.xsp java.logicsheet=/com/saba/web/engine/xsp-java.xsl

[00684] The SabaXSPPage class provides model pages access to frequently needed information including:

• • [00685] Site: information about the SabaSite object representing the current saba site.
  • [00686] Path information: extracted from the Saba site object for convenience
  • [00687] Access to a logger for debugging and status messages

[00688] SabaXSPPage declares protected member variables for each:

[00002]

	protected SabaSite	wdkSite;
	protected Logger	wdkLogger;
	protected String	wdkBaseURL;
	protected String	wdkRoot;

[00689] These variables are therefore accessible by model pages and by the tags defined in the wdktags tag library.

[heading-00690] Structure of Model Pages

[00691] Model pages are Extensible Server Page (XSP) pages. XSP pages can contain a mix of static content and content generating programming logic by using xsp directives (tags) defined in the xsp tag library. Furthermore, an XSP page can make use of an indefinite number of application specific tag libraries. A Web Content Server 800 model page uses the wdktags tag library to simplify certain common programming tasks.

[00692] Web Content Server 800 model pages have a very well defined structure. The document element of the page is <xsp:page>. The document element can contain <xsp:structure> and other xsp directives, but it can contain a single non-xsp element only. For a Web Content Server 800 page that element is wdk:page. The wdk:page element consists of the following subsections:

• • [00693] wdk:head—contains internationalized labels, the page title, image references, link mapping information (generated automatically from the control file by the control file processor).
  • [00694] wdk:form—The wdk:form element is one of the elements in the widget library. Since most wdk pages are HTML forms, the wdk:form element is used to generate the HTML form and javascript functions required by a Web Content Server 800 application. For example, a javascript function is generated that can be called by link widgets to submit the form.
  • [00695] wdk:widgets—widgets (input fields, buttons, hyperlinks, etc.) are all listed in the wdk:widgets section.

[00696] The wdk:form element can contain the declaration of hidden fields needed by the application, and it contains a singe wdk:model element. The wdk:model element contains all “data” generated by the page.

[00697] Often all the wdk:model section contains is invocations of Commands that produce the appropriate XML content.

[heading-00698] Separating Content from Interaction

[00699] An important property of model pages is the ability to generate/declare dynamic content (through commands) and interaction elements (widgets) independently of each other. This separation of content and widget generation allows for greater reusability. However, at the end of all the processing, the widgets and the content have to be combined. For example, an input text field (a widget) and the “name” property of a business object have to be connected/combined some way to make sure that that particular text field can display that particular property. This connectivity between model elements and widgets is achieved by Web Content Server 800 tag library tags.

[00700] The wdktags:attachTo tag can be used to “attach” (copy) a particular widget to a model element.

[00701] For example, a software engineer may author the following simple model document:

[00002]

	<xsp:page language= “java”
	xmlns:xsp= “http://www.apache.org/1999/XSP/Core”
	xmlns:wdktags= “http://www.saba.com/XML/WDK/taglib”
	>
	<wdk:page>
	<wdk:head>
	</wdk:head>
	<wdk:form method= “POST”>
	<wdk:model>
	<domain>
	<name>Domain 1</name>
	<id>id1</id>
	</domain>
	<domain>
	<name>Domain 2</name>
	<id>id2</id>
	</domain>
	</wdk:model>
	</wdk:form>
	<wdk:widgets>
	<wdk:input name= “editName”>
	<wdktags:attachTo path= “domain”/>
	<value><wdktags:nodeRef path= “name”/></value>
	</wdk:input>
	</wdk:widgets>
	</wdk:page>
	</xsp:page>

[00702] The document resulting from processing the Web Content Server 800 tag library and the XSP engine execution will be:

[00002]

	<wdk:page>
	<wdk:head>
	</wdk:head>
	<wdk:form>
	<wdk:model>
	<domain>
	<name>Domain 1</name>
	<id>id1</id>
	<wdk:input name= “editName”>
	<value>Domain 1</value>
	</wdk:input>
	</domain>
	<domain>
	<name>Domain 2</name>
	<id>id2</id>
	<wdk:input name= “editName”>
	<value>Domain 2</value>
	</wdk:input>
	</domain>
	</wdk:model>
	</wdk:form>
	<wdk:widgets/>
	</wdk:page>

[00703] Note that the attachTo directive effectively created a copy of the input widget inside each domain element. Furthermore, the nodeRef directive has been replaced with the text value of the element it refers to in its path attribute.

[00704] The following describes the implementation of the attachTo tag.

[00002]

1	<xsl:template match=“*[wdktags:attachTo]”>
2	<xsl:variable name=“rootNode”>
	<xsl:choose>
	<xsl:when test=“wdktags:attachTo/@root”>
	<xsl:value-of
	select=“wdktags:attachTo/@root”/></xsl:when>
	<xsl:otherwise>
WDKDomUtils.getModelNode(xspCurrentNode.getOwnerDocument().
	getDocumentElement())
	</xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
3	<xsp:logic>
	{
	List wdkNodes = WDKDomUtils.getNodes((Element)<xsl:value-of
	select=“$rootNode”/>,“<xsl:value-of
	select=”wdktags:attachTo/@path“/>”);
4	if (wdkNodes == null) {
	throw new RuntimeException(“Could not find node:
	<xsl:value-of select=“wdktags:attachTo/@path“/>”);
	}
	Iterator wdklter = wdkNodes.iterator();
	while (wdklter.hasNext()) {
5	wdkwidgetNode = (Node)wdklter.next();
	wdktagsNodeStack.push(xspCurrentNode);
	xspCurrentNode = wdkwidgetNode;
6	if (xspCurrentNode == null) {
	throw new RuntimeException(“Null node in node list”);
	}
7	<xsp:content>
	<xsl:copy>
	<xsl:apply-templates select=“*|@*”/>
	</xsl:copy>
	</xsp:content>
8	xspCurrentNode = (Node)wdktagsNodeStack .pop();
	}
	}
	</xsp:logic>
	</xsl:template>

[00705] Line 1 specifies the match condition: this template will match any element that contains a wdktags:attachTo sub-element. Section 2 contains XSL logic for determining what root element should be used as the starting point for the value of the path attribute. If the developer specifies a root attribute, then the value of that attribute is used, otherwise the root element defaults to the wdk:model node of the model page. Section 3 invokes the getNodes( ) method on the WDKDomUtils class. That method returns the set of nodes that can be accessed from the root node through the path given in the path attribute of the wdktags:attachTo directive. Section 4 checks for error conditions and sets up the iteration through the set of DOM elements returned in section 3. In section 5 the current xsp node (the value of the xspCurrentNode variable) is saved on a stack, and its value is replaced with the next node from the set of nodes returned in section 3. Since the XSP processor uses the xspCurrentNode variable to mark the current “insertion point”—i.e. the location where the next DOM node will be inserted in the Document, this operation effectively copies the current subtree (the widget) to each node returned in section 3. (Sections 6 and 7 perform the actual copying.) Finally, section 8 restores the value of the xspCurrentNode and resumes the iteration.

[00706] The following section describes the implementation of the nodeRef tag.

[00002]

1	<xsl:template match=“wdktags:nodeRef”>
2	<xsl:variable name=“root”>
	<xsl:choose>
	<xsl:when test=“@source”><xsl:value-of select=“@source”/></xsl:when>
	<xsl:otherwise>wdkwidgetNode</xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
3	<xsp:logic>{
	Element wdkChildNode = WDKDomUtils.getChildNode((Element)<xsl:value-of
	select=“$root”/>,“<xsl:value-of select=”@path“/>”);
	<xsp:content><xsp:expr>WDKDomUtils.getTextValue(wdkChildNode)</xsp:expr></xsp:content>
	}
	</xsp:logic>
	</xsl:template>

[00707] Line 1 specifies the match condition: this rule matches every nodeRef tag. Section 2 determines the root node: if the source attribute is given then the value of that attribute is used, otherwise the value of wdkwidgetNode Java variable is used. The wdkwidgetNode variable is initialized in the wdktags:attachTo template described above. This way, if nodeRef is used in the context of an attachTo tag, the root node is the same node the widget is copied to. The actual node whose value is needed is located by following the path from the root node. Finally, the text value of the node is computed by calling the WDKDomUtils.getTextValue( ) method.

[heading-00708] Structure of View Pages

[00709] View pages are XSLT stylesheets. The role of the view stylesheet is to convert the XML document produced by executing the model file (and the subsequent widget transformation) to a format understood by the user agent. For example, for desktop browsers this typically means conversion to an HTML representation. Since model pages have a well-defined structure, view pages are also highly regular. For example, there are a number of model page elements that should not be rendered (such as wdk:head element and its content should not be copied to the output). Other model pages nodes have a standard representation in HTML (or in the desired output format). For example, the rule for rendering wdk:page is to generate the <html> element, the <head> element containing the <title> element. These common templates are all grouped in a default stylesheet that can be imported using the <xsl:import> directive by every view page. As a result, for simple pages, the view page needs to contain a singe cusomized xsl:template rule that matches on the “wdk:model” node. This template is responsible for rendering the data as well as the widgets.

[heading-00710] Example: Default View Transformation Templates

[00002]

1	<?xml version=“1.0”?>
	<xsl:stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”
	xmlns:wdk=“http://www.saba.com/XML/WDK”>
	<xsl:output method=“xml” indent=“yes”/>
	<xsl:strip-space elements=“*”/>
2	<xsl:template match=“/”>
	<xsl:variable name=“titleLabel”><xsl:value-of select=“//wdk:head/wdk:title”/></xsl:variable>
	<html>
	<head>
	<title><xsl:value-of select=“$titleLabel”/></title>
	</head>
	<body>
	<xsl:apply-templates/>
	</body>
	</html>
	</xsl:template>
3	<xsl:template match=“* | @*|text()|comment()” priority=“−1”>
	<xsl:copy>
	<xsl:apply-templates select=“* | @*|text()|comment()”/>
	</xsl:copy>
	</xsl:template>
4	<!−− eliminate the wdk:head element and all children of wdk:widgets −−>
	<xsl:template match=“wdk:head | wdk:widgets”>
	</xsl:template>
5	<!−− replace widget with span (so we can do CSS on it) and process their children −−>
	<xsl:template match=“wdk:widget”>
	<span class=“{@name}”>
	<xsl:apply-templates/>
	</span>
	<br/>
	</xsl:template>
6	<xsl:template match=“wdk:page”>
	<xsl:apply-templates/>
	</xsl:template>
	</xsl:stylesheet>

[00711] Section 1 defines the namespaces used in the stylesheet. Section 2 defines the root level template. This template produces the html tags, and generates the html head element complete with the title element. Section 3 defines the default template: every element, attribute, text and comment is copied to the resulting document, unless a more specific template provides different instructions. Section 4 specifies a template for eliminating the wdk:head and wdk:widgets elements and their contents (since the contents of these tags should not be rendered using the default template defined in section 3). Section 5 introduces a template for transforming every widget by wrapping them into a span element replacing the wdk:widget “wrapper”. This makes it possible to use CSS styling on a per named-widget basis. Finally, section 6 defines the template for processing the wdk:page element.

[heading-00712] A View Page Example

[00002]

1	<?xml version=“1.0”?>
	<xsl:stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”
	xmlns:wdk=“http://www.saba.com/XML/WDK”>
2	<xsl:import href=“../xsl/view/wdk_defaultview.xsl”/>
3	<xsl:template match=“wdk:model”>
4	<h2 align=“center”><xsl:value-of select=“/wdk:page/wdk:head/wdk:title”/></h2>
5	<p>
	<xsl:value-of select=“/wdk:page/wdk:head/wdk:labels/wdk:label[@name=‘nameLabel’]”/>
6	<xsl:for-each select=“parents/parent”>
	<xsl:value-of select=“name”/>
	<xsl:text> &gt; </xsl:text>
	</xsl:for-each>
	<xsl:value-of select=“parents/leaf/name”/>
	</p>
7	<xsl:apply-templates select=“//wdk:widget”/>
8	</xsl:template>
	</xsl:stylesheet>

[00713] Section 2 imports the stylesheet containing the default templates. Line 3 defines the rule for processing the wdk:model node. Line 4 displays the title of the page by accessing the wdk:title tag inside the wdk:head tag. Section 6 iterates through each “parent” element inside the wdk:model element and displays its name. In section 7 any widget produced by the model page is displayed.

[heading-00714] The wdk taglibrary

[00715] The wdk taglibrary contains a number of tags to simplify the development wdk model pages. The tag library includes tags for:

• • [00716] handling resource bundles for page internationalization,
  • [00717] invoking commands to generate XML representation of the data retrieved from the database,
  • [00718] managing the connectivity between widgets and the produced data model,
  • [00719] managing the input and output parameters to the model page,
  • [00720] etc.

[00721] To make the tag library accessible by the processing engine, the following line is inserted in cocoon.properties:

[00722] processor.xsp.logicsheet.wdktags.java=s:/sys/java/web/com/saba/web/xsl/taglib/wdk_taglib.xsl

[00723] The value of the above property identifies the location of the taglibrary stylesheet. The taglibrary stylesheet contains a number of xsl:import directives to import templates responsible for implementing subsets of tags and it also contains a number of default templates, as the code example below shows:

[00002]

<?xml version=“1.0” encoding=“UTF-8”?>
<xsl:stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”
xmlns:xsp=“http://www.apache.org/1999/XSP/Core”
xmlns:wdktags=“http://www.saba.com/XML/WDK/taglib”
xmlns:wdk=“http://www.saba.com/XML/WDK”>
<xsl:preserve-space elements=“*”/>
<xsl:include href=“wdk_param.xsl”/>
<xsl:include href=“wdk_i18n.xsl”/>
<xsl:include href=“wdk_command.xsl”/>
<xsl:include href=“wdk_control.xsl”/>
<xsl:include href=“wdk_site.xsl”/>
<xsl:template match=“xsp:page”>
<xsl:copy>
<!−− need to explicitly call some logic in the wdk_command stylesheet −−>
<xsl:call-template name=“command_header”/>
<!−− need to explicitly call some logic in the control stylesheet −−>
<xsl:call-template name=“control_header”/>
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>
<xsl:template match=“@*|*|text()|processing-instruction()|comment()” priority=“−1”>
<xsl:copy>
<xsl:apply-templates select=@*|*|text()|processing-instruction()|comment()”/>
</xsl:copy>
</xsl:template>
<xsl:template match=“wdk:head”>
<xsl:copy>
<wdk:site>
<href>/<xsp:expr>wdkRoot</xsp:expr>/</href>
<imageRoot><xsp:expr>wdkSite.getImageRoot()</xsp:expr></imageRoot>
<sabaservlet><xsp:expr>WDKSabaUtil.getAssociatedSabaSiteName(wdkRoot)</xsp:expr></sabaservlet
>
<sitename><xsp:expr>wdkSite.getName()</xsp:expr></sitename>
</wdk:site>
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>

An Example: wdktags:param

[00725] The wdktags:param is one of the tags defined in the wdk tag library. The purpose of this tag is to simplify the extraction of parameters from the HttpServletRequest object. Traditionally, JSP, XSP or servlet programmers have to write a number of lines of code for the parameters they want to process. The code for each parameter is typically similar to the following:

[00002]

	String param = request.getParameter(“param”);
	if(param == null) {
	param = “some default”;
	}

[00726] The wdktags:param tag intends to simplify this by allowing developers to declare what parameters they want to use in the model page, and the mundane task of extracting the parameter is performed by the tag itself. Thus, Web Content Server 800 developer can write the following in the <wdk:head> section of the model page:

[00002]

	<wdktags:in>
	<wdktags:param name= “param” type= “String”
	default= “some default” required= “true”/>
	</wdktags:in>

[00727] Each parameter can be defined with a single line of XML code and as a result of this line the developer can use a Java variable named “param” in their code wherever the value of the “param” HttpRequest parameter is needed. The wdktags:param tag is implemented in wdk_param.xsl, and is imported by the main taglibrary stylesheet. The following code shows the implementation of wdktags:param:

[00002]

1	<?xml version=“1.0” encoding=“UTF-8”?>
	<xsl:stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”
	xmlns:xsp=“http://www.apache.org/1999/XSP/Core”
	xmlns:wdktags=“http://www.saba.com/XML/WDK0/taglib”>
2	<xsl:template match=“wdktags:in/wdktags:param”>
3	<xsp:logic>
	<xsl:variable name=“paramName”><xsl:value-of select=“@name”/></xsl:variable>
	<xsl:variable name=“paramType”>
	<xsl:choose>
	<xsl:when test=“not(@type)”>String</xsl:when>
	<xsl:when test=“@type=′ID′″>String</xsl:when>
	<xsl:otherwise><xsl:value-of select=“@type”/></xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
	<xsl:variable name=“paramRequired”>
	<xsl:choose>
	<xsl:when test=“not(@required)”>false</xsl:when>
	<xsl:otherwise><xsl:value-of select=“@ required”/></xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
	<xsl:variable name=“paramDefault”>
	<xsl:choose>
	<xsl:when test=“@default!=“”><xsl:value-of select=“@ default”/></xsl:when>
	<xsl:when test=“@default=“”>“”</xsl:when>
	<xsl:when test=“not(@default) and @type=‘String’”>“”</xsl:when>
	<xsl:otherwise>null</xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
4	<xsl:value-of select=“$paramType”/><xsl:text> </xsl:text><xsl:value-of
	select=“$paramName”/>=request.getParameter(“<xsl:value-of select=“$paramName”/>”);
	if (<xsl:value-of select=“$paramName”/> == null)
	<xsl:value-of select=“ $paramName”/> = <xsl:value-of select=“$paramDefault”/>;
	</xsp:logic>
	</xsl:template>
	</xsl:stylesheet>

[00728] Section 1 declares all namespaces used in the stylesheet. In line 2 the match condition is given for the template. This template matches on every wdktags:param tag inside a wdktags:in tag. This nested condition is necessary, because a different template may transform wdktags:param tags inside the wdktags:out tag. Section 3 computes the values to use for parameter type and parameter default value. These values are either determined from the values of “type” and “default” attributes of the wdktags:param tag, or default values are selected (the java String class for type, and the java null constant for default). Section 4 produces the java code declaring the java variable by the name given in the “name” attribute of the param tag, and the value is initialized either from the HttpServletRequest object or by using the default value computed in line 2.

[heading-00729] Tags Defined in the Web Content Server 800 Tag Library

[00730] wdktags:param Provides a convenient method for declaring and using parameters passed in through the HttpServletRequest.

[00731] wdktags:siteRef: Generates an absolute URL from a relative URL based on the current site information.

[00732] wdktags:execute: XML fragments produced by Java objects (Commands) can be embedded in the resulting model document using the execute tag.

[00733] wdktags:i18n.load: Declares the i18n resource bundle to use for the labels in the page.

[00734] wdktags:i18n.path: Generates internationalized image path information using site parameters and information from the resource bundle specified by wdktags:i18n.load.

[00735] wdktags:i18n.label: Retrieves internationalized labels from the resource bundle specified by wdktags:i18n.load.

[00736] wdktags:attachTo and wdktags:nodeRef: As described above these tags can be used to assign widgets to model elements and to add data dependent information to widgets.

[00737] wdktags:repeat: Provides the capability to replicate widget components based on elements in the generated model. Used mainly by list widgets to generate the set of options dynamically.

[heading-00738] The Widget Library

[00739] The Web Content Server 800 widget library contains rules (XSLT templates) for transforming a number of widgets to their HTML representation. The widget library provides a level of abstraction between the user interaction component (e.g., a text input field) and its presentation (e.g., an HTML input field or a WML input field). This way the content producing model pages can be reused by different control files—one may deliver the content to a desktop browser using the HTML widget library, while another may deliver the same content to a handheld device using a modified version of the widget library (e.g., using WML).

[00740] The widget library contains widgets for most commonly used inputs and controls, such as:

• • [00741] Buttons and links: The link widget can be used to display an image button or regular hyperlink;
  • [00742] List widgets: the list widget can be used to display common drop-down menus, set of radio boxes or set of check boxes;
  • [00743] Input widgets for entering and displaying text values and passwords;
  • [00744] Hidden variables: for storing values in the webpage without displaying them;
  • [00745] Etc.
    An Example: wdk:input

[00747] The wdk:input widget represents the abstract notion of a text field. If the model page developer needs a text field to get information from the user, he or she needs to use the wdk:input widget. Here is an example of using the input widget:

[00002]

	<wdk:input name= “inputZip”>
	<id>inputZip</id>
	<size>5</size>
	<maxlength>5</maxlength>
	<value>60202</value>
	<label>Enter the zip code</label>
	<required>false</required>
	<password>false</password>
	</wdk:input>

[00748] The widget transformation transforms this document fragment to the following:

[00002]

<wdk:widget name= “inputZip”>
<span align= “left” class= “Input_Label”>Enter the zip
code</span>
&nbsp;
<span align=“left” class= “Input_Field”>
<input type= “text” name= “inputZip”  size= “5” maxlength= “5”
value= “60202”/>
</span>
</wdk:widget>

[00749] Note that the transformed version of the widget is “wrapped into” wdk:widget tags. This makes it very simple for the view transformation to reference the entire widget (e.g. by using <xsl:apply-templates select=“wdk:widget [@name=‘inputZip’]/>). Also note that the label and the field parts of the widget are wrapped in <span> tags with the class attribute set to Input_Label and Input_Field, respectively. These class attributes can be used to customize the look and feel of the input widget by using Cascading Stylesheets (CSS) or by writing specific XSLT templates in the view transformation. For example, the following view transformation template will set all input labels in the page to use Arial font:

[00002]

	<xsl:template match= “span[@class= ‘Input_Label’]”>
	<span style= “font-family:Arial”>
	<xsl:apply-templates select= “*”/>
	</span>
</xsl:template>

[00750] The wdk:input widget is implemented as XSLT templates as shown below:

[00002]

1	<xsl:template match=“wdk:input”>
	<xsl:variable name=“formElement”>
	<xsl:choose>
	<xsl:when test=“boolean(id)”>
	<xsl:value-of select=“normalize-space(id)”/>
	</xsl:when>
	<xsl:otherwise>
	<xsl:value-of select=“@name”/>
	</xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
2	<wdk:widget name=“{@name}”>
3	<span align=“left” class=“Input_Label”>
4	<xsl:if test=“required=‘TRUE’”>
	<xsl:attribute name=“style”>color: red</xsl:attribute>
	</xsl:if>
	<xsl:value-of select=“label”/>
	</span>
	&#160;
5	<span align=“left” class=“Input_Field”>
	<xsl:choose>
	<xsl:when test=“normalize-space(password)=‘true’”>
	<input name=“{$formElement}” type=“password”>
	<xsl:call-template name=“input_attributes”/>
	</input>
	</xsl:when>
	<xsl:otherwise>
	<input name=“{$formElement}”type=“text”>
	<xsl:call-template name=“input_attributes”/>
	</input>
	</xsl:otherwise>
	</xsl:choose>
	</span>
6	</wdk:widget>
	</xsl:template>
7	<xsl:template name=“input_attributes”>
	<xsl:if test=“boolean(size)”>
	<xsl:attribute name=“size”><xsl:value-of select=“normalize-space(size)”/></xsl:attribute>
	</xsl:if>
	<xsl:if test=“boolean(maxlength)”>
	<xsl:attribute name=“maxlength”><xsl:value-of select=“normalize-space(maxlength)”/></xsl:attribute>
	</xsl:if>
	<xsl:if test=“boolean(value)”>
	<xsl:attribute name=“value”><xsl:value-of select=“normalize-space(value)”/></xsl:attribute>
	</xsl:if>
	</xsl:template>

[00751] Section 1 contains the match condition for the template: every wdk:input element in the document will be transformed using this template. In section 1 the name of the input field is computed as well. Section 2 shows that this widget (just like all the other widgets) is nested inside a wdk:widget element, which makes it simpler to place widgets in the view transform. Section 3 shows how the different components (the label and the actual text field) are embedded in an HTML span element. In section 4 the color of the text label is determined based on the “required” sub-element of the wdk:input widget. The logic in section 5 determines what type of text field to generate: either “password” or regular “text” field. Section 7 shows the template called from section 5 to fill in the attributes of the generated HTML input element.

[heading-00752] List of Widgets Defined in the wdk Widget Library

[00753] wdk:hidden_element: Represents an HTML hidden element. The widget generates the required element and Javascript functions that can be invoked to set the value of this element.

[00754] wdk:form: Generates the HTML form element and Javascript functions needed to manage the form.

[00755] wdk:input: Represents a single line text element. Can render the widget as a PASSWORD or TEXT HTML form field.

[00756] wdk:list: Represents a widget for selecting an item from a set of predefined items. Supports four different HTML renderings:

• • [00757] Dropdown list
  • [00758] List box
  • [00759] Checkbox set
  • [00760] Radiobutton set

[00761] wdk:link: Represents a link or button. Besides submitting the form, the link widget can be used to:

• • [00762] Pass parameters with the invoked URL using <field> subelements;
  • [00763] Execute an unlimited number of javascript functions before (or instead of) submission;
  • [00764] Open popup-windows and initialize the popup-window variables.
  • [00765] Process the data returned by the popup window invoked by the link
    Commands

[00767] Model pages are responsible for producing an XML representation of the content of the page. This content typically comes from executing complex business logic (e.g., running database queries, exercising business APIs, etc.). Although model pages (being XSP pages) are capable of including programming logic, including a large amount of code in an XSP page makes it hard to maintain. To solve this problem Web Content Server 800 introduces an implementation of the Command pattern (Gamma et al.). A developer can invoke a command from a model page by using the execute Web Content Server 800 tag library tag. For example, the following line

[00002]

<wdktags:execute manager= “CatalogCommandMgr” command= “search” />

invokes the execute method of the ICommand object registered under the “search” key of the CatalogCommandMgr and replaces the element with the XML result of executing the method. Here is the implementation of the wdktags:execute tag:

[00002]

<?xml version=“1.0”?>
<xsl stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform”
xmlns:xsp=“http://www.apache.org/1999/XSP/Core”
xmlns:wdktags=“http://www.saba.com/XML/WDK/taglib”>
<xsl:template name=“command_header”>
	<xsp:structure>
	<xsp:include>com.saba.xml.*</xsp:include>
	<xsp:include>com.saba.web.dk.*</xsp:include>
	</xsp:structure>
	<xsp:logic>
	ICommand cmd = null;
	private ICommand getCommand(String mngrName, String cmdName)
	throws Exception {
	Class mngrClass = Class.forName(mngrName);
	ICommandManager mngr = (ICommandManager)mngrClass.newInstance( );
	return cmd = mngr.getCommand(cmdName);
	}
	Node executeCommand(String mngrName, String cmdName,
	HttpServletRequest request, HttpServletResponse response,
	Document document, Object argument)
	throws Exception {
	StringWriter writer = new StringWriter( );
	IXMLVisitor visitor = XML.getDefaultXMLVisitor(writer);
	cmd = getCommand(mngrName, cmdName);
	if (argument != null)
	cmd.execute(request, visitor, argument);
	else
	cmd.execute(request, visitor);
	String xml = writer.toString( );
	if (xml.length( ) != 0) {
	InputSource source = new InputSource(new StringReader(writer.toString( )));
	XercesParser parser = new XercesParser( );
	Document doc = parser.parse(source, false);
	return document.importNode(doc.getFirstChild( ), true);
	}
	else {
	return null;
	}
	}
	</xsp:logic>
</xsl:template>
<xsl:template match=“wdktags:execute”>
	<xsl:variable name=“returnVariable”>
	<xsl:choose>
	<xsl:when test=“boolean(@return)”><xsl:value-of select=“@return”/></xsl:when>
	<xsl:otherwise>wdkExecuteReturn<xsl:value-of select=“generate-id( )”/></xsl:otherwise>
	</xsl:choose>
	</xsl:variable>
	<xsp:logic>
	Node <xsl:value-of select=“$returnVariable”/>;
	</xsp:logic>
	<xsp:logic> {
	String wdkMngrName = “<xsl:value-of select=“@manager”/>”;
	String wdkCmdName = “<xsl:value-of select=“@command”/>”;
	Object wdkArgument = null;
	<xsl:if test=“boolean(@argument)”>
	wdkArgument = (Object) <xsl:value-of select=“@argument”/>;
	<xsl:if>
	<xsl:value-of select=“$returnVariable”/> = (Node)executeCommand(wdkMngrName,
wdkCmdName, request, response, document, wdkArgument);
	}
	</xsp:logic>
	<xsp:expr><xsl:value-of select=“$returnVariable”/></xsp:expr>
</xsl:template>
</xsl:stylesheet>