WO2001009794A2 - Systeme, procede et article de production pour une architecture basee sur le commerce electronique - Google Patents

Systeme, procede et article de production pour une architecture basee sur le commerce electronique Download PDF

Info

Publication number
WO2001009794A2
WO2001009794A2 PCT/US2000/020704 US0020704W WO0109794A2 WO 2001009794 A2 WO2001009794 A2 WO 2001009794A2 US 0020704 W US0020704 W US 0020704W WO 0109794 A2 WO0109794 A2 WO 0109794A2
Authority
WO
WIPO (PCT)
Prior art keywords
ofthe
component
application
business
user interface
Prior art date
Application number
PCT/US2000/020704
Other languages
English (en)
Other versions
WO2001009794A3 (fr
Inventor
Roy A. Underwood
Original Assignee
Accenture Llp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Accenture Llp filed Critical Accenture Llp
Priority to AU67504/00A priority Critical patent/AU6750400A/en
Publication of WO2001009794A2 publication Critical patent/WO2001009794A2/fr
Publication of WO2001009794A3 publication Critical patent/WO2001009794A3/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
    • G06Q10/00—Administration; Management
    • G06Q10/10—Office automation; Time management
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/451—Execution arrangements for user interfaces
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/465—Distributed object oriented systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/466—Transaction processing

Definitions

  • the present invention relates to software framework designs and more particularly to providing a resources e-commerce technical architecture (ReTA).
  • ReTA resources e-commerce technical architecture
  • the Internet is a worldwide interconnection of computer networks that communicate using a common protocol. Millions of computers, from low end personal computers to high-end super computers are coupled to the Internet.
  • the Web World-Wide-Web
  • CERN the European Particle Physics Laboratory
  • the Web is a wide-area hypermedia information retrieval system aimed to give wide access to a large universe of documents.
  • the Web was known to and used by the academic/research community only. There was no easily available tool which allows a technically untrained person to access the Web.
  • Mosaic graphical user interface
  • the architecture ofthe Web follows a conventional client-server model.
  • client and server are used to refer to a computer's general role as a requester of data (the client) or provider of data (the server).
  • client and Web documents reside in servers.
  • Web clients and Web servers communicate using a protocol called "HyperText Transfer Protocol" (HTTP).
  • HTTP HyperText Transfer Protocol
  • a browser opens a connection to a server and initiates a request for a document.
  • the server delivers the requested document, typically in the form of a text document coded in a standard Hypertext Markup Language (HTML) format, and when the connection is closed in the above interaction, the server serves a passive role, i.e., it accepts commands from the client and cannot request the client to perform any action.
  • HTML Hypertext Markup Language
  • the communication model under the conventional Web environment provides a very limited level of interaction between clients and servers.
  • increasing the level of interaction between components in the systems often makes the systems more robust, but increasing the interaction increases the complexity ofthe interaction and typically slows the rate ofthe interaction.
  • the conventional Web environment provides less complex, faster interactions because ofthe Web's level of interaction between clients and servers.
  • a system, method and article of manufacture provide a resources e-commerce technical architecture where context objects are shared among a plurality of components executed on a transaction server. Services are also accessed within the server without a need for knowledge of an application program interface ofthe server. Application consistency is maintained by referencing text phrases through a short codes framework. Additionally, a graphical user interface is also generated for the resources e-commerce technical architecture.
  • Figure 1 illustrates an exemplary hardware implementation of one embodiment ofthe present invention
  • Figure 1.1 illustrates a flowchart for a codes table framework that maintains application consistency by referencing text phrases through a short codes framework according to an embodiment ofthe present invention
  • Figure 1.2 is a flowchart depicting a method for providing an interface between a first server and a second server with a proxy component situated therebetween;
  • Figure 1.3 shows the execution architecture for components that make up the SAP Framework Execution Architecture according to an embodiment ofthe present invention
  • Figure 1.4 is a flowchart illustrating a method for sharing context objects among a plurality of components executed on a transaction server
  • Figure 2 illustrates the create component instances method according to an embodiment ofthe present invention
  • FIG. 3 illustrates multiple components in the same transaction context according to an embodiment ofthe present invention
  • Figure 4 illustrates the forcing of a component's database operations to use a separate transaction according to an embodiment ofthe present invention
  • Figure 5 illustrates the compose work form multiple activities in the same transaction according to an embodiment ofthe present invention
  • Figure 6 illustrates JIT activation where MTS intercepts the Customer creation request, starts a process for the Customer package containing Customer component, creates the ContextObject and returns a reference to the client according to an embodiment ofthe present invention
  • Figure 7 illustrates JIT activation when the customer object has been deactivated (the customer object is grayed out) according to an embodiment ofthe present invention
  • Figure 8 is a flowchart depicting a method for providing an activity framework
  • Figure 8.1 is an illustration ofthe MTS runtime environment according to an embodiment ofthe present invention.
  • Figure 9 is a flowchart illustrating a method for accessing services within a server without a need for knowledge of an application program interface ofthe server;
  • Figure 9.1 illustrates the different layers in a Site Server framework architecture according to an embodiment ofthe present invention
  • Figure 10 illustrates schema attributes and classes, with class "Role” and attribute “RoleName” shown;
  • Figure 11 illustrates the creating of Container "Roles” according to an embodiment ofthe present invention
  • Figure 12 is an illustration of a graphic display at a point where a user has right-clicked on the Schema folder and selected New - Attribute according to an embodiment ofthe present invention
  • Figure 13 illustrates the adding of different Roles according to an embodiment ofthe present invention
  • Figure 14 illustrates an example ofthe graphic display showing the attributes of member "Joe Bloggs" according to an embodiment ofthe present invention
  • Figure 15 is a flowchart that illustrates a method for handling events in a system
  • Figure 15.1 illustrates a ReTA Event Handler framework that manages the informational, warning and enor events that an application raises according to an embodiment ofthe present invention
  • Figure 16 is a flowchart depicting a method for managing user information
  • Figure 16.1 illustrates a User framework which enables two approaches to maintaining user information according to an embodiment ofthe present invention
  • Figure 17 is a flowchart that illustrates a method for managing business objects in a system that includes a plurality of sub-activities which each include sub-activity logic adapted to generate an output based on an input received from a user upon execution, and a plurality of activities which each execute the sub-activities in a unique manner upon being selected for accomplishing a goal associated with the activity;
  • Figure 17.1 shows a Sub Activity component using the Persistence framework to retrieve a Customer Object from the Database according to an embodiment ofthe present invention
  • Figure 18 is a flow chart depicting a method for persisting information during a user session
  • Figure 18.1 illustrates a Session Flow Diagram - On Session Start according to an embodiment ofthe present invention
  • Figure 19 illustrates a Session Flow Diagram - On Start ASP Page according to an embodiment ofthe present invention
  • Figure 20 is a flow chart illustrating a method for generating a graphical user interface
  • Figure 20.1 is an illustration showing the steps for generating a HTML page consisting of a form with a TextBox, a DropDown list and a PushButton according to an embodiment ofthe present invention
  • Figure 21 is a flow chart depicting a method for software configuration management
  • Figure 21.1 is an illustration of an IDEA framework on which the ReTA Development Architecture Design is based according to an embodiment ofthe present invention
  • Figure 22 illustrates the Configuration Management Life Cycle according to an embodiment of the present invention
  • Figure 23 illustrates the change control 'pipeline' and each phase within the pipeline according to an embodiment of the present invention
  • FIG. 24 depicts the application of Roles within the Microsoft Transaction Server (MTS) management console according to an embodiment ofthe present invention
  • Figure 25 illustrates an environment migration process that guides development within ReTA engagement environments according to an embodiment ofthe present invention
  • Figure 26 is an illustration of a Development Unit test for existing applications according to an embodiment ofthe present invention.
  • Figure 27 illustrates an assembly test for existing applications according to an embodiment ofthe present invention
  • Figure 28 illustrates a system test for existing applications according to an embodiment ofthe present invention
  • Figure 29 is a flowchart for production of existing applications according to an embodiment of the present invention.
  • Figure 30 illustrates a graphic display of Visual Source Safe according to an embodiment ofthe present invention
  • Figure 31 illustrates a frame of PVCS Version Manager I-Net Client according to an embodiment ofthe present invention
  • Figure 32 is an illustration of a Build Source Control Model according to an embodiment ofthe present invention
  • Figure 33 illustrates an Assembly Test phase control mode according to an embodiment ofthe present invention
  • Figure 34 illustrates a Microsoft Visual SourceSafe abels' dialog box according to an embodiment of the present invention
  • Figure 35 illustrates a Database Diagram within Visual Studio according to an embodiment of the present invention
  • Figure 36 illustrates Object Modeling within Rational Rose according to an embodiment ofthe present invention
  • Figure 37 illustrates directly calling a wrapped CICS component according to an embodiment of the present invention
  • Figure 38 illustrates indirectly calling a wrapped CICS component according to an embodiment ofthe present invention
  • Figure 39 illustrates RSW eTest Automated Testing Tool according to an embodiment ofthe present invention
  • Figure 40 is an illustration which describes the physical configuration necessary for ReTA development according to an embodiment ofthe present invention.
  • Figure 41 illustrates the application & architecture configuration for a typical ReTA Build environment according to an embodiment ofthe present invention
  • Figure 42 illustrates the application & architecture configuration for a typical ReTA Build environment according to an embodiment ofthe present invention
  • Figure 43 illustrates an IDEA Framework with components in scope ReTA Phase 1 according to an embodiment ofthe present invention
  • Figure 44 illustrates a NCAF Framework with the shaded components in scope for Phase 1 according to an embodiment ofthe present invention
  • Figure 45 illustrates a MODEnc Framework according to an embodiment ofthe present invention
  • Figure 46 illustrates a NCAF Framework according to an embodiment ofthe present invention
  • Figure 47 illustrates the components that comprise the ReTA execution architecture and their physical location according to an embodiment ofthe present invention
  • Figure 48 illustrates a MODEnc Framework for Operations Architecture according to an embodiment ofthe present invention
  • Figure 49 is an illustrative representation of a solicited event resulting from the direct (synchronous) polling of a network component by a network management station according to an embodiment ofthe present invention
  • Figure 50 is an illustrative representation of when an unsolicited event occurs when a network component sends (asynchronously) data to the network management station according to an embodiment ofthe present invention
  • Figure 51 illustrates event management in a net-centric environment according to an embodiment ofthe present invention
  • Figure 52 illustrates event management in an Intranet-based net-centric model according to an embodiment ofthe present invention
  • Figure 53 illustrates event management when using an Extranet-based net-centric model according to an embodiment ofthe present invention
  • Figure 54 illustrates the tables and relationships required for the ReTA Phase 1 Architecture Frameworks according to an embodiment ofthe present invention
  • Figure 55 illustrates tables and relationships required for the ReTA Phase 1 validation application according to an embodiment ofthe present invention
  • Figure 56 illustrates the physical configuration of a possible ReTA-engagement development environment according to an embodiment ofthe present invention
  • Figure 57 illustrates the physical configuration of possible ReTA-based Assembly, Product and Performance testing environments according to an embodiment ofthe present invention
  • Figure 58 illustrates Separate Web and Application Servers according to an embodiment of the present invention
  • Figure 59 illustrates a Single Web and Application Server according to an embodiment ofthe present invention
  • Figure 60 illustrates a Commerce Membership Server [Membership Authentication] properties view according to an embodiment ofthe present invention
  • Figure 61 illustrates a Membership Directory Manager Properties Dialog according to an embodiment ofthe present invention
  • Figure 62 is an illustration of a Membership Server Mapping Property according to an embodiment ofthe present invention.
  • Figure 64 illustrates the web application being placed under the "Member" directory of "cm” in Windows Explorer according to an embodiment ofthe present invention
  • Figure 65 depicts a typical ReTA engagement development environment according to an embodiment ofthe present invention
  • Figure 66 illustrates the development environment configuration for a ReTA Phase 1 engagement according to an embodiment of the present invention
  • Figure 67 illustrates an interface associated with the ability of inserting or removing statements within a block without worrying about adding or removing braces according to an embodiment of the present invention
  • Figure 68 shows a Visual J++ Build Environment according to an embodiment of the present invention
  • Figure 69 shows an interface for attaching to the MTS Process for debugging according to an embodiment ofthe present invention
  • Figure 70 shows an interface for debugging an Active Server Page (example global. asa file) according to an embodiment ofthe present invention
  • Figure 71 illustrates an example of Rose generated java file and javadoc comments according to an embodiment ofthe present invention
  • Figure 72 is a flowchart illustrating a method for testing a technical architecture
  • Figure 72.1 illustrates the application & architecture configuration for a typical ReTA Build environment according to an embodiment ofthe present invention
  • Figure 73 illustrates that the code for technology architecture assembly test may be migrated from the technology architecture component test environment as defined in the migration procedures according to an embodiment ofthe present invention
  • Figure 74 illustrates the application & architecture configuration for a typical ReTA Build environment according to an embodiment ofthe present invention
  • Figure 75 illustrates the physical characteristics ofthe testing environment to be utilized during the Performance Testing Phases according to an embodiment ofthe present invention
  • Figure 76 is a flow chart depicting a method for managing change requests in an e-commerce environment
  • Figure 76.1 illustrates a framework associated with the change tracker according to an embodiment ofthe present invention
  • Figure 77 illustrates the Change Tracker Main Window according to an embodiment ofthe present invention
  • Figure 78 illustrates the Change Request Detail Screen according to an embodiment ofthe present invention
  • Figure 79 illustrates a History of Changes Window according to an embodiment ofthe present invention
  • Figure 80 illustrates the Ad-Hoc Reporting Window according to an embodiment ofthe present invention
  • Figure 81 illustrates the Manager Reporting Window according to an embodiment ofthe present invention
  • Figure 82 illustrates the Migration Checklist Window according to an embodiment ofthe present invention
  • Figure 83 is a flow chart illustrating a method for managing issues in an e-commerce environment
  • Figure 83.1 illustrates the Issue Tracker Main Screen according to an embodiment ofthe present invention
  • Figure 84 illustrates the New Issue Screen according to an embodiment ofthe present invention
  • Figure 85 illustrates the Modify Issue Screen according to an embodiment ofthe present invention
  • Figure 86 illustrates the Report Selection Screen according to an embodiment ofthe present invention
  • Figure 87 is a flow chart depicting a method for network performance modeling
  • Figure 87.1 illustrates the end to end process associated with Performance Modeling according to an embodiment ofthe present invention
  • Figure 88 illustrates the Effective Network Performance Management according to an embodiment ofthe present invention
  • Figure 89 illustrates an example of overhead introduced at lower layers according to an embodiment ofthe present invention.
  • Figure 90 illustrates a graph depicting a Network Usage Profile according to an embodiment of the present invention.
  • Figure 91 illustrates a Network Layout according to an embodiment ofthe present invention
  • Figure 92 illustrates how the four tool categories relate to each other according to an embodiment ofthe present invention.
  • Figure 93 is a flow chart depicting a method for managing software modules during development
  • Figure 93.1 illustrates the PVCS Migration Flow according to an embodiment ofthe present invention
  • Figure 94 illustrates SCM Planning according to an embodiment ofthe present invention
  • Figure 95 illustrates an Identify CM Units & Baselines Process Flow according to an embodiment ofthe present invention
  • Figure 96 illustrates a manner in which CM Repositories and Practices Process Flow are established according to an embodiment ofthe present invention
  • Figure 97 illustrates the Establish Change Control Process according to an embodiment ofthe present invention
  • Figure 98 illustrates Collect Metrics and Identify CI Activities according to an embodiment of the present invention
  • Figure 99 illustrates the Review/Establish Project Security according to an embodiment ofthe present invention
  • Figure 100 illustrates the Determine Training Requirements according to an embodiment of the present invention
  • Figure 101 illustrates the Create Project CM Plan according to an embodiment ofthe present invention
  • Figure 102 shows the Manage CM Repository Process Flow according to an embodiment ofthe present invention
  • Figure 103 is a flow chart illustrating a method for providing a system investigation report workbench
  • Figure 103.1 illustrates a SIR Workbench Main Window screen which provides navigation buttons for adding new SIRs, viewing existing SIRs, viewing/printing existing reports and help according to an embodiment ofthe present invention
  • Figure 104 illustrates New SIR window displayed upon select the New button on the Main Window according to an embodiment ofthe present invention
  • Figure 105 illustrates a window for reviewing and modifying existing SIRs according to an embodiment ofthe present invention
  • Figure 106 illustrates the Change Control Details Window according to an embodiment ofthe present invention
  • Figure 107 illustrates a Report Selection Screen upon selection the Report button from the main menu according to an embodiment ofthe present invention
  • Figure 108 illustrates a graphic display of SourceSafe Administrator according to an embodiment ofthe present invention
  • Figure 109 illustrates a configuration of a project tree within Visual SourceSafe Explorer according to an embodiment ofthe present invention
  • Figure 109.1 illustrates a dialog box ofthe projection tree in Figure 109 designed to allow developers to quickly located and retrieve desired projects and/or files according to an embodiment ofthe present invention
  • Figure 110 illustrates a graphic display when the user gets the latest ofthe server-side application code from VSS according to an embodiment ofthe present invention
  • Figure 111 illustrates a window that appears where selection the Recursive checkbox permits copying of any sub-projects according to an embodiment ofthe present invention
  • Figure 112 illustrates a History window displayed upon selection of View History menu item according to an embodiment ofthe present invention
  • Figure 113 illustrates the VSS Explorer reflecting the status ofthe checked out files for other developers to see at a point where one can open the local project or files and make any desired changes according to an embodiment ofthe present invention
  • Figure 114 illustrates Check In from within the VSS Explorer according to an embodiment ofthe present invention
  • Figure 115 illustrates the prompting for Check In details according to an embodiment ofthe present invention
  • Figure 116 illustrates a label creation dialog box according to an embodiment ofthe present invention
  • Figure 117 illustrates a History of Project dialog box according to an embodiment ofthe present invention
  • Figure 118 illustrates a History Details dialog according to an embodiment ofthe present invention
  • Figure 119 illustrates the end to end evaluation process of an Internet firewall for ReTA according to an embodiment ofthe present invention
  • Figure 120 is a chart of Firewall Products according to an embodiment ofthe present invention.
  • Figure 121 depicts the two firewall vendors selected for the product evaluation stage according to an embodiment ofthe present invention.
  • Figure 122 is a diagram ofthe Activity Framework classes with the VB Activity Wrapper according to an embodiment ofthe present invention.
  • Figure 123 illustrates the relationships IVB Activity interface according to an embodiment ofthe present invention
  • Figure 124 is a flow chart depicting a method for providing a global internetworking gateway architecture in an e-commerce environment
  • Figure 124.1 illustrates a simple high level internetworking gateway architecture according to an embodiment ofthe present invention
  • Figure 125 illustrates an Internetworking Gateway with a Specialized Proxy/Cache Server according to an embodiment ofthe present invention
  • Figure 126 illustrates a high level global internetworking gateway architecture according to an embodiment ofthe present invention
  • Figure 127 shows an illustrative West Coast internetworking gateway architecture according to an embodiment ofthe present invention
  • Figure 128 shows a Remote Access Internetworking Gateway architecture according to an embodiment ofthe present invention
  • Figure 129 illustrates an Internetworking Gateway with Partner collaboration on Internet Development according to an embodiment ofthe present invention
  • Figure 130 illustrates a persistable business object extending Persistence. RetaPersistableObj. According to an embodiment ofthe present invention
  • Figure 131 illustrates layers of a shared property group manager according to an embodiment of the present invention
  • Figure 132 is a flow chart depicting a method for initializing a database used with an issue tracker
  • Figure 132.1 illustrates configuring of an issue tracker tool for normal operation according to an embodiment ofthe present invention
  • Figure 133 illustrates a dialog box prompting to confirm the removal of linked tables within a database
  • Figure 134 illustrates a New Table' dialog window being displayed upon selection of a 'New' button in order to insert a new table according to an embodiment ofthe present invention
  • Figure 135 illustrates a prompting by Access for selecting tables to link according to an embodiment ofthe present invention
  • Figure 136 illustrates a dialog box indicating linked tables according to an embodiment ofthe present invention
  • Figure 137 illustrates a 'Welcome Form' window according to an embodiment ofthe present invention
  • Figure 138 illustrates a 'Issue Form' window according to an embodiment ofthe present invention
  • Figure 139 illustrates a window which permits modification ofthe available reports within the Issue tool according to an embodiment ofthe present invention
  • Figure 140 illustrates a window displayed permitting modification of desired report elements to the new project name according to an embodiment ofthe present invention
  • Figure 141 illustrates a Team Code Table window which allows adding and deleting of project locations according to an embodiment ofthe present invention
  • Figure 142 illustrates a Team Membership Table window which allows adding and deleting of team members according to an embodiment ofthe present invention
  • Figure 143 illustrates a Project Phases Table window which allows changing of project phases according to an embodiment ofthe present invention
  • Figure 144 illustrates a Startup window which allows changing ofthe title of a database according to an embodiment ofthe present invention
  • Figure 145 is a flowchart depicting a method for generating software based on business components
  • Figure 145.1 illustrates a relationship between business components and partitioned business components according to an embodiment ofthe present invention
  • Figure 146 illustrates how a Billing Business Component may create an invoice according to an embodiment ofthe present invention
  • Figure 147 illustrates the relationship between the spectrum of Business Components and the types of Partitioned Business Components according to an embodiment ofthe present invention
  • Figure 148 illustrates the flow of workflow, dialog flow, and/or user interface designs to a User Interface Component according to an embodiment ofthe present invention
  • Figure 149 is a diagram ofthe Eagle Application Model which illustrates how the different types of Partitioned Business Components may interact with each other according to an embodiment of the present invention
  • Figure 150 illustrates what makes up a Partitioned Business Component according to an embodiment ofthe present invention
  • Figure 151 illustrates the role of patterns and frameworks according to an embodiment ofthe present invention
  • Figure 152 illustrates a Business Component Identifying Methodology according to an embodiment ofthe present invention
  • Figure 153 is a flow chart depicting an exemplary embodiment of a resources e-commerce technical architecture
  • Figure 154 is a flow chart illustrating a second exemplary embodiment of a method for maintaining data in an e-commerce based technical architecture
  • Figure 155 is a flow chart illustraing an exemplary embodiment of a method for providing a resources e-commerce technical architecture
  • Figure 156 illustrates another exemplary embodiment of a method for providing a resources e- commerce technical architecture
  • Figure 157 illustrates an additional exemplary embodiment of a method for providing a resources e-commerce technical architecture.
  • the Resources eCommerce Technology Architecture is a solution that allows the use of packaged components to be integrated into a client based eCommerce solution.
  • the Resources architecture offerings provided services that supported the construction, execution and operation of very large custom built solutions.
  • client needs have shifted towards requirements for solutions that continually integrate well with third party applications (i.e., data warehouse and portion ofthe present description management systems).
  • third party applications i.e., data warehouse and portion ofthe present description management systems.
  • Previous engagements have proven that it is difficult to integrate these applications into a new solution.
  • application vendors continue to produce new releases that incorporate technical advancements, it is even more difficult to ensure that these integrated applications continue to work with a given solution.
  • ReTA The ReTA approach to constructing, executing and operating a solution emphasizes the ability to change solution components with minimal impact on the solution as a whole. From this approach, ReTA views third party applications as another component in the overall solution. ReTA is component based, which means the engagement can choose to take only the pieces it needs to meet its specific business requirements. ReTA is especially suited to building small applications, implementing tools and packages, integrating applications and web enabling applications.
  • ReTA leverages the best capabilities from established market leaders such as Microsoft, SAP and Oracle. In addition, ReTA leverages some ofthe Resources prior efforts to integrate solutions. The present invention is an assembly of these best capabilities that helps to ensure a holistic delivered solution.
  • a system for affording various features which support a resources eCommerce Technical Architecture.
  • the present invention may be enabled using a hardware implementation such as that illustrated in Figure 1.
  • various functional and user interface features of one embodiment ofthe present invention may be enabled using software programming, i.e. object oriented programming (OOP).
  • OOP object oriented programming
  • FIG. 1 A representative hardware environment of a prefened embodiment ofthe present invention is depicted in Figure 1, which illustrates a typical hardware configuration of a workstation having a central processing unit 110, such as a microprocessor, and a number of other units interconnected via a system bus 112.
  • a central processing unit 110 such as a microprocessor
  • the workstation shown in Figure 1 includes Random Access Memory (RAM) 114, Read Only Memory (ROM) 116, an I/O adapter 118 for connecting peripheral devices such as disk storage units 120 to the bus 112, a user interface adapter 122 for connecting a keyboard 124, a mouse 126, a speaker 128, a microphone 132, and/or other user interface devices such as a touch screen (not shown) to the bus 112, communication adapter 134 for connecting the workstation to a communication network (e.g., a data processing network) and a display adapter 136 for connecting the bus 112 to a display device 138.
  • the workstation typically has resident thereon an operating system such as the Microsoft Windows NT or Windows/95 Operating System (OS), the IBM OS/2 operating system, the MAC OS, or UNIX operating system.
  • OS Microsoft Windows NT or Windows/95 Operating System
  • MAC OS MAC OS
  • OOP Object oriented programming
  • OOP is a process of developing computer software using objects, including the steps of analyzing the problem, designing the system, and constructing the program.
  • An object is a software package that contains both data and a collection of related structures and procedures. Since it contains both data and a collection of structures and procedures, it can be visualized as a self- sufficient component that does not require other additional structures, procedures or data to perform its specific task.
  • OOP therefore, views a computer program as a collection of largely autonomous components, called objects, each of which is responsible for a specific task. This concept of packaging data, structures, and procedures together in one component or module is called encapsulation.
  • OOP components are reusable software modules which present an interface that conforms to an object model and which are accessed at run-time through a component integration architecture.
  • a component integration architecture is a set of architecture mechanisms which allow software modules in different process spaces to utilize each other's capabilities or functions. This is generally done by assuming a common component object model on which to build the architecture. It is worthwhile to differentiate between an object and a class of objects at this point.
  • An object is a single instance ofthe class of objects, which is often just called a class.
  • a class of objects can be viewed as a blueprint, from which many objects can be formed.
  • OOP allows the programmer to create an object that is a part of another object.
  • the object representing a piston engine is said to have a composition-relationship with the object representing a piston.
  • a piston engine comprises a piston, valves and many other components; the fact that a piston is an element of a piston engine can be logically and semantically represented in OOP by two objects.
  • OOP also allows creation of an object that "depends from" another object. If there are two objects, one representing a piston engine and the other representing a piston engine wherein the piston is made of ceramic, then the relationship between the two objects is not that of composition. A ceramic piston engine does not make up a piston engine.
  • the object representing the ceramic piston engine is called a derived object, and it inherits all ofthe aspects ofthe object representing the piston engine and adds further limitation or detail to it.
  • the object representing the ceramic piston engine "depends from” the object representing the piston engine. The relationship between these objects is called inheritance.
  • the object or class representing the ceramic piston engine inherits all ofthe aspects ofthe objects representing the piston engine, it inherits the thermal characteristics of a standard piston defined in the piston engine class.
  • the ceramic piston engine object ove ides these ceramic specific thermal characteristics, which are typically different from those associated with a metal piston. It skips over the original and uses new functions related to ceramic pistons.
  • Different kinds of piston engines have different characteristics, but may have the same underlying functions associated with them (e.g., how many pistons in the engine, ignition sequences, lubrication, etc.).
  • a programmer would call the same functions with the same names, but each type of piston engine may have different/overriding implementations of functions behind the same name. This ability to hide different implementations of a function behind the same name is called polymo ⁇ hism and it greatly simplifies communication among objects.
  • composition-relationship With the concepts of composition-relationship, encapsulation, inheritance and polymo ⁇ hism, an object can represent just about anything in the real world. In fact, the logical perception ofthe reality is the only limit on determining the kinds of things that can become objects in object- oriented software. Some typical categories are as follows:
  • Objects can represent physical objects, such as automobiles in a traffic-flow simulation, electrical components in a circuit-design program, countries in an economics model, or aircraft in an air-traffic-control system.
  • Objects can represent elements ofthe computer-user environment such as windows, menus or graphics objects.
  • An object can represent an inventory, such as a personnel file or a table ofthe latitudes and longitudes of cities.
  • An object can represent user-defined data types such as time, angles, and complex numbers, or points on the plane.
  • OOP allows the software developer to design and implement a computer program that is a model of some aspects of reality, whether that reality is a physical entity, a process, a system, or a composition of matter. Since the object can represent anything, the software developer can create an object which can be used as a component in a larger software project in the future.
  • OOP enables software developers to build objects out of other, previously built objects.
  • Encapsulation enforces data abstraction through the organization of data into small, independent objects that can communicate with each other. Encapsulation protects the data in an object from accidental damage, but allows other objects to interact with that data by calling the object's member functions and structures.
  • Class hierarchies and containment hierarchies provide a flexible mechanism for modeling real-world objects and the relationships among them.
  • Class libraries are very flexible. As programs grow more complex, more programmers are forced to adopt basic solutions to basic problems over and over again.
  • a relatively new extension of the class library concept is to have a framework of class libraries. This framework is more complex and consists of significant collections of collaborating classes that capture both the small scale patterns and major mechanisms that implement the common requirements and design in a specific application domain. They were first developed to free application programmers from the chores involved in displaying menus, windows, dialog boxes, and other standard user interface elements for personal computers.
  • Frameworks also represent a change in the way programmers think about the interaction between the code they write and code written by others.
  • the programmer called libraries provided by the operating system to perform certain tasks, but basically the program executed down the page from start to finish, and the programmer was solely responsible for the flow of control. This was appropriate for printing out paychecks, calculating a mathematical table, or solving other problems with a program that executed in just one way.
  • a programmer writing a framework program not only relinquishes control to the user (as is also true for event loop programs), but also relinquishes the detailed flow of control within the program to the framework. This approach allows the creation of more complex systems that work together in interesting ways, as opposed to isolated programs, having custom code, being created over and over again for similar problems.
  • a framework basically is a collection of cooperating classes that make up a reusable design solution for a given problem domain. It typically includes objects that provide default behavior (e.g., for menus and windows), and programmers use it by inheriting some of that default behavior and overriding other behavior so that the framework calls application code at the appropriate times.
  • default behavior e.g., for menus and windows
  • Behavior versus protocol Class libraries are essentially collections of behaviors that you can call when you want those individual behaviors in your program.
  • a framework provides not only behavior but also the protocol or set of rules that govern the ways in which behaviors can be combined, including rules for what a programmer is supposed to provide versus what the framework provides.
  • a preferred embodiment ofthe invention utilizes HyperText Markup Language (HTML) to implement documents on the Internet together with a general-pu ⁇ ose secure communication protocol for a transport medium between the client and a company.
  • HTTP or other protocols could be readily substituted for HTML without undue experimentation.
  • Information on these products is available in T. Berners-Lee, D. Connoly, "RFC 1866: Hypertext Markup Language - 2.0" (Nov. 1995); and R. Fielding, H, Frystyk, T. Berners-Lee, J. Gettys and J.C.
  • HTML Hypertext Transfer Protocol - HTTP/1.1 : HTTP Working Group Internet Draft
  • HTML documents are SGML documents with generic semantics that are appropriate for representing information from a wide range of domains.
  • HTML has been in use by the World-Wide Web global information initiative since 1990. HTML is an application of ISO Standard 8879; 1986 Information Processing Text and Office Systems; Standard Generalized Markup Language (SGML).
  • SGML Standard Generalized Markup Language
  • HTML has been the dominant technology used in development of Web-based solutions.
  • HTML has proven to be inadequate in the following areas:
  • UI User Interface
  • Custom “widgets” e.g., real-time stock tickers, animated icons, etc.
  • client-side performance is improved.
  • Java supports the notion of client-side validation, offloading appropriate processing onto the client for improved performance.
  • Dynamic, real-time Web pages can be created. Using the above-mentioned custom UI components, dynamic Web pages can also be created.
  • Sun's Java language has emerged as an industry-recognized language for "programming the Internet.”
  • Sun defines Java as "a simple, object-oriented, distributed, inte ⁇ reted, robust, secure, architecture-neutral, portable, high-performance, multithreaded, dynamic, buzzword-compliant, general-pu ⁇ ose programming language.
  • Java supports programming for the Internet in the form of platform-independent Java applets.”
  • Java applets are small, specialized applications that comply with Sun's Java Application Programming Interface (API) allowing developers to add "interactive content” to Web documents (e.g., simple animations, page adornments, basic games, etc.).
  • API Java Application Programming Interface
  • Applets execute within a Java-compatible browser (e.g., Netscape Navigator) by copying code from the server to client. From a language standpoint, Java's core feature set is based on C++. Sun's Java literature states that Java is basically, "C++ with extensions from Objective C for more dynamic method resolution.”
  • ActiveX includes tools for developing animation, 3-D virtual reality, video and other multimedia content.
  • the tools use Internet standards, work on multiple platforms, and are being supported by over 100 companies.
  • the group's building blocks are called ActiveX Controls, which are fast components that enable developers to embed parts of software in hypertext markup language (HTML) pages.
  • ActiveX Controls work with a variety of programming languages including Microsoft Visual C++, Borland Delphi, Microsoft Visual Basic programming system and, in the future, Microsoft's development tool for Java, code named "Jakarta.”
  • ActiveX Technologies also includes ActiveX Server Framework, allowing developers to create server applications.
  • ActiveX could be substituted for JAVA without undue experimentation to practice the invention.
  • a codes table framework 140 for maintaining application consistency by referencing text phrases through a short codes framework.
  • a table of codes each having a text phrase associated therewith is provided. Such table of codes is stored on a local storage medium.
  • the table of codes is accessed on the local storage medium.
  • One ofthe text phrases is subsequently retrieved by selecting a conesponding one ofthe codes ofthe table, as indicated in operation 146.
  • modification ofthe text phrases associated with each ofthe codes ofthe table is permitted. See operation 148.
  • the modification may be carried out during a business logic execution. Further, various services may be provided such as retrieving a single one ofthe text phrases, retrieving all ofthe text phrases in response to a single command, updating a single code and text phrase combination, updating all ofthe code and text phrase combinations, naming the table, adding a new code and text phrase combination, removing one ofthe code and text phrase combinations, and or adding another table.
  • a name ofthe table may be stored upon retrieval ofthe text phrase. Further, a total number of code and text phrase combinations in the table may be determined and stored. In the case where a plurality of tables are provided, any number ofthe tables may be removed during operation. Additional information will be now be discussed relative to the various foregoing operations.
  • the pu ⁇ ose of a codes table is to maintain application consistency by referencing text phrases (to be displayed to the end user) through short codes.
  • the code and text phrase (decode) are stored in a standard table format.
  • the codes table component stores this table locally on the web server, thus reducing the overhead of accessing the database each time the application needs to translate a code.
  • This framework The role of this framework is to store frequently used code/decode sets on the web server and provide services that enable the application developer to retrieve the decode(s) associated with code(s). In addition, the framework provides services to enable the developer to modify the contents ofthe locally stored codes table during business logic execution.
  • the Codes Table Framework provides the following services:
  • the Codes Table Framework consist ofthe following COM objects:
  • the AFRetrieval component enables the application developer to load the specified codes table into local memory (for faster access) and retrieve the requested decode(s).
  • the lAFRetrieval interface defines the access to the AFRetrieval component. This interface supports the following methods:
  • the AFMaintenance component maintains the specified local codes table.
  • the lAFMaintenance interface defines the access to the AFMaintenance component. This interface supports the following methods:
  • Figure 1.2 illustrates a method 150 for providing an interface between a first server and a second server with a proxy component situated therebetween.
  • a request for a business object is identified by an application on the first server.
  • the first server is connected to the second server in operation 153.
  • selection criteria from the first server is transmitted to the second server.
  • the first server receives a first recordset and a second recordset from the second server in operation 155.
  • Business data is included in the first recordset and result codes are included in the second recordset.
  • the first and second recordsets are mapped to the business object in operation 156 and, in operation 157, the business object is sent to the application on the first server.
  • the first and second recordsets may also be mapped to the business object using a utility conversion function. Additionally, the first and second recordsets may also be mapped to the business object using a utility conversion function.
  • the recordsets may be ActiveX data objects (ADO) recordsets.
  • the first server may also receive a third recordset from the second server in response to the selection criteria.
  • This third recordset may include enors and references to an enor table on the first server for allowing processing ofthe errors.
  • changes to the proxy component may be prevented from affecting the application on the first server. Additionally, generation of a plurality of the proxy components by a user may be allowed.
  • This portion ofthe present description details the ReTA SAP framework design from the perspective ofthe application developer.
  • the role of this framework is to provide designs and templates that describe how to integrate an Internet application with a SAP server. Unlike the other ReTA frameworks, this does not provide any code components for connecting to SAP, but uses the S AP/DCOM component connector created jointly by Microsoft and SAP.
  • This portion ofthe present description provides a framework for the design ofthe architecture using the SAP DCOM connector components to integrate with SAP.
  • the DCOM Component Connector provides interoperability between R/3 objects and COM objects across a heterogeneous network through well-defined business interfaces. It provides the development tools for connecting with SAP to standard SAP BAPI 's (Business Application Programmer Interface) as well as custom developed or modified BAPFs.
  • SAP BAPI Business Application Programmer Interface
  • the DCOM component connector can connect to SAP on Windows NT or UNIX.
  • the Application server needs to be R/3 Version 2.1 or higher or R/2 with 50D.
  • the ReTA SAP framework uses an adapter layer design that places a wrapper around the DCOM component connector.
  • the adapter layer improves developer productivity by managing some of the lower level tasks, and improves the flexibility of the final solution.
  • the remainder of this portion ofthe present description describes the Execution and Development Architectures for the SAP framework.
  • the DCOM Component connector uses COM proxy components that map to SAP Business Objects. There is one proxy component for each SAP business object.
  • the SAP business objects can contain both the standard BAPI 's (Business Application Programmer Interface) as well as custom developed or modified BAPI's.
  • BAPI Business Application Programmer Interface
  • the SAP/DCOM component generation wizard connects to SAP, examines the SAP business object, and generates a proxy component with the same interface.
  • the SAP/DCOM connector component can connect to SAP on Windows NT or UNIX.
  • Figure 1.3 shows the execution architecture for components that make up the SAP Framework Execution Architecture 160.
  • SAP/DCOM connector generated components 162 provide the actual connection to SAP 164. These components are generated from the SAP Business Application Programmer Interface (BAPI) 166,168.
  • BAPI SAP Business Application Programmer Interface
  • the BAPI's are either the standard SAP BAPI's, custom created BAPI's or Remote Function Calls.
  • the ReTA framework uses an Adapter layer to provide a thin wrapper on the SAP/DCOM connector components.
  • the adapter layer provides the following benefits:
  • SAP/DCOM connector generated components use ADO (ActiveX Data Objects) recordsets to pass data to SAP.
  • the adapter layer components map from these recordsets to the Business Objects or Business Data format used by the application. If a given method returns business data from SAP then this is in the form of an ADO recordset. If a method updates information in SAP then one must pass in an ADO recordset with all the data. To initialize this ADO recordset one calls a separate standard interface method ofthe proxy component. SAP returns business errors by returning a separate ADO recordset that references an error table.
  • ADO ActiveX Data Objects
  • the ReTA framework's adapter layer maps the ADO recordsets that the DCOM connector uses to the business objects or data objects used by the application.
  • the adapter layer also maps the enor table recordset returned by SAP to the enor handling mechanism used by the application.
  • the SAP/DCOM connector portion ofthe present description gives a detailed description of how to generate a COM proxy component for a given SAP BAPI.
  • the steps for creating a proxy component are:
  • the DCOM Component connector may then generate C++ and EDL files, compile these files to create the proxy component and install this component in MTS.
  • the SAP Adapter components are responsible for:
  • This template gives an example of an SAP connector component with one method to receive business data and one method to send business data. It describes how to convert to/from the data types required by the SAP Connector component and how to manage the SAP return enor codes.
  • Figure 1.4 illustrates a method for sharing context objects among a plurality of components executed on a transaction server.
  • a first component is executed on a transaction server.
  • a context object is then generated for the first component in operation 172 to control a scope ofthe execution ofthe first component.
  • a call made by the first component is identified to execute a second component.
  • the context object ofthe first component is utilized for controlling the scope ofthe execution ofthe second component in operation 176.
  • the first and second components may be service order item components.
  • the first component may be an activity component and the second component may be a business component.
  • a plurality of activity components may be provided.
  • a call made by the activity component may also be identified to execute a second business component with the context object ofthe activity component utilized for controlling the scope of the execution ofthe second business component.
  • a call made by the activity component may be identified to execute an error logging component with an additional context object separate from the context object ofthe activity component being utilized for controlling the scope ofthe execution ofthe error logging component.
  • ReTA ReTA approach to performing "logical unit of work” database operations in the context of transactions.
  • Applications developed with ReTA implement transactions through Microsoft Transaction Server (MTS).
  • MTS Microsoft Transaction Server
  • ReTA applications group business components into transactions. The application developer designs each business component to define whether its actions should be performed within a transaction.
  • FIG. 2 illustrates a create component instances method 200.
  • MTS controls the scope of transactions by using transaction context objects.
  • Each transaction server component has an associated MTS context object 202, which controls the transaction context. If a component 204 needs to create instances of other components 206 during its processing, it uses the Createlnstance method ofthe MTS context object to create the new object. Calling this method ensures that the new component has an associated MTS context object 202 with the conect transaction scope.
  • the following portions ofthe present description include three database operations grouping scenarios that a ReTA application developer can implement through MTS.
  • the developer composes the work of a business activity 300 into a single transaction.
  • Activity 300 uses business objects in components 302 and 304 to compete its work. Any database operations generated by either of these business components are completed in the context of a single transaction.
  • the developer uses the default transaction context scope that MTS provides.
  • the developer sets the transaction attribute ofthe Activity component to Requires a transaction and the attribute of the business components to either Requires a transaction or Supports transactions.
  • MTS creates a conesponding context object 306. Subsequently, when the activity component initializes the business components, these business components share the same context object and are therefore committed in the same transaction.
  • the transaction is committed. If any ofthe database calls, fails or any ofthe components decides to abort the transaction, the transaction is aborted and all the database actions performed are rolled back.
  • the developer creates a component whose database operations are always carried out in a separate transaction.
  • an enor logging component 402 should not use the transaction context of the component generating the enor. This could cause the enor logged to the database to be rolled back if an error occurs in a separate database operation.
  • This scenario has an activity component 400, two business components 404,406 and an enor logging component 402. If an error occurs in the activity, then an error message is sent to the enor logging component (which logs the enor in a database). The transaction ofthe activity is rolled back, however, the transaction ofthe enor logging component is committed to the database.
  • the enor logging component is registered as Requires a new transaction.
  • MTS creates a new transaction context for the component. If an enor occurs in the activity, the database operations for the activity is rolled back, but any database operations that the error component generates is committed.
  • the developer creates two separate activities 500,502 whose work sometimes need to be composed into a single transaction.
  • the developer creates a third activity component 504 that calls the other two activities.
  • the third activity component is registered as Requires a transaction.
  • MTS creates a new transaction context.
  • the activity 504 initializes the other two activities 500,502, they share the same transaction context 506 (and any objects they create also have the ability to share the transaction context).
  • MTS and ODBC provide connection pooling.
  • MTS/ODBC associates a connection pool with a specific user account. Therefore, it is important that all data access components have a predefined account to use when requesting database connections.
  • connections are pooled only within the same process. This implies that every MTS package may have a pool of connections, as each MTS package runs in its own process.
  • connection pooling is a feature ofthe ODBC resource manager. MTS automates the configuration ofthe ODBC resource to enable connection pooling.
  • the Database server is a resource bottleneck. To improve performance, ensure high bandwidth connections exist between application and database servers.
  • Connection pooling provides performance improvement especially in the case where connections are used and released frequently such as Internet application.
  • MTS supports the concept of a stateful object. However, the object must satisfy the following conditions:
  • the object can not be transactional.
  • MTS implements an activity concept.
  • activity concept all objects participating in a transaction (or LUW) are logically "grouped" together.
  • SetComplete is called and all objects in that activity are freed.
  • no object in the transaction holds context (state) on transaction completion.
  • MTS creates a new thread to service the request.
  • MTS packages have a maximum limit of 100 threads per package. If the number ofthe incoming concunent calls exceeds 100, MTS serializes all excess calls. Project testing (a FinacialWorks project) proved that performance degraded significantly after reaching the 100 concurrent threads mark.
  • a MTS object is created from an existing context, the new object becomes part ofthe same activity.
  • the object's context inherits the activity identifier ofthe creating context.
  • Activities define a single logical thread of execution. When a base client calls into an activity, all subsequent requests from other clients are blocked until control is returned to the original caller.
  • MTS initiates a transaction when a method on a transactional component is called.
  • MTS records the transaction ID in the component's object context. This transaction ID is passed to other MTS components' context objects requiring participation in the same transaction.
  • MTS operates with an optimistic assumption that the transaction is going to succeed. If the component never calls SetAbort, SetComplete, DisableCommit, or EnableCommit, the transaction commits when the client releases its last reference to the MTS component.
  • the transaction aborts when the client releases its last reference to the component. If the component calls EnableCommit, the transaction commits when the client releases its last reference to the component.
  • MTS may automatically commit the transaction when the client releases its object references.
  • Transactions can also be manually controlled from a base client by using the transaction context to start and commit/abort a transaction. This is particularly useful in the case where a stateful base client activates an MTS-managed transactional object to carry out a distributed transaction. In order to achieve that, MTS uses the Transaction Context created by the base client.
  • MTS intercepts the call and creates a sibling object called the Object Context. It is the object context that may manage the transaction and the business object activation deactivation.
  • One ofthe interface methods on the context object is SetComplete.
  • SetComplete When SetComplete is called, the transaction (if any) is signaled as ready to be committed and the instance ofthe business object is destroyed releasing all resources used by it.
  • MTS creates a new instance ofthe business object and delegates the call to it (this is assuming that the client did not release its original reference to the MTS-supplied context wrapper). In the MTS world, this is known as JIT activation.
  • COM searches the Running Object Table to determine whether an instance ofthe component is active on the client.
  • COM searches the Registry for the information describing Customerlnterface and invokes the creation ofthe interface.
  • MTS 600 intercepts the Customer creation request 602, starts a process for the Customer package containing Customer component 604, creates the ContextObject 606 and returns a reference to the client. See Figure 6.
  • MTS 700 deactivates the component, freeing the thread, the memory and returns the result to the client.
  • Figure 7 shows that the customer object 702 has been deactivated (the customer object is grayed out).
  • the Context wrapper creates a new instance ofthe Customer component and delegates the incoming call to it.
  • MTS does not need to recreate the object.
  • the keyword "New” creates an object with private instantiation property. It is used with early binding.
  • CreateObject Normally used with late binding and used to create objects with public instantiation property. If other MTS object are instantiated using CreateObject (on the server), they run the risk of running in the wrong context. CreateObject can be used from the client to instantiate any MTS object.
  • Createlnstance It is the interface method ofthe context object used to instantiate other MTS objects. This is the only way to guarantee the newly created object participates in the same current transaction.
  • MTS instantiates a transaction, it records the transaction ID in the component's object context. This transaction ID is passed to other MTS components only when Createlnstance is used to create these objects.
  • Java/VB uses COM to create an instance ofthe object. If the Object is registered in MTS, MTS loads the DLL and creates a new instance passing back a MTS- managed handle to the object. The object gets a new MTS context.
  • the new object gets a new context. If CreateObject (or New for an object in a different DLL) is used, the contexts are independent of each other. If a transaction is involved, the new context manages a completely different transaction from the original. If Createlnstance is used, the new object's context shares the same transaction as the invoking one.
  • CreateObject or New for an object in a different DLL
  • New is only a problem in the following scenario.
  • the application contains one DLL that contains more than one MTS-managed class.
  • the application wants an instance of one of these classes to create an instance ofthe other (in separate contexts). New may not do this, whereas CreateObject and Createlnstance may. However, Createlnstance is required if they are to run under the same transaction.
  • Visual Basic is the language of choice, make sure to pass parameters by value (as the default in VB is by reference). This may help reduce network trips and hence improves performance. If one is passing the collection object in MTS, make sure to use the Microsoft provided wrapper collection object.
  • the standard VB collection object is known to cause enors when running under MTS. It is better to use a variant array instead of collection to pass information around. It is more robust and performs better.
  • MTS registered business objects are passed by reference as they use standard marshalling
  • IObjectContext.Createlnstance This allows MTS to manage context switches and Object lifetime.
  • Database Locking should be in place to ensure the integrity ofthe database in a multi-user environment. Locking prevents the common problem of lost updates from multiple users updating the same record.
  • the optimistic approach of record locking is based on the assumption that it is rarely the case for multiple users to read and update the same records concunently. Such a situation is treated as exceptional processing rather than normal.
  • Optimistic locking does not place any locks at read time; locks are actually placed at update time.
  • a time stamp mechanism should be provided to ensure that at update or delete times the record has not changed since the last time it is read. It is recommended to use optimistic locking with ADO and MTS to improve performance. If the data access mechanism uses ADO disconnected RecordSets, then the only possible locking policy is optimistic.
  • ADOR.Recrodset is a lighter version ofthe ADODB.Recordset designed specifically for client's use. With disconnected Recordsets only optimistic locking can be employed.
  • MTS wrapper collection
  • Figure 8 illustrates a method for providing an activity framework.
  • a plurality of sub-activities are created which each include sub-activity logic adapted to generate an output based on an input received from a user upon execution.
  • a plurality of activities are defined, each of which execute the sub-activities in a unique manner upon being selected for accomplishing a goal associated with the activity. Selection of one of the activities is allowed in operation 804 by receiving user indicia.
  • an interface is depicted for allowing receipt ofthe input and display ofthe output during execution ofthe sub-activities associated with the selected activity.
  • the sub-activity logic may be adapted for verifying that all required input has been received prior to generating the output. Access to the input received from the user by each ofthe sub-activities ofthe activities may also be allowed.
  • the activity may include creating a service order.
  • the sub-activities each may additionally include at least one business component.
  • the interface may include a plurality of displays that are each displayed during the execution of a conesponding one ofthe sub-activities.
  • This portion ofthe present description details the ReTA Activity framework design from the perspective ofthe application developer.
  • the primary role of this framework is to provide services that support the "model view controller” (MVC) design pattern.
  • MVC model view controller
  • the application implements a "separation of concern” among the user interface (view), logical unit of work (controller) and business components (model). Separating the user interface from the business logic increases reuse ofthe interface and the business component.
  • different types of interfaces can reuse the same model and the same interface can view different models.
  • Another goal of separating presentation and storage responsibilities is to reduce the impact of change. For example, changing the user interface design should only impact the user interface components and not the business logic.
  • the ReTA Activity framework increases application maintainability and flexibility. It also encourages "best practice” coding standards.
  • Web page (Active Server Page) (View/Controller)
  • the application's web page logic 832 starts the activity 834, executes the sub-activity and creates the user interfaces. No business logic is contained directly in the web page code.
  • the application developer leverages the ReTA Session, ReTA Activity and the ReTA UI frameworks from the web page code.
  • Activity Components implements the business process logic (functional control logic) 836. Activities support high-level processes that are not the responsibility of any individual business components. This includes high-level steps related to a user's "logical unit of work" or business function.
  • activities enable multiple web pages to implement a "logical unit of work".
  • An example of an activity implementing a "logical unit of work" with multiple web pages is "Create Service Order”.
  • the user selects a service to order on the first page, enters the customer information on the second page, reviews and submits the order on the third page and receives an order confirmation on the fourth page.
  • Business components 837 implement the application's business entity logic. These components represent individual business entities (such as customer or account). Each entity encapsulates its own data and behavior acting on that data. Note: The Activity implements business logic that spans multiple business components.
  • the ReTA Activity framework consists ofthe following three main components:
  • An activity 834 encompasses a combination of web pages, which fulfill a business function.
  • the activity has the following responsibilities: • Provide a "logical unit of work" context to all sub-activities within the activity.
  • Activity framework uses Microsoft Transaction Server (MTS) transactions to implement the "logical unit of work" concept. On the completion of a transaction (whether successful or abort), MTS ensures that each sub-activity may be in a consistent state (either completed or rolled back). • Check that requested information and conditions are fulfilled before executing logic.
  • MTS Microsoft Transaction Server
  • the activity does not contain any business logic. Sub-activities (and their associated business components) provide the business logic. Thus, the activity maintains a context and provides a "logical unit of work" for a specific business functionality.
  • a sub-activity 838 executes a sub-part ofthe overall activity business logic.
  • the sub-activity represents the smallest grained business logic. For example in a "Create Service Order" activity, one sub-activity retrieves all the service types information to display on the first web page.
  • a sub-activity has the following responsibilities:
  • a view 840 defines the mapping between a user interface and business components containing the values to display.
  • the view has the following responsibilities:
  • the Activity component maintains a separate view for each web page defined to be part ofthe activity.
  • the ReTA Activity framework fully supports business activity components written in Java or Visual Basic.
  • the Activity framework provides partial support for business activity components written C++.
  • the application developer must implement the services provided by the Activity utility classes AFView and AFViewBOMapping.
  • the Activity Framework provides the following services: 'MMM ® Unplug user interface from business component
  • the Activity Framework implements these services through the following COM and Class objects:
  • the AFActivity component provides the structure for implementing business logic, state management among web pages, management of views and sub-activities, and transactional support for carrying out a "logical unit of work".
  • the application developer creates an activity component for each specific business activity by extending the AFActivity component.
  • the activity component shares the services provided within the Activity framework allowing the application developer to concentrate on the business logic.
  • Application business logic is organized into three separate areas within an activity: pre-conditions, execution, and post conditions.
  • the IAF Activity, LAFContext and LAFEventListener interfaces define the access to the AFActivity component. These interfaces support the following methods:
  • This method may call the SetComplete method of MTS. (See MTS portion ofthe present description for more information)
  • the ReTA Session component holds references to all registered listeners (Activity components).
  • the application developer implements the following abstract methods in the business activity component:
  • the AFSubActivity component implements a sub-part ofthe overall activity business logic.
  • the application developer creates a sub-activity component for each sub-part of a specific business activity by extended the AFSubActivity component.
  • the sub-activity workflow sequence is pre-condition, execution and post-condition. Note:
  • the LAFSubActivity interface defines the access to the AFSubActivity component. This interface supports the following methods:
  • the application developer implements the following abstract methods in the business sub- activity component:
  • the AFCollection component is a general pu ⁇ ose collection component.
  • the collection component can be used to store and retrieve a collection of COM components, integers or strings.
  • the LAFCoUection interface defines the access to the AFCollection component. This interface supports the following methods:
  • the AFVBActivityWrapper component enables the application developer to add Activities that are written in Visual Basic.
  • the LAF Activity, LAFContext, LAFEventListener and lAFVBActivityWrapper interfaces define the access to the AFVBActivityWrapper component. These interfaces support the following methods:
  • This string contains the names of all UI fields ofthe page and the JavaScript code needed to retrieve their values. Due to non-support of class inheritance by the VB language, the VB application developer must implement the gefPageParameter logic supplied by superclass AFActivity for Java applications. The VB developer copies the required logic from the VB Activity shell code file.
  • ReTA Session Method called by the ReTA Session during an ASP start page event to enable the architecture to capture user entry from previous web page.
  • the ReTA Session component holds references to all registered listeners (Activity components). Due to non-support of class inheritance by the VB language, the VB application developer must implement the receiveEvent logic supplied by superclass AFActivity for Java applications. The VB developer copies the required logic from the VB Activity shell code file.
  • IAFVBActivity Interface Methods The application developer implements the following interface methods in the VB business activity component:
  • the AFView class provides a mapping between a User Interface and a set of Business Components (the view maps one web page form to one or more business components).
  • the Session framework invokes the receiveEvent method on the appropriate Activity component.
  • the Activity component uses the View class to record, into the appropriate business component, the data entered by the user at the previous web page.
  • the View class obtains the cunent user interface field values for the next web page as requested by the application developer through ASP scripting logic.
  • the AFViewBOMappmg component defines the mapping between a user interface entry field and the business component instances containing the value to display. This class gets/sets an UI field value by getting/setting the business component instance contained in the activity context. Each mapped business component instance should implement the IAFEditable interface. This interface provides the setValue and getValue methods used to set and get values ofthe business component instance.
  • the AFViewRadioButtonBOMappmg component defines the mapping between a user interface radio button field and the business component instances containing the value to display. This class gets/sets an UI field value by getting/setting the business component instance contained in the activity context. Each mapped business component instance should implement the IAFEditable interface. This interface provides the setValue and getValue methods used to set and get values ofthe business component instance.
  • the AFViewDynamicBOMapping component defines the mapping between a dynamically created user interface field and the business component instances containing the value to display. This class gets/sets an UI field value by getting/setting the business component instance contained in the activity context. Each mapped business component instance should implement the LAFEditable interface. This interface provides the setValue and getValue methods used to set and get values ofthe business component instance.
  • IH339 Description a new AFViewDynamicBOMapping instance defining a UI field to business component attribute mapping for an ASP page (parameters passed by the application developer). The application developer calls this method from the implemented views method of the business activity component.
  • the Activity framework Based on the parameter passed to the current Active Server Page, update the business components containing the value entered by the user from the previous page for the mapped UI field.
  • the Activity framework implements this logic for the application developer.
  • AFViewTextAreaBOMapping (AFVBViewTextAreaBOMapping)
  • the AFViewTextAreaBOMapping component defines the mapping between a user interface multi-line entry field and the business component instances containing the value to display. This class gets/sets an UI field value by getting/setting the business component instance contained in the activity context. Each mapped business component instance should implement the LAFEditable interface. This interface provides the setValue and getValue methods used to set and get values ofthe business component instance.
  • the AFViewDropDownBOMapping component defines the mapping between a user interface drop down field and the business component instances containing the value to display. This class gets/sets an UI field value by getting/setting the business component instance contained in the activity context. Each mapped business component instance should implement the LAFEditable interface. This interface provides the setValue and getValue methods used to set and get values ofthe business component instance.
  • the AFViewULListBOMapping component defines the mapping between a user interface Selected List field and the AFCollection component instance containing the values to display. This class gets/sets an UI field value by getting/setting the AFCollection component instance contained in the activity context.
  • the AFViewThumbNailBOMapping component defines the mapping between a user interface ThumbNail (iconic pushbutton) field and the business component instances containing the value to display. This class gets/sets an UL field value by getting/setting the business component instance contained in the activity context. Each mapped business component instance should implement the LAFEditable interface. This interface provides the setValue and getValue methods used to set and get values ofthe business component instance.
  • This string contains the name ofthe selected list box field and the JavaScript code needed to retrieve its value. Called by the getParameter method ofthe AFView component.
  • the Activity framework implements this logic for the application developer.
  • Figure 9 illustrates a method 900 for accessing services within a server without a need for knowledge of an application program interface ofthe server.
  • a role container is first created in operation 902.
  • a role class is defined and in operation 906 an attribute for the role class is generated which includes a default start page attribute.
  • a role object is made in the role class with the default start page attribute associated therewith in operation 908.
  • a uniform resource locator is selected in operation 910 for the default start page attribute.
  • a plurality of attributes may be generated for the role container. Further, these attributes may include a default start page attribute, a user name attribute, a user identifier attribute, and/or a role name attribute.
  • a user may be assigned to the role object.
  • a plurality of role objects may be made in the role class with each role object having a unique default start page associated therewith.
  • an operator role object and a customer role object may be made as well. The following material provides a more detailed description ofthe above-described method.
  • This portion ofthe present description details the ReTA Site Server framework design from the perspective ofthe application developer.
  • the role of this framework is to provide components that allow one to integrate the ReTA custom frameworks with Site Server. This provides a user component connecting to Site Server, but does not require knowledge ofthe Site Server API itself to integrate with Site Server.
  • a COM component (UserSS) is used to make calls to Site Server's API.
  • the ReTA UserSS component allows the developer to access Site Server's Personalization and Membership Services without any knowledge of Site Server's API.
  • FIG.1 illustrates Site Server Framework Architecture. This figure shows the different layers in the Site Server framework architecture.
  • the UserSS COM component 930 connects to Site Server 932.
  • the UserSS component uses Site Server's Personalization and Membership; UserSS also performs security as well on a Commerce Site.
  • the ReTA framework 934 uses the UserSS layer to provide access to Site Server.
  • the UserSS layer provides the following benefits:
  • the UserSS component interfaces with the SiteServer personalization and membership services. This component uses SiteServer to handle the user security, role and preferences.
  • the LAFUser, lAFUserPreferences, and LAFUserRole interfaces define the access to the AFUserSS component. These interfaces support the following methods:
  • This portion ofthe description describes the required settings in Site Server Commerce Edition used by the ReTA frameworks. This portion ofthe description also describes the steps involved in creating the required settings.
  • the Membership Directory Manager is used to manage administration and access control for Membership Directory objects, including users and groups, and schema objects.
  • the Membership Directory stores objects used by all Site Server features.
  • the ReTA UserSS framework requires schema objects to be created.
  • the schema objects required by the ReTA Frameworks are: Roles container 1000, RoleName attribute 1002, username attribute 1004, webUserld attribute, and a Role class.
  • Figure 10 illustrates schema attributes and classes, with class "Role” and attribute "RoleName” shown.
  • Site Server ReTA takes advantage of this by creating a Container “Roles” that contains different “Roles” or different objects ofthe class “Role”. These "Roles” have attributes such as a default start page. Therefore different “Roles” (different objects ofthe class “Role”) such as “Operator” or “Customer” may both have a default start page attribute that may point to different URL's.
  • the Site Server portion ofthe present description details how to setup a Container, Class, and Attributes. The following lists the steps involved to setup the required attributes for the ReTA Frameworks to integrate with Site Server. Using the Site Server Console, right click on the Membership Directory Manager folder.
  • Figure 11 illustrates the creating of Container "Roles”.
  • To create these attributes expand the Admin Container under the Membership Directory Manager.
  • FIG 14 illustrates an example showing the attributes 1400 of member "Joe Bloggs" (Note RoleName).
  • EVENT HANDLER FRAMEWORK DESIGN Figure 15 illustrates a method 1500 for handling events in a system.
  • an event which includes metadata is recognized.
  • the metadata ofthe event is read and, in operation 1506 a table look-up is performed for information relating to the event based on the metadata.
  • the information includes a severity ofthe event and further information such as a type ofthe event, and a location where the event occuned.
  • a message is displayed either in-line in a currently depicted display or in a separate display based on the severity ofthe event.
  • the event may additionally be indicated to components ofthe system other than the component in which the event occuned.
  • the type ofthe event may be a database enor, an architecture enor, a security enor, and/or an application enor.
  • the location ofthe event may be at least one of a method and an object where the event occuned.
  • the information may further relate to a code associated with the event.
  • the message may include the information relating to the event.
  • the message may also include a time during which the event occurred.
  • the message may include a string altered based on a user profile.
  • This portion ofthe present description details the ReTA Event Handler framework design from the perspective ofthe application developer.
  • the role of this framework is to provide services to manage the informational, warning and error events that an application may raise. These services include:
  • the Event Handler uses an Event Reference meta-data database table to maintain information about the types of events in an application and the policy for dealing with them. This gives a flexible approach and the event messages, the severity and other policies for the events can be changed during operations. Phase 2 - Event Handler Enhancements
  • Event Handler consists ofthe following enhancements:
  • Event Handler framework is componentized. It no longer maintains references to any ofthe other framework components. Internally, the Event Handler continues to use the persistence light framework to log events to the database.
  • phase 1 it can be used as a Session level component.
  • the Event Handler framework can be used as a stateless page level component. This means that a new instance ofthe component is created at the beginning of each ASP page and is released at the end of each page.
  • the Event Handler framework no longer requires Event Collection components as parameters to implement event handling, which only allowed handling events at the page level.
  • the new method "processSingleEvent” takes the parameters of a single event as its input, which enables handling events at the occurrence ofthe event.
  • the Event Handler can format enor descriptions in HTML.
  • the Event Handler can return the enor message as a string and enables the application to implement client specific formatting (HTML or other).
  • the process event method no longer calls the ASP redirect method. Instead, it returns the severity level code. On return, the application logic determines whether to redirect to the error page or display the error in-line in the cunent page.
  • the Translator is no longer a separate component. Instead, it is a Java class inside the Event Handler component.
  • the ReTA Event Handler Framework 1530 manages the informational, warning and enor events that an application raises. The following describes the ReTA event handling sequence:
  • Each method defining a COM component interface captures these event exceptions and either adds them to an Event Collection component or directly calls a method on the Event Handler component.
  • Events are processed from the ASP page by calling the process method ofthe Event Handler. Events can also processed from the point where the event occurred by calling the "processSingleEvent" method ofthe Event Handler.
  • Event Handler processes the event(s): • For each event, set the user id and cunent page
  • the caller is responsible for either redirecting to the enor page or displaying the event in-line in the Current Page.
  • the Error Message is either displayed in-line in the cunent page or in a separate enor page.
  • the Event Handler generates enor display message:
  • the user event descriptions are retrieved from the database either on session start or on demand and are cached by the Translator class. When generating the event description page, this description is requested from the Translator. Event descriptions can have embedded context parameters. When generating the event description page, the event handler replaces these parameters with their values specified when creating the event.
  • the Event Handler uses two database tables:
  • the T_AF_EventReference 1534 is a static table that describes the Event meta-data, giving the policies for each event type.
  • the policies include: • The message that is displayed to the user. These messages can contain data from the
  • the severity ofthe event can be information, Warning, Enor and Fatal.
  • the T AFJEventLog 1536 contains the log ofthe events that occuned. The following information is logged:
  • the Event Handler Framework provides the following services:
  • Event Handler Framework implements these services through the following COM and Class objects:
  • the AFEventHandler component 1538 handles the events generated by the system. Depending on the severity level, the event handler may redirect the user to another ASP page and may abort the activity or session. The event handler also determines whether and when to log an event.
  • the IAFEventHandler interface defines the access to the AFEventHandler component. This interface supports the following methods:
  • the AFEventCollection component contains a collection of events.
  • the LAFEventCoUection interface defines the access to the AFEventCollection component. This interface supports the following methods:
  • the AFResult component defines the result return by a method execution.
  • the lAFResult interface defines the access to the AFResult component. This interface supports the following methods:
  • the AFTranslator class returns event reference information (based on the event type and event code.
  • the AFTranslator class has the following methods:
  • the AFEventException class contains the event exception information and is added to the AFEventCollection component for processing by the AFEventHandler component.
  • the AFEventReference component 1540 contains the event reference information that is defined by the application through database table T_AF_EventReference.
  • the architecture reads the event reference data into memory on session start.
  • the AFPersistableEvent 1542 contains the event information captured during the application execution that is persisted to the database table T AFJEVENTLOG.
  • Figure 16 depicts a method 1600 for managing user information.
  • a site server is provided in operation 1602.
  • the side server has information stored on it including preferences, roles, and details relating to users.
  • a database separate from the site server is provided in operation 1604.
  • the database has information stored thereon including preferences, roles, and details relating to the users.
  • an identity of one ofthe users is authenticated.
  • a single interface is displayed in operation 1608, which provides the user access to both the site server and the database upon authentication ofthe identity ofthe user.
  • the user is allowed to view and change the information that is stored on the site server and the database and that is associated with the user.
  • the single interface is tailored in operation 1612 based on the information associated with the user.
  • the identity ofthe user may be authenticated by verifying a user name and a password, a secure sockets layer (SSL) certificate, and/or a log-in form.
  • the preferences relating to the users may include a cunency in which monetary values are displayed and a language in which text is displayed.
  • the roles relating to the users may include a customer, a manager, and an employee.
  • the details ofthe users may include a user name and a legal name. The following material provides a more detailed description ofthe above-described method.
  • This portion of the present description details the ReTA User framework design from the perspective ofthe application developer.
  • the primary role of this framework is to provide services that allow the application developer to maintain user preferences, roles and security.
  • the User framework provides User Authentication services through any of the standard Internet Information Server security methods:
  • the User framework provides services for accessing: • User information - NT username, Real Name.
  • the User framework 1630 enables two approaches to maintaining user information.
  • the framework supports two approaches by exposing a single set of interfaces that can be used by either ofthe two user framework components.
  • the framework interfaces with the Microsoft Site Server products
  • SiteServer holds and manages user information.
  • AFUserDB component 1634 the framework interfaces with database tables.
  • database tables define the user information.
  • the User Framework provides the following services:
  • the User Framework implements these services through the following COM objects:
  • the AFUserDB component holds the user role, preferences and details retrieved from the database. When created the user component retrieves the user NT login name, user details and constructs the user preference and user role objects.
  • LAFUser, LAFUserPreferences and LAFUserRole interfaces define the access to the AFUserDB component. These interfaces support the following methods: i s i Description
  • the UserSS component interfaces with the SiteServer personalization and membership services. This component uses SiteServer to handle the user security, role and preferences.
  • the LAFUser, LAFUserPreferences, and LAFUserRole interfaces define the access to the AFUserSS component. These interfaces support the following methods:
  • This method returns a zero integer. It is here for compatibility with the UserDB component.
  • This method returns a string value representing the user
  • SiteServer's API is used to obtain this value.
  • This method returns a string value representing the user's name.
  • SiteServer's API is used to obtain this value.
  • Figure 17 illustrates a method 1700 for managing business objects in a system that includes a plurality of sub-activities which each include sub-activity logic adapted to generate an output based on an input received from a user upon execution, and a plurality of activities which each execute the sub-activities in a unique manner upon being selected for accomplishing a goal associated with the activity.
  • an identifier and a reference to a business object are received from one ofthe sub-activities upon the execution thereof.
  • a database is accessed and data from the database is retrieved based on the identifier.
  • the business object is created and populated with the data retrieved from the database in operation 1706.
  • the data may be stored on the database in tables. Further, the created business object may replace an existing business object. Additionally, the identifier may identify a customer and the business object may be a customer object. Also, a business object referenced by one ofthe sub- activities may be removed upon the execution thereof.
  • the business object may be a Visual Basic business object.
  • the business object may be a Java business object.
  • the following material provides a more detailed description ofthe above-described method. This portion ofthe present description details the ReTA Persistence framework design from the perspective ofthe application developer. The role of this framework is to provide services that interact with application database(s) to create, retrieve, update and delete business objects.
  • the ReTA Persistence framework provides a transparent and flexible mapping ofthe business object attributes to relational database tables. To implement this "business object to database table" mapping, the framework is tightly integrated with all business objects. The framework exposes abstract methods that the application developer implements in the business objects. In contrast with the other ReTA frameworks, the Persistence framework is not implemented as a separate component.
  • the Persistence framework is a set of local language classes available in Java or Visual Basic. Figure 17.1 shows a SubActivity component 1730 using the Persistence framework 1732 to retrieve a Customer Object 1734 from the Database.
  • the Persistence Framework provides the following services: Classes
  • the Persistence Framework implements these services through the following Java or Visual Basic Classes:
  • the AFPLPersistableObj abstract class contains methods called by the application developer objects to manage attribute values common to all persistable business objects (user id and last update timestamp).
  • the AFPLPersistableObj class represents the superclass of a persisted object.
  • the application developer extends AFPLPersistableObj and implements the AFPLPersistableObj abstract methods.
  • the AFPLPersistableObj defines the following methods: Iffi ⁇ I Description
  • AFPLExtent provides the mapping between the business object and its associated database table.
  • the AFPLExtent class represents the domain defined by the visible part ofthe database table for the specified user. This class holds the passed in database URL, usemame and password used during the access to the database.
  • the AFPLExtent class manages the database connection.
  • the AFPLExtent class implements the following methods used by the application developer from business factory objects:
  • VBPersistObj interface class contains methods that need to be implemented on every VB Business Object.
  • the application developer implements the following methods from their business object:
  • the VBExtent class provides the mapping between the business object and its associated database table.
  • the VBExtent class represents the domain defined by the visible part ofthe database table for the specified user. This class holds the passed in database URL, usemame and password used during the access to the database.
  • the VBExtent class manages the database connection.
  • the VBExtent class implements the following methods used by the application developer from business factory objects:
  • SESSION FRAMEWORK DESIGN Figure 18 illustrates a method 1800 for persisting information during a user session.
  • a session is initiated upon a user accessing a predetermined starting page.
  • a cunent page accessed by the user is then tracked in operation 1804 while browsing a plurality of pages during the session.
  • a record is maintained of a page previously accessed by the user during the session.
  • Information is persisted in operation 1808. This information is selected from a group of items such as user identifier, a time of a most recent user action during the session, activity components accessed during the session, and business components accessed during the session.
  • the current page, previous page record, and information are provided to at least one activity component in operation 1810.
  • the activity component generates output based on input provided by the user via the plurality of pages.
  • the activity components to which the cunent page, previous page record, and information are provided may be selectively determined.
  • the activity component may be provided an indication as to whether the user is permitted to access each ofthe pages.
  • the activity component may also be provided the indication as to whether the user is permitted to access each ofthe pages based on the previous page record.
  • the information may also include the user identifier.
  • user preferences may be looked up based on the user identifier with the information including the user preferences.
  • references to activity components, business components, a user component, a tracking manager component, a system preference component, and an event handler component may be employed. The following material provides a more detailed description ofthe above-described method.
  • This portion ofthe present description details the ReTA Session framework design from the perspective ofthe application developer.
  • the primary role of this framework is to provide services to handle the stateless nature of Internet. By default, the Internet does not provide services for maintaining information between pages. Without these services, it would not be possible to implement most eCommerce functionality. For example, session level state is necessary to implement eCommerce functionality where a customer can select products on multiple product description pages and then submit a complete product order request from a confirm order page.
  • the ReTA Session framework leverages the Internet Information Server / Active Server Page ( IS/ASP) session object, which is automatically created when a user who has no open IIS sessions requests a Web page.
  • IS/ASP Internet Information Server / Active Server Page
  • FIG 18.1 illustrates a Session Flow Diagram - On Session Start.
  • a Session framework 1830 operates in the MTS Runtime Environment 1832.
  • Figure 19 illustrates a Session Flow Diagram - On Session Start.
  • Session Flow Diagram - On Start ASP Page Again, the Session framework 1900 operates in the MTS Runtime Environment 1902.
  • the ReTA Session framework provides services required throughout a user session. The user creates the Session framework at log on and removes the Session framework at log off. During the lifetime ofthe user session, application and architecture components require certain data to persist. This framework provides services to store and retrieve all information needed for a particular user session. This information may persist throughout the user session.
  • the Session framework also provides services to uniquely identify the user and enforce access rights.
  • the user information that the Session framework persists, in memory, between Active Server Page requests includes:
  • Last page o Last page accessed by the session user.
  • Last connection time o Session user's last connection time.
  • Current activity o Activity currently being executed by the session user (refer to activity framework design)
  • Activity Components o All activity components accessed during user session •
  • Business Components o All business components accessed during user session required by multiple activity components.
  • This framework uses the Active Server Page's Session Object. Thus, the framework only works with browsers that accept cookies. For other browsers (or if cookies are disabled), a new ASP Session Object may start for each web page.
  • the Session Framework provides the following services: Components
  • the Session Framework implements these services through the following COM objects:
  • the AFSession component maintains the user's session state information. To maintain the state information, this component holds references to activity components (logical units of work - application flow logic), business components (business logic required across activity components), user component (user information), tracking manager component (web page access security and web page flow control information), system preference component (system preference information) and event handler component (event handler) created during the user's session.
  • activity components logical units of work - application flow logic
  • business components business logic required across activity components
  • user component user information
  • tracking manager component web page access security and web page flow control information
  • system preference component system preference information
  • event handler component event handler
  • the state maintenance work performed by the AFSession component is transparent.
  • the application developer leverages the session services through populating the database tables with the client specific information.
  • the IAFSession, IAFEventBroadcaster and LAFContext interfaces define the access to the AFSession component. These interfaces support the following methods: ⁇ n_9_ ⁇ Description
  • Stop session - Called by ASP global.asa Session_OnStop.
  • This method is called by ASP script logic at the start of each page. It is used to broadcast a pageStart event to all the listeners (activity components) that have registered as interested in pageStart events. It also stores this page as the current page and moves the existing cunent page into the last page (information held by the session's "tracking" object).
  • This method is called by ASP script logic at the end of each page. It is used to broadcast a pageEnd event to all the listeners (activity components) that have registered as interested in pageEnd events.
  • This method is called when the session is to be aborted. This method calls the abort method on all activity components known to session (held by the session's "activity context" object).
  • Ask session if it has a reference to the requested activity (held by the session's "activity context” object). If found, returns true, else retums false.
  • the AFSystemPreferences component contains system preferences (held during the session). This component uses the ReTA persistence framework to read the system preferences from the database ("system preferences" table).
  • the LAFSystemPreferences interface defines the access to the AFSystemPreferences component. This interface supports the following methods:
  • the AFTrackingManager component provides page sequence security, dialogue flow and activity flow functionality for the session framework.
  • Page sequence security The page sequence security is defined in the following tables:
  • the dialogue flow is defined in the following table:
  • the LAFTrackingManager interface 1904 defines the access to the AFTrackingManager component. This interface supports the following methods:
  • the AFBrowserlnfo component contains the user's browser information.
  • the IAFBrowserlnfo and lAFEditable interfaces define the access to the AFBrowserlnfo component. These interfaces support the following methods:
  • Figure 20 illustrates a method 2000 for generating a graphical user interface.
  • a form is initially created in operation 2002.
  • the form includes a plurality of attribute mles dictating a manner in which user interface objects are situated thereon.
  • a plurality of user interface objects are selected.
  • a page is generated in operation 2006 with the selected user interface objects situated on the page in accordance with the attribute mles ofthe form.
  • JavaScript actions are attached to the selected user interface objects in operation 2008. The JavaScript actions are capable of being executed upon detection of a user action involving one ofthe user interface objects.
  • the user interface objects may include one or more ofthe following: a push button, a text box, a text area, a radio button, a check box, a drop down, a blank item, a user interface list, and a static table.
  • the user action may include at least one of clicking on one ofthe user interface objects, changing text in one ofthe interface objects, exiting a text box of one ofthe interface objects. Further, the user action involving one ofthe user interface objects may cause a predetermined event.
  • the page may be an HTML page.
  • UI ReTA User Interface
  • the role of this framework is to provide services that generate the HTML code for UI widgets and attach Javascript actions to UI widgets.
  • the UI framework exposes these services through a set of Component Object Model (COM) objects.
  • COM Component Object Model
  • the application developer uses these UI COM objects and their services through scripting logic added to the application's Active Server Pages (ASP).
  • ASP Active Server Pages
  • the User Interface framework provides components for generating HTML.
  • An HTML page is generated from a combination ofthe various UI Components.
  • Figure 20.1 shows the steps for generating a HTML page consisting of a form 2030 with a TextBox 2032, a DropDown list 2034 and a PushButton 2036.
  • the User Interface Framework provides the following services:
  • the User Interface Framework implements these services through the following COM objects: These components are described in detail in the following sub-portions ofthe description.
  • the AFForm component is used in conjunction with form element widgets to build complex user interfaces, initially, the application creates an instance ofthe form component and sets its attributes. Following this activity, the application creates instances ofthe associated form element widgets and adds them to the form using the form's add method. As another service, the form component provides methods to help align all associated form element widgets properly on the page.
  • the LAFForm interface defines the access to the AFForm component. This interface supports the following methods, which the developer uses to create a form.
  • the AFPushbutton component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • An action object can be attached to a AFPushButton component. (Refer to AFHardCodedASPAction and AFJScriptAction for details).
  • the IAFPushbutton and IAFUIActionltem interfaces define the access to the AFPushbutton component. These interfaces support the following methods, which the developer uses to create a push button form element. iffi u ⁇ i Description
  • the AFTextBox component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • An action object can be attached to a AFTextBox component. (Refer to AFHardCodedASPAction and AFJScriptAction for details).
  • the IAFTextBox and IAFUIActionltem interfaces define the access to the AFTextBox component. These interfaces support the following methods, which the developer uses to create a Text Box form element.
  • AFTextArea component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • An action object can be attached to a AFTextArea component. (Refer to AFHardCodedASP Action and AFJScriptAction for details).
  • the LAFTextArea and IAFUIActionltem interfaces define the access to the AFTextArea component. These interfaces support the following methods, which the developer uses to create a Text Area form element.
  • the AFRadioButton component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • An action object can be attached to a AFRadioButton component. (Refer to AFHardCodedASP Action and AFJScriptAction for details).
  • Radio buttons are used in groups. Because ofthe complexity ofthe client side script required in conjunction with the radio button component, the application developer must call the generateRadioButtonScript () method on the AFScriptgenerator object on the page wherever radio buttons are used. This method takes as inputs:
  • the return value from this method is the generated HTML and Javascript which is written to the client browser within the ⁇ HEAD> ⁇ /HEAD> tag ofthe page.
  • the IAFRadioButton and IAFULActionltem interfaces define the access to the AFRadioButton component. These interfaces support the following methods, which the developer uses to create a Radio Button form element.
  • the AFCheckBox component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • An action object can be attached to a AFCheckBox component. (Refer to AFHardCodedASP Action and AFJScriptAction for details).
  • the IAFCheckBox and IAFULActionltem interfaces define the access to the AFCheckBox component. These interfaces support the following methods, which the developer uses to create a Check Box form element.
  • the AFDropDown component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • An action object can be attached to a AFDropDown component. (Refer to AFHardCodedASP Action and AFJScriptAction for details).
  • the IAFDropDown and IAFULActionltem interfaces define the access to the AFDropDown component. These interfaces support the following methods, which the developer uses to create a Combo Box form element.
  • the AFBlankltem component can only be used in conjunction with a AFForm component (the form's generate method iterates through the generate method for all form element widgets to build the necessary HTML code).
  • the LAFBlankltem interface defines the access to the AFBlankltem component. This interface supports the following methods, which the developer uses to create a blank item form element.
  • the AFUIList component creates a sophisticated DHTML based single-select list box form widget.
  • the list box widget consists of a fixed headings row and a scrollable set of data rows.
  • the list box widget supports data entry through data row level associated check boxes and text boxes.
  • action objects can be attached to the list box and are generated in the same way as described for other form components. (Refer to AFHardCodedASP Action and AFJScriptAction for details).
  • the list box widget refreshes itself by passing (as parameters) the selected item and the state of all check boxes and all text boxes.
  • the AFUIList view captures the values and updates the state ofthe list box to reflect the user choice.
  • LAFUIList interface defines the access to the AFUIList component. This interface supports the following methods, which the developer uses to create a single select list box. iSH ⁇ I Description
  • the AFThumbNailContainer component generates a set of thumbnail images.
  • the thumbnails are used as iconic pushbuttons.
  • the application developer defines the single click and double click action destinations in the ASP page by coding the JavaScript functions referenced by the AFThumbNailContainer "generate" method.
  • the IAFThumbNailContainer interface defines the access to the AFThumbNailContainer component. This interface supports the following methods, which the developer uses to create a Thumbnail container. EEBH Descnption
  • the static table component creates a standard HTML table with the parameters set by the developer through scripting logic added to application's ASP.
  • the LAFStaticTable interface defines the access to the AFStaticTable component. This interface supports the following methods, which the developer uses to create a static HTML table.
  • the AFHardCodedASP Action component adds a user defined automatic navigation action to a UI component.
  • the UI components that support this service include AFPushButton, AFTextBox, AFTextArea, AFRadioButton, AFCheckBox, AFDropDown and AFSelectedList. Attaching the navigation action to a UI item may automatically direct the user to the next page.
  • the next page is identified by the flow control service ofthe session framework. This means that the developer does not have to specify the page to open. This service also ensures that all changes made to the open pages are capture before opening a new one.
  • the navigation action is triggered when the user causes a defined event on the object. Defined events include clicking on a link or button and changing the text or exiting a text box.
  • the Javascript events are onClick and OnChange.
  • the page that represents the target ofthe action must be entered into the database.
  • the action logic may look to see which activity it belongs to and then look in the database to determine what page to show to the user.
  • An example database entry in the T AF FWDestinationforaction table is:
  • the id field must be a unique number, •
  • the current page is the page on which the action is being triggered.
  • the Action is the name ofthe UI item which is triggering the action
  • the Activity is the activity in which the action is taking place.
  • the Destination Page is the page to which the user should be redirected as the outcome of the action.
  • the IAF Action and IAFHardCodedASP Action interface defines the access to the AFHardCodedASPAction component. These interfaces support the following methods, which the developer uses to create a navigational action.
  • the AFJscriptAction component adds a user defined action to a UI Component.
  • the UI components that support this service include AFPushButton, AFTextBox, AFTextArea, AFRadioButton, AFCheckBox, AFDropDown and AFSelectedList. Attaching a Javascript action to a UI item may call a Javascript function when the action is triggered.
  • the application developer creates the called Javascript function on the conect application's ASP.
  • the Javascript action is triggered when the user causes a defined event on the object. Defined events include clicking on a link or button and changing the text or exiting a text box.
  • the Javascript events are onClick and onChange.
  • the LAFAction interface defines the access to the AFJscriptAction component. This interface supports the following methods, which the developer uses to create an action.
  • the AFScriptGenerator component creates the Javascript functions needed by the actions.
  • the IAFScriptGenerator interface defines the access to the AFScriptGenerator component. This interface supports the following methods, which the developer uses to generate the appropriate Javascript functions.
  • the AFStyleSheet Component creates the Cascading Style Sheet text for the application.
  • the I AFStyleSheet interface defines the access to the AFStyleSheet component. This interface supports the following method, which the developer uses to generate the appropriate Cascading Style Sheet text.
  • Figure 21 illustrates a method 2100 for software configuration management.
  • software configuration management units are identified.
  • software configuration management repositories and practices are established for storing work product related to the software configuration management units.
  • a change control process is determined in operation 2106 for implementing change requests relating to the work product.
  • Access to the work product is monitored in operation 2108 by a plurality of users and audits are performed to indicate whether the access to the work product by the users is authorized.
  • training requirements are calculated in operation 2110 by identifying a skill set required for the implementation ofthe change requests and determining a cunent skill set.
  • the software configuration management units may be identified based on configuration types, project baselines, and/or naming standards.
  • the software configuration management units may also have characteristics including a name, a modification log, and a release affiliation. Further, the software configuration management practices may include backing up the repositories.
  • the change control process may include identifying users authorized to implement the change requests, defining criteria for implementing the change requests, allowing evaluation ofthe change requests by the users based on the criteria, and monitoring the implementation ofthe change request.
  • the present invention may also optionally include the creation of a training schedule to fulfill the training requirements. The following material provides a more detailed description ofthe above-described method.
  • the ReTA Development Architecture Design includes a set of sub-components that represent all design aspects ofthe development architecture.
  • the Development Architecture Design Deliverable is used to validate design of the development architecture against the requirements. After it is validated, it may be used as a basis for build and test ofthe architecture.
  • LDEA The ReTA Development Architecture Component Design is based on the LDEA framework 2130. See Figure 21.1.
  • LDEA provides a development environment framework and associated guidelines that reduce the effort and costs involved with designing, implementing, and maintaining an integrated development environment.
  • LDEA takes a holistic approach to the development environment by addressing all three Business Integration components: organization, processes, and tools. In order to accomplish this, several subcomponents 2132 are provided around a central system building 2134.
  • the pu ⁇ ose ofthe development environment is to support the tasks involved in the analysis, design, constmction, and maintenance of business systems, as well as the associated management processes. It is important to note that the environment should adequately support all the development tasks, not just the code/compile/test/debug cycle.
  • the pu ⁇ ose of Software Configuration Management (SCM) 2106 is to establish and maintain the integrity ofthe components of an application throughout the project's life cycle.
  • the project manager is responsible for the completion ofthe Project Configuration Management Plan during Design ⁇ with the help ofthe project team. This may:
  • the ReTA SCM Policy portion ofthe description can assist engagement executives in creating a project configuration management plan.
  • the following table provides a list ofthe active participants within the change control process.
  • a person may have more than one role or responsibility depending on the size ofthe technical effort. Also note that the responsibilities are described here at a high level and are not intended to be all-inclusive. Most ofthe roles are would already exist on an engagement. However, there is one new role that is critical to the CM process, the Source Code Librarian.
  • Configuration Management becomes more complex in a component-based development environment as the system is broken down to a greater level of granularity. For this reason, change control processes need to be clearly defined and communicated across the entire engagement team.
  • the Change Tracking Database is a Microsoft Access tool. It provides basic functionality of entering, modifying and reporting of system change requests encountered throughout the entire project life cycle.
  • the Issues Tracking Database is a Microsoft Access tool that is ideal for small to medium sized projects. It provides basic functionality of entering, modifying and reporting of project issues encountered throughout the entire project life cycle.
  • Figure 23 illustrates the change control 'pipeline' 2300 and each phase within the pipeline.
  • the Change Control process can be divided into many different phases. They include:
  • the first phase 2302 ofthe change control process is to log a change request. Regardless of who initiates a change request and how the change request enters into the engagement work-in- progress pipeline each change request should be logged Change Tracking tool. IT personnel who log change requests should record as much information as possible.
  • the Change Control Committee (CCC) meets regularly to review the change requests that have been logged to the Change Tracking tool in the past week.
  • the committee also discusses the status ofthe changes scheduled for migration during the weekly migration windows, reviews the changes already moved to production, and sets the Staging Date for change requests.
  • the Change Control Committee facilitator may generate the following reports:
  • the meeting the CCC may:
  • the Statement of Work which is cunently in use sometimes in FLP, is a detailed portion ofthe present description that describes the work that may be done for the change request.
  • the Scope Definition portion ofthe present description is a simple portion ofthe present description ofthe scope ofthe change. It can be an email message, a faxed letter, or a brief Microsoft Word portion ofthe present description.
  • the following table shows what is required:
  • the Statement of Work / Scope Definition portion ofthe present description is sent to the change requester for sign-off.
  • the sign-off needs to be checked-off on the Migration Checklist in the Change Tracking Tool in order to migrate the change to production.
  • This sign-off serves as a quality checkpoint that the work on the change request may meet the business needs ofthe change requester.
  • This phase 2308 is required only for project change requests.
  • the developer may create technical analysis and design specifications portion ofthe present descriptions.
  • Other impacted groups may create a technical impact statement.
  • the developer codes the change request and unit tests the code changes to ensure that it works as designed and that it meets the business needs.
  • the developer should set the status ofthe change request in the Change Tracking tool to
  • the developer should fill in the Resolution field for the change request within the Change Tracking Database.
  • the developer should also fill in the approximate number of hours it took to complete the change request in the Actual Hours field.
  • This phase 2312 is required for all project change requests and some enhancements.
  • the developer tests the change to ensure that the system's functionality works as designed. Furthermore, this test also ensures that the code change did not adversely affect other areas ofthe current system. This may entail running some pre-defined System Test scripts. For certain change requests, it is important to test the code change against a large volume of data. This may check if the change may handle all the data in the production environment. For any change requests which may impact interfaces both in and out ofthe target application, it is necessary to test that all the interfaces still work conectly. This may prevent a change request from adversely impacting other systems.
  • the developer should set the status ofthe change request in the Change Tracking tool to "Testing”.
  • the most appropriate person may assume the role ofthe test administrator.
  • the administrator tests the change request to ensure that it meets the original business need.
  • the developer may actually mn the test plans that the test administrator creates, and the test administrator may validate the test results. Once the test administrator agrees that the change satisfies all the test criteria, the developer needs to check the user acceptance test sign-off box in the Change Tracking Tool.
  • the sign-off is needed to migrate the change to production. This sign-off serves as a final quality checkpoint that the work on the change request meets the business needs ofthe change requester.
  • the developer goes through a final process before submitting the change request to be moved to production.
  • the developer should move all objects associated with the change request from the testing environment to the staging area.
  • the developer In order to move the change to production, the developer needs to complete the Migration Checklist form on the Change Tracking Tool and inform Production Control 2316 by the Staging Date.
  • This form contains all the information about the objects that need to be moved from the staging area into the production environment.
  • This form is a streamlined checklist of all the things that the developers must do in order for Production Services personnel to move the objects to production. Whenever a sign-off checkbox is checked or unchecked, the current user's LD and the current date may be captured by the Change Tracking tool.
  • the Ready to Migrate checkbox is used to summarize that all the required sign-offs have been obtained and that the code is ready to be migrated to production. Finally, the developer should set the status ofthe change request in the Change Tracking tool to "Migrate".
  • Production Services personnel may move all project and enhancement change requests to the Production environment during prescheduled outages or immediately in the case of an emergency fix. Production Services may then informing all system users what changes have been moved into production. Production Services personnel should set the status of each migrated change request in the Change Tracking tool to "Production”. They should also set the Actual Implementation Date to the date the change was moved to production.
  • the change request in production caused other problems to jobs in production, and a new fix is needed, the change request is reopened once again. If the change request caused problems in other jobs that requires modification to the other jobs, then a new change request is created, and the source ofthe new request is tracked back to the old request.
  • the Change Tracking tool contains metrics to track the quality ofthe change request.
  • the Change Control Committee may assign the Migration Metric and Production Metric values for each change request approximately 35 days after it was migrated into production. If problems occur during the migration ofthe change request, the Change Control Committee may assign a "Fail” for the Migration Metric. The Problem Description should then be completed to explain why this problem occurred. The Lessons Learned should be filled with what lessons can be learned from the experience. If no problems occur, the Migration Metric may be assigned a "Pass".
  • the Change Control Committee may assign a "Fail" for the Production Metric.
  • the Problem Description and Lessons Learned fields should also be filled with the relevant information.
  • a change request may pass if it meets the following criteria.
  • Flawless movement of all resources (Active Server Pages, MTS Components, Java Classes, Graphics, Data Model, etc.), from the staging environment to the production environment) is required. (I.e., resource movement must have no negative effects.)
  • Production Metric Criteria Production online processing and production batch processing must not experience any release-related abends.
  • the production implementation may not cause problems, interruptions in service or failures in other areas within 35 days ofthe initial implementation date. Any release with is backed out due to quality or problems may fail this criterion.
  • the change must be delivered when planned. A postponement due to external reasons may not cause the change to fail this criterion. Postponements due to quality or readiness of code must be communicated to the Change Control Committee, project team, and customers at least 3 days prior to the scheduled implementation date.
  • Migration Control tools control multiple versions of source code, data, and other items as they are changed, tested, and moved from one development environment into another, for example, from development to test and from test to production.
  • the list below provides a list ofthe various environments and their specific pu ⁇ ose within the project lifecycle.
  • Test are running locally for presentation and business logic.
  • Architecture components are accessed via a mapped network drive.
  • a shared RDBMS Server or a local, more lightweight version ofthe database can be used for database services.
  • both developers may share components and interfaces using drive mappings.
  • the source code is checked into the source code repository and the source code administrator is notified ofthe status.
  • Staging Test This environment is used to verify and test packaged systems and components. This allows developers to verify the functionality and use of third party vendor applications during the Build/Unit Testing phase.
  • Web Server modules include Active Server Pages (ASP), static HTML portion ofthe present descriptions, graphics or images and JavaScript files.
  • ASP and HTML portion ofthe present descriptions may have security restrictions placed on them from within Microsoft Internet Information Server (IIS) and from the Windows NT Server.
  • Security can be set to include individual user accounts, groups/roles, or no security.
  • Application Server - Two file types are migrated within application servers, COM Dynamic Link Library's and Java Classes. Both files are created during the application and architecture build processes.
  • the COM DLL's require registration within MTS by inserting them into a MTS Package.
  • an export process is required between them to instmct the Web server where the business components physically reside. For more information on the registration and exporting processes refer to the MTS online help.
  • Database Server These items include tables, views, sequences, triggers, stored procedures and functions, and user/schema information. These items are not necessarily particular to multi- tiered development. However, care should be taken to ensure that architecture tables and other objects are located separately from the application objects.
  • a component within MTS utilizes role-based security to determine who may or may not have access to a specific COM component.
  • a role is a symbolic name that defines a group of users for a package of components. Roles extend Windows NT security to allow a developer to build secured components in a distributed application.
  • Figure 24 depicts the application of Roles 2400 within the Microsoft Transaction Server Management console 2402.
  • the package labeled 'ReTA Applications' 2404 has a single role defined as being able to access it, 'ReTA User' 2406. Users that are members ofthe local 'ReTA Administrators' and 'ReTA User' Windows NT groups 2408,2410 are allowed to function in the ReTA User capacity defined for this package.

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • Business, Economics & Management (AREA)
  • Entrepreneurship & Innovation (AREA)
  • Human Resources & Organizations (AREA)
  • Strategic Management (AREA)
  • Data Mining & Analysis (AREA)
  • Economics (AREA)
  • Marketing (AREA)
  • Operations Research (AREA)
  • Quality & Reliability (AREA)
  • Tourism & Hospitality (AREA)
  • General Business, Economics & Management (AREA)
  • Human Computer Interaction (AREA)
  • Stored Programmes (AREA)

Abstract

Un système, un procédé et un article de production fournissent une architecture technique de commerce électronique à ressources dans laquelle des objets de contexte sont partagés parmi une pluralité de constituants exécutés sur un serveur de transactions. Il est aussi possible d'accéder à des services à l'intérieur du serveur sans la nécessité d'une connaissance d'une interface de programme d'application du serveur. La cohérence des applications est maintenue par référence aux phrases textuelles au moyen d'une structure de codes courts. De plus, une interface utilisateur graphique est également générée pour l'architecture technique de commerce électronique à ressources.
PCT/US2000/020704 1999-07-30 2000-07-28 Systeme, procede et article de production pour une architecture basee sur le commerce electronique WO2001009794A2 (fr)

Priority Applications (1)

Application Number Priority Date Filing Date Title
AU67504/00A AU6750400A (en) 1999-07-30 2000-07-28 A system, method and article of manufacture for an e-commerce based architecture

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US36473499A 1999-07-30 1999-07-30
US09/364,734 1999-07-30

Publications (2)

Publication Number Publication Date
WO2001009794A2 true WO2001009794A2 (fr) 2001-02-08
WO2001009794A3 WO2001009794A3 (fr) 2001-06-14

Family

ID=23435839

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US2000/020704 WO2001009794A2 (fr) 1999-07-30 2000-07-28 Systeme, procede et article de production pour une architecture basee sur le commerce electronique

Country Status (2)

Country Link
AU (1) AU6750400A (fr)
WO (1) WO2001009794A2 (fr)

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9715439B1 (en) * 2013-04-08 2017-07-25 Amazon Technologies, Inc. Embedded defect reporting system
EP3355601A1 (fr) * 2003-09-05 2018-08-01 Nokia Technologies Oy Service de groupe avec informations sur les membres du groupe
CN111158684A (zh) * 2019-12-30 2020-05-15 北京天融信网络安全技术有限公司 系统创建方法、装置、电子设备及可读存储介质
CN112631599A (zh) * 2020-12-09 2021-04-09 潍柴动力股份有限公司 编译方法、装置和存储介质

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5692132A (en) * 1995-06-07 1997-11-25 Mastercard International, Inc. System and method for conducting cashless transactions on a computer network
US5815657A (en) * 1996-04-26 1998-09-29 Verifone, Inc. System, method and article of manufacture for network electronic authorization utilizing an authorization instrument
WO1999001826A2 (fr) * 1997-07-02 1999-01-14 Business Evolution, Inc. Procede, systeme et produit programme informatique fournissant un service client sur le web

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5692132A (en) * 1995-06-07 1997-11-25 Mastercard International, Inc. System and method for conducting cashless transactions on a computer network
US5815657A (en) * 1996-04-26 1998-09-29 Verifone, Inc. System, method and article of manufacture for network electronic authorization utilizing an authorization instrument
WO1999001826A2 (fr) * 1997-07-02 1999-01-14 Business Evolution, Inc. Procede, systeme et produit programme informatique fournissant un service client sur le web

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP3355601A1 (fr) * 2003-09-05 2018-08-01 Nokia Technologies Oy Service de groupe avec informations sur les membres du groupe
US9715439B1 (en) * 2013-04-08 2017-07-25 Amazon Technologies, Inc. Embedded defect reporting system
CN111158684A (zh) * 2019-12-30 2020-05-15 北京天融信网络安全技术有限公司 系统创建方法、装置、电子设备及可读存储介质
CN112631599A (zh) * 2020-12-09 2021-04-09 潍柴动力股份有限公司 编译方法、装置和存储介质
CN112631599B (zh) * 2020-12-09 2024-03-19 潍柴动力股份有限公司 编译方法、装置和存储介质

Also Published As

Publication number Publication date
WO2001009794A3 (fr) 2001-06-14
AU6750400A (en) 2001-02-19

Similar Documents

Publication Publication Date Title
US6718535B1 (en) System, method and article of manufacture for an activity framework design in an e-commerce based environment
US6601233B1 (en) Business components framework
US6523027B1 (en) Interfacing servers in a Java based e-commerce architecture
US7100195B1 (en) Managing user information on an e-commerce system
US6609128B1 (en) Codes table framework design in an E-commerce architecture
US6633878B1 (en) Initializing an ecommerce database framework
US6704873B1 (en) Secure gateway interconnection in an e-commerce based environment
WO2001009752A2 (fr) Systeme, procede et article de production destines a la conception d'une structure d'ordinateur central dans une architecture de commerce electronique
US6701514B1 (en) System, method, and article of manufacture for test maintenance in an automated scripting framework
US7437614B2 (en) Synchronization in an automated scripting framework
US6502102B1 (en) System, method and article of manufacture for a table-driven automated scripting architecture
EP1269321B1 (fr) Procede et systeme permettant une solution de script informatisee pour mise a l'essai en entreprise
US6477665B1 (en) System, method, and article of manufacture for environment services patterns in a netcentic environment
US6615199B1 (en) Abstraction factory in a base services pattern environment
US6434568B1 (en) Information services patterns in a netcentric environment
US6434628B1 (en) Common interface for handling exception interface name with additional prefix and suffix for handling exceptions in environment services patterns
US6339832B1 (en) Exception response table in environment services patterns
US6615253B1 (en) Efficient server side data retrieval for execution of client side applications
US6477580B1 (en) Self-described stream in a communication services patterns environment
US6606660B1 (en) Stream-based communication in a communication services patterns environment
US6601192B1 (en) Assertion component in environment services patterns
US6640244B1 (en) Request batcher in a transaction services patterns environment
US6438594B1 (en) Delivering service to a client via a locally addressable interface
US6571282B1 (en) Block-based communication in a communication services patterns environment
US6715145B1 (en) Processing pipeline in a base services pattern environment

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A2

Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GE GH GM HR HU ID IL IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG US UZ VN YU ZW

AL Designated countries for regional patents

Kind code of ref document: A2

Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG

121 Ep: the epo has been informed by wipo that ep was designated in this application
AK Designated states

Kind code of ref document: A3

Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GE GH GM HR HU ID IL IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG US UZ VN YU ZW

AL Designated countries for regional patents

Kind code of ref document: A3

Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG

DFPE Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101)
REG Reference to national code

Ref country code: DE

Ref legal event code: 8642

122 Ep: pct application non-entry in european phase
NENP Non-entry into the national phase in:

Ref country code: JP