EP1877898A1

EP1877898A1 - Method of creating customisable applications

Info

Publication number: EP1877898A1
Application number: EP06764574A
Authority: EP
Inventors: John Pritchard; Olivier Poupeney
Original assignee: Ecensity Corp
Current assignee: Ecensity Corp
Priority date: 2005-05-02
Filing date: 2006-04-28
Publication date: 2008-01-16
Also published as: WO2006117467A1; FR2885242B1; US20060248097A1; FR2885242A1

Abstract

The invention relates to a method of creating an application corresponding to a set of components, the execution of which produces a result that is adapted as a function of the use conditions of the application. The inventive method comprises the generation of a set of DOM-type XML documents containing the non-generic software of the application, the generic software being associated with Java classes that are linked to certain elements of the DOM documents. According to the invention, the wholly original method enables users simply to modify the application without having to recompile all of the executables.

Description

CREATING CUSTOMIZABLE APPLICATIONS

The present invention relates to the field of creating computer applications, in particular customizable applications.

The present invention relates more particularly to a method for creating customizable applications whose display may depend on the conditions of use, the identity or the profile of the user.

It is advantageous to customize the display of applications for different users. For example, it may be desired to display only a first information content for a first type of client, and to display a second type of information for a second type of client. One can also, for the same content, want to vary the display of said content.

The prior art has already proposed a technical solution to this problem of personalization by proposing an architecture in the form of a source of structured information, such as a relational or XML database, including the definition and the relative data. personalization information, as well as the links between each type of information (eg profile, page, ...). The various application components, for example java type, allow the display of the personalized pages by call to an application programming interface (API), composed of a set of object classes, which encapsulates the access to the application. source and recovery of the personalization information, which is then processed and returned to application components as a customized result. FIG. 1 describes such a solution of the prior art in which the customization is carried out by the call to java classes containing specific code, to a data source, for example of the relational database type. This database includes customization information used to provide a customized result based on the user, A or B.

In operation, an application component, for example a Web component, calls a Java class using parameters associated with the user A. This class is possibly guided by an ancestor Java class, which encapsulates the generic logic. The logic of the Java class then handles a set of queries and responses from the data source containing personalization information and processes this information so as to render a personalized result A.

It is important to understand that in this type of configuration, specific and generic java programs that reference the application programming interface are compiled, and adding or modifying a new customization attribute in the database requires on the one hand the update and the migration of existing information, but also the modification and recompilation of the java code of the API. In this case, you should also modify and recompile all programs that use the API.

More precisely, if we modify the structure of the data source, and we change the references between the data, we must also change the classes Java containing non-generic logic associated with this information to take into account the new information and thus to recompile these classes.

It is understood that this constraint is a disadvantage for the evolution of the tool for generating customizable applications.

This disadvantage is solved by the method and the computer program as claimed.

According to the invention, there is provided a method for creating an application corresponding to a set of components, the execution of which provides a result adapted according to the conditions of use of said application comprising:

. a first preliminary step of creating an application consisting in: defining a first set of XML documents whose nodes represent said conditions of use;

- Define a second set of XML documents whose nodes represent the components of said application;

each of said first and second sets comprising XML documents comprising a first type of node associated with an executable and a second type of node defining a reference to an XML document of said first and second set; the documents of the second set comprising a third type of node defining a reference an XML document of the same second set and representing a component of the same type;

. A second step of executing said application consisting in: reading with the help of an interpreter, a document of the second set for the interpretation of all of its nodes and the nodes of the referenced documents of said first and second set the interpretation of each node of the first type allowing executions of said associated executables;

Storing, in an application context, the results of said executions of said executables; - Return the content of said application context.

The invention also relates to a computer program, possibly stored on a data carrier, for implementing the method according to the invention.

According to the invention, the set of specific logic that was present in Java classes compiled according to the prior art is now obtained in the form of a DOM (Document Object Model) thus realizing a program of XML type.

The invention will be better understood from the following description, given purely for explanatory purposes, of one embodiment of the invention, with reference to the appended figures: FIG. 1 illustrates the method and personalization architecture according to the prior art; FIG. 2 illustrates the method and the customization architecture according to the invention. FIG. 3 represents a specific example of personalization DOM according to the invention.

FIGS. 4a to 4c correspond to an exemplary XML code for the implementation of the present invention.

Illustrated in FIG. 2, according to the invention, a set of DOM A is defined having as nodes the elements corresponding to the presentation information. This DOM A therefore comprises elements that represent the non-generic logic for the INFO personalization information that it defines.

First of all, it should be noted that throughout the following, the notion of inheritance is used in the sense known to those skilled in the field of programming, such as, for example, an inheritance of object classes (ex: java).

This first DOM has thus inherited a second type of

DOM B. Each element of the DOM A thus comprises either all of the personalization information necessary for personalization, or only part of it, the information complement being contained in the DOM B which it inherits.

In addition, DOM A elements may refer to other C DOMs in the sense of the reference XML to complete the information elements necessary for customization.

Each type of element representing the nodes of the DOMs according to the invention refers to a Java class containing a generic logic. A specific interpreter then interprets the elements to call the correct Java class.

It is therefore easy to understand that this data structure makes it possible, when it is desired to modify personalization attributes, not to recompile a Java class that includes non-generic code, but simply to add a DOM or an element referencing a DOM that incorporates the code. information to add.

The invention is now more specifically described in the context of a profile as illustrated in FIG. 3. The DOM referenced 1 comprises an element

"Space Presentation" the corresponding to the different information of presentation of a page. This DOM 1 comprises a "Profile" element Ib which refers to a referenced DOM 2 comprising a "Profile" element 2a, named "Customer" 2b. This profile corresponds for example to the type of client by default.

When connecting a customer of type "Customer", and at the time of the interpretation of the DOM, the reference between the DOM 1 and 2 allows the call for this type of client, elements of the type "displet" Id , the If, and the display of the displets "Displet 1" and "Displet 2" as defined in the DOM 1. This display is realized by execution of a java class associated for example with the "Object presentation" elements 6c of the Displet βa element of the DOM 6.

If we define this time a particular type of customer of type "GoId", by creating a new DOM 3 including a 3b element of the type "Profile" of name

"GoId", and that it is desired associated with this type of client a specific display of a displet "Displet 3".

In this case, another DOM 4 is created comprising a "presentation space" type element 4a which on the one hand inherits the DOM 1 in order to also display for the client "GoId" the displets 1 and 2, and which of On the other hand, there is a "Profile" element 4b that references the DOM 3. In this way, the displet "Displet 3" will be displayed for "GoId" type clients but not for the type-only clients. "Customer".

So we understand that to add a profile with particular attributes, it is not necessary to modify the profile information structure and recompile the existing classes, but simply to create a new DOM inheriting from existing DOMs for the type of modification to be performed, and referencing a new profile corresponding to the profile to be added.

FIGS. 4a to 4c illustrate an exemplary code associated with the situation of FIG. 3. FIG. 4a corresponds to a DOM type application component, which assigns the profile called "Demo" to the current user, and therefore, according to FIG. invention, refers to the DOM "demo" of Figure 4b, by the instruction <node: push src = "profiles: demo"/> • The value of the displet element b is then searched for the "Demo" profile. The <node: push src≈ "profiles: demo"/> statement puts the information about the "Demo" profile in context. The <node: path-select select = "/ profile / displet / b"/> and <core: echo /> statements select the displet / b element and display this element, for the "Demo" profile.

Figure 4b, by the "parent" node, there is a reference to the "guest" DOM containing the displet / b element. The interpreter will thus construct the context by placing the information of the "Demo" profile (DOM of FIG. 4b) and adding the information of its "guest" parent profile (DOM of FIG. 4c).

In the DOMs of FIGS. 4a to 4c, each "displet" type node calls a java executable, which processes the information.

Those skilled in the art will understand in this example the advantage of the present invention. Indeed, if one wishes to add a profile "Demo2", it is enough to create the DOM "demo2" and to modify the references in the initial DOM of figure 4a, without modifying the associated class java.

The invention is described in the foregoing by way of example. It is understood that the skilled person is able to realize different variants of the invention without departing from the scope of the patent.

Claims

A method of creating an application corresponding to a set of components, the execution of which provides a result adapted according to the conditions of use of said application comprising:

. a first preliminary step of creating an application consisting of:

- Define a first set (2,3) of XML documents whose nodes (2a, 3 &) represent said conditions of use;

- Define a second set (1, 4, 6, 5) of XML documents whose nodes represent the components of said application; each of said first and second sets comprising XML documents comprising a first type of node (6c, 5c) associated with an executable and a second type of node (Ib, 4b) defining a reference to an XML document of said first and second set; the documents of the second set comprising a third type of node (4a) defining a reference to an XML document of the same second set and representing a component of the same type;

. A second step of executing said application consists in: reading with an interpreter, a document of the second set for the interpretation of all of its nodes and the nodes of the referenced documents of said first and second together, the interpretation of each node of the first type (5c, 6c) allowing the executions of said associated executables;

- Store, in an application context, the results of said executions of said executables;

- Return the content of said application context.

2. Method according to claim 1, characterized in that said executable is a Java class.

3. Method according to claim 1 or 2, characterized in that said execution is performed on a server.

4. Method according to claim 1 or 2, characterized in that said execution is performed on a client station.

5. Method according to claim 1, characterized in that said conditions of use correspond to a profile of a user.

6. Computer program characterized in that it comprises a set of instructions for the implementation of the method according to any one of claims 1 to 5.